boutpp package

Module contents

class boutpp.Coordinates

Contains information about geometry, such as metric tensors

Bxy

libboutpp.Field2D

Type:

Bxy

G1

libboutpp.Field2D

Type:

G1

G1_11

libboutpp.Field2D

Type:

G1_11

G1_12

libboutpp.Field2D

Type:

G1_12

G1_13

libboutpp.Field2D

Type:

G1_13

G1_22

libboutpp.Field2D

Type:

G1_22

G1_23

libboutpp.Field2D

Type:

G1_23

G1_33

libboutpp.Field2D

Type:

G1_33

G2

libboutpp.Field2D

Type:

G2

G2_11

libboutpp.Field2D

Type:

G2_11

G2_12

libboutpp.Field2D

Type:

G2_12

G2_13

libboutpp.Field2D

Type:

G2_13

G2_22

libboutpp.Field2D

Type:

G2_22

G2_23

libboutpp.Field2D

Type:

G2_23

G2_33

libboutpp.Field2D

Type:

G2_33

G3

libboutpp.Field2D

Type:

G3

G3_11

libboutpp.Field2D

Type:

G3_11

G3_12

libboutpp.Field2D

Type:

G3_12

G3_13

libboutpp.Field2D

Type:

G3_13

G3_22

libboutpp.Field2D

Type:

G3_22

G3_23

libboutpp.Field2D

Type:

G3_23

G3_33

libboutpp.Field2D

Type:

G3_33

IntShiftTorsion

libboutpp.Field2D

Type:

IntShiftTorsion

J

libboutpp.Field2D

Type:

J

ShiftTorsion

libboutpp.Field2D

Type:

ShiftTorsion

dx

libboutpp.Field2D

Type:

dx

dy

libboutpp.Field2D

Type:

dy

dz

libboutpp.Field2D

Type:

dz

g11

libboutpp.Field2D

Type:

g11

g12

libboutpp.Field2D

Type:

g12

g13

libboutpp.Field2D

Type:

g13

g22

libboutpp.Field2D

Type:

g22

g23

libboutpp.Field2D

Type:

g23

g33

libboutpp.Field2D

Type:

g33

g_11

libboutpp.Field2D

Type:

g_11

g_12

libboutpp.Field2D

Type:

g_12

g_13

libboutpp.Field2D

Type:

g_13

g_22

libboutpp.Field2D

Type:

g_22

g_23

libboutpp.Field2D

Type:

g_23

g_33

libboutpp.Field2D

Type:

g_33

boutpp.D2DX2(Field3D field, outloc=u'CELL_DEFAULT', method=u'DIFF_DEFAULT', region=u'RGN_NOBNDRY')

Compute the derivative D2DX2

Parameters:
  • field (Field3D) – The Field3D object of which to calculate the derivative

  • outloc (string) – The location where the derivative is expected. Defaults to the same as field.

  • method (string) – The method to calculate the derivative.

  • region (string) – The region for which to calculate the derivative

Returns:

The computed D2DX2 derivative

Return type:

Field3D

boutpp.D2DXDY(Field3D field, outloc=u'CELL_DEFAULT', method=u'DIFF_DEFAULT', region=u'RGN_NOBNDRY')

Compute the derivative D2DXDY

Parameters:
  • field (Field3D) – The Field3D object of which to calculate the derivative

  • outloc (string) – The location where the derivative is expected. Defaults to the same as field.

  • method (string) – The method to calculate the derivative.

  • region (string) – The region for which to calculate the derivative

Returns:

The computed D2DXDY derivative

Return type:

Field3D

boutpp.D2DXDZ(Field3D field, outloc=u'CELL_DEFAULT', method=u'DIFF_DEFAULT', region=u'RGN_NOBNDRY')

Compute the derivative D2DXDZ

Parameters:
  • field (Field3D) – The Field3D object of which to calculate the derivative

  • outloc (string) – The location where the derivative is expected. Defaults to the same as field.

  • method (string) – The method to calculate the derivative.

  • region (string) – The region for which to calculate the derivative

Returns:

The computed D2DXDZ derivative

Return type:

Field3D

boutpp.D2DY2(Field3D field, outloc=u'CELL_DEFAULT', method=u'DIFF_DEFAULT', region=u'RGN_NOBNDRY')

Compute the derivative D2DY2

Parameters:
  • field (Field3D) – The Field3D object of which to calculate the derivative

  • outloc (string) – The location where the derivative is expected. Defaults to the same as field.

  • method (string) – The method to calculate the derivative.

  • region (string) – The region for which to calculate the derivative

Returns:

The computed D2DY2 derivative

Return type:

Field3D

boutpp.D2DYDZ(Field3D field, outloc=u'CELL_DEFAULT', method=u'DIFF_DEFAULT', region=u'RGN_NOBNDRY')

Compute the derivative D2DYDZ

Parameters:
  • field (Field3D) – The Field3D object of which to calculate the derivative

  • outloc (string) – The location where the derivative is expected. Defaults to the same as field.

  • method (string) – The method to calculate the derivative.

  • region (string) – The region for which to calculate the derivative

Returns:

The computed D2DYDZ derivative

Return type:

Field3D

boutpp.D2DZ2(Field3D field, outloc=u'CELL_DEFAULT', method=u'DIFF_DEFAULT', region=u'RGN_NOBNDRY')

Compute the derivative D2DZ2

Parameters:
  • field (Field3D) – The Field3D object of which to calculate the derivative

  • outloc (string) – The location where the derivative is expected. Defaults to the same as field.

  • method (string) – The method to calculate the derivative.

  • region (string) – The region for which to calculate the derivative

Returns:

The computed D2DZ2 derivative

Return type:

Field3D

boutpp.DDX(Field3D field, outloc=u'CELL_DEFAULT', method=u'DIFF_DEFAULT', region=u'RGN_NOBNDRY')

Compute the derivative DDX

Parameters:
  • field (Field3D) – The Field3D object of which to calculate the derivative

  • outloc (string) – The location where the derivative is expected. Defaults to the same as field.

  • method (string) – The method to calculate the derivative.

  • region (string) – The region for which to calculate the derivative

Returns:

The computed DDX derivative

Return type:

Field3D

boutpp.DDY(Field3D field, outloc=u'CELL_DEFAULT', method=u'DIFF_DEFAULT', region=u'RGN_NOBNDRY')

Compute the derivative DDY

Parameters:
  • field (Field3D) – The Field3D object of which to calculate the derivative

  • outloc (string) – The location where the derivative is expected. Defaults to the same as field.

  • method (string) – The method to calculate the derivative.

  • region (string) – The region for which to calculate the derivative

Returns:

The computed DDY derivative

Return type:

Field3D

boutpp.DDZ(Field3D field, outloc=u'CELL_DEFAULT', method=u'DIFF_DEFAULT', region=u'RGN_NOBNDRY')

Compute the derivative DDZ

Parameters:
  • field (Field3D) – The Field3D object of which to calculate the derivative

  • outloc (string) – The location where the derivative is expected. Defaults to the same as field.

  • method (string) – The method to calculate the derivative.

  • region (string) – The region for which to calculate the derivative

Returns:

The computed DDZ derivative

Return type:

Field3D

boutpp.Delp2(Field3D a)
boutpp.Div_par(Field3D field, outloc=u'CELL_DEFAULT', method=u'DIFF_DEFAULT')

Compute the derivative Div_par

Parameters:
  • field (Field3D) – The Field3D object of which to calculate the derivative

  • outloc (string) – The location where the derivative is expected. Defaults to the same as field.

  • method (string) – The method to calculate the derivative.

Returns:

The computed Div_par derivative

Return type:

Field3D

boutpp.FDDX(Field3D velocity, Field3D field, outloc=u'CELL_DEFAULT', method=u'DIFF_DEFAULT', region=u'RGN_NOBNDRY')

Compute the flux derivative FDDX

Parameters:
  • velocity (Field3D) – The Field3D object of which the field is advected

  • field (Field3D) – The Field3D object of which to calculate the derivative

  • outloc (string) – The location where the derivative is expected. Defaults to the same as field.

  • method (string) – The method to calculate the derivative.

  • region (string) – The region for which to calculate the derivative

Returns:

The computed FDDX derivative

Return type:

Field3D

boutpp.FDDY(Field3D velocity, Field3D field, outloc=u'CELL_DEFAULT', method=u'DIFF_DEFAULT', region=u'RGN_NOBNDRY')

Compute the flux derivative FDDY

Parameters:
  • velocity (Field3D) – The Field3D object of which the field is advected

  • field (Field3D) – The Field3D object of which to calculate the derivative

  • outloc (string) – The location where the derivative is expected. Defaults to the same as field.

  • method (string) – The method to calculate the derivative.

  • region (string) – The region for which to calculate the derivative

Returns:

The computed FDDY derivative

Return type:

Field3D

boutpp.FDDZ(Field3D velocity, Field3D field, outloc=u'CELL_DEFAULT', method=u'DIFF_DEFAULT', region=u'RGN_NOBNDRY')

Compute the flux derivative FDDZ

Parameters:
  • velocity (Field3D) – The Field3D object of which the field is advected

  • field (Field3D) – The Field3D object of which to calculate the derivative

  • outloc (string) – The location where the derivative is expected. Defaults to the same as field.

  • method (string) – The method to calculate the derivative.

  • region (string) – The region for which to calculate the derivative

Returns:

The computed FDDZ derivative

Return type:

Field3D

class boutpp.Field2D

The Field2D class

applyBoundary(self, boundary=None, time=None)

Set the boundaries of a Field2D. Only one of both arguments can be provided. If no value is provided, the default boundary is applied.

Parameters:
  • boundary (string, optional) – The boundary to be set. Has to be a valid boundary type, e.g. “neumann”.

  • time (float, optional) – The time to be used by the boundary, if time dependent boundary conditions are used.

ddt(self, val=None)

Get or set the time derivative

Parameters:

val (Field2D, optional) – If set, set the time derivative to val

Returns:

The time derivative

Return type:

Field2D

classmethod fromBoutOutputs(cls, outputs, name, tind=-1, mesh=None, ignoreDataType=False)

Create a Field2D from reading in a datafile via collect.

Parameters:
  • outputs (BoutOutputs) – object to read from

  • tind (int, optional) – time slice to read

  • mesh (Mesh, optional) – if not defined, use global mesh

  • ignoreDataType (bool, optional) – Do not fail if data is not float64

  • **kwargs – remaining arguments are passed to collect

classmethod fromCollect(cls, name, tind=-1, mesh=None, ignoreDataType=False, **kwargs)

Create a Field2D from reading in a datafile via collect.

Parameters:
  • tind (int, optional) – time slice to read

  • mesh (Mesh, optional) – if not defined, use global mesh

  • ignoreDataType (bool, optional) – Do not fail if data is not float64

  • **kwargs – remaining arguments are passed to collect

classmethod fromMesh(cls, mesh=None)

Create a Field2D.

Parameters:

mesh (Mesh, optional) – The mesh of the Field2D. If None, use global mesh

get(self)

Get all data of the Field2D

Returns:

A 2D numpy array with the data of the Field2D

Return type:

array

getAll(self)

Get all data of the Field2D

Returns:

A 2D numpy array with the data of the Field2D

Return type:

array

getLocation(self)

Get the location of the Field2D

Returns:

Representation of the field’s location.

Return type:

string

getMesh(self)

Get the mesh associated with the field

Returns:

The mesh of the field

Return type:

bc.Mesh

isAllocated(self)

Check if the Field2D has its own datablock allocated

Returns:

whether the Field is allocated

Return type:

bool

set(self, data, ignoreDataType=False)

Set all data of the Field2D

Parameters:
  • data (array_like) – The data to be set

  • ignoreDataType (bool, optional) – Ignore if data is off different type to BoutReal

setAll(self, data, ignoreDataType=False)

Set all data of the Field2D

Parameters:
  • data (array_like) – The data to be set

  • ignoreDataType (bool, optional) – Ignore if data is off different type to BoutRealxx

setLocation(self, location)

Set the location of the Field2D This does not do any modification of the data.

Parameters:

location (string) – The location to be set, e.g. “YLOW” or “CELL_YLOW” are supported.

class boutpp.Field3D

The Field3D class

applyBoundary(self, boundary=None, time=None)

Set the boundaries of a Field3D. Only one of both arguments can be provided. If no value is provided, the default boundary is applied.

Parameters:
  • boundary (string, optional) – The boundary to be set. Has to be a valid boundary type, e.g. “neumann”.

  • time (float, optional) – The time to be used by the boundary, if time dependent boundary conditions are used.

applyParallelBoundary(self, boundary=None, time=None)

Set the boundaries of a Field3D. Only one of both arguments can be provided. If no value is provided, the default boundary is applied.

Parameters:
  • boundary (string, optional) – The boundary to be set. Has to be a valid boundary type, e.g. “neumann”.

  • time (float, optional) – The time to be used by the boundary, if time dependent boundary conditions are used.

ddt(self, val=None)

Get or set the time derivative

Parameters:

val (Field3D, optional) – If set, set the time derivative to val

Returns:

The time derivative

Return type:

Field3D

classmethod fromBoutOutputs(cls, outputs, name, tind=-1, mesh=None, ignoreDataType=False)

Create a Field3D from reading in a datafile via collect.

Parameters:
  • outputs (BoutOutputs) – object to read from

  • tind (int, optional) – time slice to read

  • mesh (Mesh, optional) – if not defined, use global mesh

  • ignoreDataType (bool, optional) – Do not fail if data is not float64

  • **kwargs – remaining arguments are passed to collect

classmethod fromCollect(cls, name, tind=-1, mesh=None, ignoreDataType=False, **kwargs)

Create a Field3D from reading in a datafile via collect.

Parameters:
  • tind (int, optional) – time slice to read

  • mesh (Mesh, optional) – if not defined, use global mesh

  • ignoreDataType (bool, optional) – Do not fail if data is not float64

  • **kwargs – remaining arguments are passed to collect

classmethod fromMesh(cls, mesh=None)

Create a Field3D.

Parameters:

mesh (Mesh, optional) – The mesh of the Field3D. If None, use global mesh

get(self)

Get all data of the Field3D

Returns:

A 3D numpy array with the data of the Field3D

Return type:

array

getAll(self)

Get all data of the Field3D

Returns:

A 3D numpy array with the data of the Field3D

Return type:

array

getLocation(self)

Get the location of the Field3D

Returns:

Representation of the field’s location.

Return type:

string

getMesh(self)

Get the mesh associated with the field

Returns:

The mesh of the field

Return type:

bc.Mesh

isAllocated(self)

Check if the Field3D has its own datablock allocated

Returns:

whether the Field is allocated

Return type:

bool

set(self, data, ignoreDataType=False)

Set all data of the Field3D

Parameters:
  • data (array_like) – The data to be set

  • ignoreDataType (bool, optional) – Ignore if data is off different type to BoutReal

setAll(self, data, ignoreDataType=False)

Set all data of the Field3D

Parameters:
  • data (array_like) – The data to be set

  • ignoreDataType (bool, optional) – Ignore if data is off different type to BoutRealxx

setLocation(self, location)

Set the location of the Field3D This does not do any modification of the data.

Parameters:

location (string) – The location to be set, e.g. “YLOW” or “CELL_YLOW” are supported.

class boutpp.FieldFactory
boutpp.Grad(Field3D field, outloc=u'CELL_DEFAULT', method=u'DIFF_DEFAULT')

Compute the derivative Grad

Parameters:
  • field (Field3D) – The Field3D object of which to calculate the derivative

  • outloc (string) – The location where the derivative is expected. Defaults to the same as field.

  • method (string) – The method to calculate the derivative.

Returns:

The computed Grad derivative

Return type:

Vector3D

boutpp.Grad_par(Field3D field, outloc=u'CELL_DEFAULT', method=u'DIFF_DEFAULT')

Compute the derivative Grad_par

Parameters:
  • field (Field3D) – The Field3D object of which to calculate the derivative

  • outloc (string) – The location where the derivative is expected. Defaults to the same as field.

  • method (string) – The method to calculate the derivative.

Returns:

The computed Grad_par derivative

Return type:

Field3D

boutpp.Grad_perp(Field3D field, outloc=u'CELL_DEFAULT', method=u'DIFF_DEFAULT')

Compute the derivative Grad_perp

Parameters:
  • field (Field3D) – The Field3D object of which to calculate the derivative

  • outloc (string) – The location where the derivative is expected. Defaults to the same as field.

  • method (string) – The method to calculate the derivative.

Returns:

The computed Grad_perp derivative

Return type:

Vector3D

boutpp.Grad_perp_dot_Grad_perp(Field3D a, Field3D b)
Parameters:
  • a (Field3D) – The left field of the multiplication

  • b (Field3D) – The right field of the multiplication

Returns:

the scalar product of the perpendicular gradient contributions

Return type:

Field3D

boutpp.Laplace(Field3D a)

Compute the full Laplacian nabla^2(a)

Parameters:

a (Field3D) – The Field3D object of which to calculate the derivative

Returns:

The computed Laplacian

Return type:

Field3D

class boutpp.Laplacian(section=None)

Laplacian inversion solver

Compute the Laplacian inversion of objects.

Equation solved is: dnabla^2_perp x + (1/c1)nabla_perp c2cdotnabla_perp x + exnabla_x x + eznabla_z x + a x = b

setCoefA(self, Field3D A)

Set the “A” coefficient of the Laplacian solver

Parameters:

A (Field3D) – Field to set as coefficient

setCoefC(self, Field3D C)

Set the “C” coefficient of the Laplacian solver

Parameters:

C (Field3D) – Field to set as coefficient

setCoefC1(self, Field3D C1)

Set the “C1” coefficient of the Laplacian solver

Parameters:

C1 (Field3D) – Field to set as coefficient

setCoefC2(self, Field3D C2)

Set the “C2” coefficient of the Laplacian solver

Parameters:

C2 (Field3D) – Field to set as coefficient

setCoefD(self, Field3D D)

Set the “D” coefficient of the Laplacian solver

Parameters:

D (Field3D) – Field to set as coefficient

setCoefEx(self, Field3D Ex)

Set the “Ex” coefficient of the Laplacian solver

Parameters:

Ex (Field3D) – Field to set as coefficient

setCoefEz(self, Field3D Ez)

Set the “Ez” coefficient of the Laplacian solver

Parameters:

Ez (Field3D) – Field to set as coefficient

setCoefs(self, **kwargs)

Set the coefficients for the Laplacian solver. The coefficients A, C, C1, C2, D, Ex and Ez can be passed as keyword arguments

solve(self, Field3D x, Field3D guess)

Calculate the Laplacian inversion

Parameters:
  • x (Field3D) – Field to be inverted

  • guess (Field3D) – initial guess for the inversion

Returns:

the inversion of x, where guess is a guess to start with

Return type:

Field3D

class boutpp.Mesh(create=True, section=None, options=None)

Mesh class

Contains information about geometry. It contains also the coordinates and is responsible for taking deriavtives.

communicate(self, *args)

Communicate (MPI) the boundaries of the Field3Ds with neighbours

Parameters:

args (Field3D) – Abitrary number of fields

coordinates

Get the Coordinates object of this mesh

classmethod getGlobal(cls)

Get the global Mesh object

Returns:

The global instance

Return type:

Mesh

normalise(self, double norm)

Normalise the mesh.

Usefull if the Options are in SI units, but the simulation is written in Bohm units. Calling it multiple times will not change the mesh, if the normalisation is always the same.

It calls mesh->dx/=norm etc. followed by a call to geometry().

Parameters:

norm (float) – The length with which to rescale

class boutpp.Options(**kwargs)

The Options class

assign(self, value, source='')
assignRepeat(self, value, time_dimension='t', save_repeat=True, source='')
force(self, value, source='')
classmethod fromFile(cls, file)

Create a new Options object by reading a file

Parameters:

file (string) – The path of the file to read

Returns:

The Options object

Return type:

Options

get(self, name, default)

Get an option

Parameters:
  • name (string) – the name of the value to get. Can be relative, e.g. “mesh:ddx:first”.

  • default (bool or string or float) – Depending on the type of the default, different things will be returned. Supported types are bool, string or float

Returns:

See default for the type. The option that was read if available, otherwise default

Return type:

bool or string or float

static root(name='')

Get a section from the global options tree

Parameters:

name (string, optional) – The name of the section. Can contain “:” to specify subsections. Defaults to the root section “”.

Returns:

The Options object

Return type:

Options

set(self, name, value, source='PyInterface', force=False)

Set an option

Parameters:
  • name (string) – the name of the value to be set. Can be relative, e.g. “mesh:ddx:first”.

  • value (string) – the value to be set

  • source (string, optional) – The source of the change. Useful for keeping track of where what was set.

  • force (bool, optional) – If a value is overwritten, an exception is thrown. setting this to True avoids the exception.

class boutpp.PhysicsModel

The PhysicsModel base class for python

To implement your own PhysicsModel derive from this class and provide a rhs function which takes the self and the simulation time as input, and the init function which takes self and whether the simulation has been restarted as an argument.

A complete simulation could look something like this:

import boutpp as bc

bc.init(“mesh:n=48”) class MyModel(bc.PhysicsModel):

def init(self,restart):

self.dens = bc.create3D(“sin(x)”) self.solve_for(n=self.dens)

def rhs(self,time):

self.dens.ddt(bc.DDX(self.dens))

model = MyModel() model.solve()

init(self, restart)

This can be overwritten to do model specific initialization

solve(self)

Call the solver. This makes sure that self.init(restart) and self.rhs(time) are called from the solver.

solve_for(self, *args, **kwargs)

Add Field3D’s to be solved for. Need to pass as name=field - where name is the name that is used e.g. for the dump file and field is a Field3D

Parameters:

kwargs (dictionary of Field2D or Field3D) – Keys must be strings, and value of dict must be the Field3D which should be evolved.

class boutpp.PhysicsModelBase

The PhysicsModelBase in python - better use the PhysicsModel class

setInit(self, init)

set the init function to be called

Parameters:

init (function) – Must not be a method, and must accept an bool (restart) as argument

setRhs(self, rhs)

set the rhs function to be called

Parameters:

rhs (function) – Must not be a method, and must accept an double (time) as argument

solve(self)
solve_for(self, **kwargs)
class boutpp.PythonModelCallback

Needed for callbacks from C++ to python

execute(self, parameter) void
boutpp.VDDX(Field3D velocity, Field3D field, outloc=u'CELL_DEFAULT', method=u'DIFF_DEFAULT', region=u'RGN_NOBNDRY')

Compute the flux derivative VDDX

Parameters:
  • velocity (Field3D) – The Field3D object of which the field is advected

  • field (Field3D) – The Field3D object of which to calculate the derivative

  • outloc (string) – The location where the derivative is expected. Defaults to the same as field.

  • method (string) – The method to calculate the derivative.

  • region (string) – The region for which to calculate the derivative

Returns:

The computed VDDX derivative

Return type:

Field3D

boutpp.VDDY(Field3D velocity, Field3D field, outloc=u'CELL_DEFAULT', method=u'DIFF_DEFAULT', region=u'RGN_NOBNDRY')

Compute the flux derivative VDDY

Parameters:
  • velocity (Field3D) – The Field3D object of which the field is advected

  • field (Field3D) – The Field3D object of which to calculate the derivative

  • outloc (string) – The location where the derivative is expected. Defaults to the same as field.

  • method (string) – The method to calculate the derivative.

  • region (string) – The region for which to calculate the derivative

Returns:

The computed VDDY derivative

Return type:

Field3D

boutpp.VDDZ(Field3D velocity, Field3D field, outloc=u'CELL_DEFAULT', method=u'DIFF_DEFAULT', region=u'RGN_NOBNDRY')

Compute the flux derivative VDDZ

Parameters:
  • velocity (Field3D) – The Field3D object of which the field is advected

  • field (Field3D) – The Field3D object of which to calculate the derivative

  • outloc (string) – The location where the derivative is expected. Defaults to the same as field.

  • method (string) – The method to calculate the derivative.

  • region (string) – The region for which to calculate the derivative

Returns:

The computed VDDZ derivative

Return type:

Field3D

class boutpp.Vector2D

Vector2D class

A vector of Field2D

get(self)

Get all data of the Vector2D

Returns:

A 3D numpy array with the data of the Vector2D

Return type:

np.ndarray

x

The Field2D in x direction

y

The Field2D in y direction

z

The Field2D in z direction

class boutpp.Vector3D

Vector3D class

A vector of Field3D

get(self)

Get all data of the Vector3D

Returns:

A 4D numpy array with the data of the Vector3D

Return type:

np.ndarray

x

The Field3D in x direction

y

The Field3D in y direction

z

The Field3D in z direction

boutpp.Vpar_Grad_par(Field3D velocity, Field3D field, outloc=u'CELL_DEFAULT', method=u'DIFF_DEFAULT')

Compute the flux derivative Vpar_Grad_par

Parameters:
  • velocity (Field3D) – The Field3D object of which the field is advected

  • field (Field3D) – The Field3D object of which to calculate the derivative

  • outloc (string) – The location where the derivative is expected. Defaults to the same as field.

  • method (string) – The method to calculate the derivative.

Returns:

The computed Vpar_Grad_par derivative

Return type:

Field3D

boutpp.abs(a)

Calculate abs of a

Parameters:

a (Field3D or Field2D) – The field for which to calculate abs

Returns:

abs of a

Return type:

Field3D or Field2D

boutpp.bracket(Field3D a, Field3D b, method=u'BRACKET_STD', outloc=u'CELL_DEFAULT')

Calculate the poison bracket for Field3D a and Field3D b.

Parameters:
  • a (Field3D) – The left field in the bracket

  • b (Field3D) – The right field in the bracket

  • method (string) – The method to be used

  • outloc (string) – The location of the calculated derivative

Returns:

The bracket

Return type:

Field3D

boutpp.checkInit()

Assert that boutpp has been initialized

boutpp.cos(a)

Calculate cos of a

Parameters:

a (Field3D or Field2D) – The field for which to calculate cos

Returns:

cos of a

Return type:

Field3D or Field2D

boutpp.create3D(string, Mesh msh=None, outloc=u'CELL_DEFAULT', time=0)

Returns a Field3D from the fieldfactory :Parameters: * string (string) – Expression to create. This can contain references to the options

  • msh (Mesh) – the Mesh to use, defaults to the global mesh.

  • outloc (string) – the cell location of the returned field

  • time (float) – is the time

Returns:

the Field from the expression

Return type:

Field3D

boutpp.cross(Vector3D a, Vector3D b)

Compute the cross product of two vectors

Parameters:

a, b (Vector3D) – The two Vector3D objects of which to calculate the cross product

Returns:

The cross product

Return type:

Vector3D

boutpp.exp(a)

Calculate exp of a

Parameters:

a (Field3D or Field2D) – The field for which to calculate exp

Returns:

exp of a

Return type:

Field3D or Field2D

boutpp.finalise()

Finalize BOUT++ and also MPI. After this most objects and functions are not valid anymore.

Note that this deallocates the C++ objects, thus the python objects might not work any more.

boutpp.init(args=[])

Initialization function for the library.

Parameters:

args (list of string or string, optional) – It accepts ether a list of strings, or a string that is split at the spaces. This is passed on to MPI and other libraries that BOUT++ initializes.

boutpp.interp_to(Field3D f3d, location)

Interpolate a Field3D to a given location

Parameters:
  • f3d (Field3D) – The field to interpolate

  • location (string) – The location to which to interploate

Returns:

the interpolated field

Return type:

Field3D

boutpp.log(a)

Calculate log of a

Parameters:

a (Field3D or Field2D) – The field for which to calculate log

Returns:

log of a

Return type:

Field3D or Field2D

boutpp.max(Field3D a)

Get the maximum

Parameters:

a (Field3D) – The field

Returns:

the maximum value of a

Return type:

float

boutpp.min(Field3D a)

Get the minimum

Parameters:

a (Field3D) – The field

Returns:

the minimum value of a

Return type:

float

boutpp.pow(Field3D a, exponent)

Returns a**e where a is a Field3D and e is a number

Parameters:
  • a (Field3D) – The field for which to calculate the power

  • exponent (float) – The exponent

Returns:

The a**exponent

Return type:

Field3D

boutpp.print(*args, sep=' ', end='\n')
boutpp.setOption(name, value, source='PyInterface', force=False)

Set an option in the global Options tree. Prefer Options.set to avoid unexpected results if several Option roots are avalaible.

Parameters:
  • name (string) – the name of the value to be set. Can be relative, e.g. “mesh:ddx:first”.

  • value (string) – the value to be set

  • source (string) – The source of the change. Useful for keeping track of where what was set.

  • force (bool) – If a value is overwritten, an exception is thrown. setting this to True avoids the exception.

boutpp.sin(a)

Calculate sin of a

Parameters:

a (Field3D or Field2D) – The field for which to calculate sin

Returns:

sin of a

Return type:

Field3D or Field2D

boutpp.size_t

alias of uint64

boutpp.sqrt(a)

Calculate sqrt of a

Parameters:

a (Field3D or Field2D) – The field for which to calculate sqrt

Returns:

sqrt of a

Return type:

Field3D or Field2D

boutpp.writeDefaultOutputFile(Options options: Options)