File boundary_standard.hxx#

Functions

BoutReal default_func(BoutReal t, int x, int y, int z)#

class BoundaryDirichlet_2ndOrder : public BoundaryOp #

#include <boundary_standard.hxx>

Some standard boundary conditions.

Dirichlet boundary condition set half way between guard cell and grid cell at 2nd order accuracy

Public Functions

inline BoundaryDirichlet_2ndOrder()#

inline BoundaryDirichlet_2ndOrder(BoutReal setval)#

inline BoundaryDirichlet_2ndOrder(BoundaryRegion *region, BoutReal setval = 0.)#

virtual BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args) override#

virtual void apply(Field2D &f) override#: Apply a boundary condition on field f.

virtual void apply(Field3D &f) override#

virtual void apply_ddt(Field2D &f) override#: Apply a boundary condition on ddt(f)

virtual void apply_ddt(Field3D &f) override#

inline BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args)

inline BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args, const std::map<std::string, std::string> &keywords)#: Clone using positional args and keywords If not implemented, check if keywords are passed, then call two-argument version

inline void apply_ddt(Field2D &f): Apply a boundary condition on ddt(f)

inline void apply_ddt(Field3D &f)

inline void apply_ddt(Vector2D &f)#

inline void apply_ddt(Vector3D &f)#

Private Members

BoutReal val#

class BoundaryDirichlet : public BoundaryOp #

#include <boundary_standard.hxx>

Dirichlet (set to zero) boundary condition.

Public Functions

inline BoundaryDirichlet()#

inline BoundaryDirichlet(BoundaryRegion *region, std::shared_ptr<FieldGenerator> g)#

virtual BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args) override#

virtual void apply(Field2D &f) override#: Apply a boundary condition on field f.

virtual void apply(Field2D &f, BoutReal t) override#

virtual void apply(Field3D &f) override#

virtual void apply(Field3D &f, BoutReal t) override#

virtual void apply_ddt(Field2D &f) override#: Apply a boundary condition on ddt(f)

virtual void apply_ddt(Field3D &f) override#

inline BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args)

inline BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args, const std::map<std::string, std::string> &keywords)#: Clone using positional args and keywords If not implemented, check if keywords are passed, then call two-argument version

inline void apply_ddt(Field2D &f): Apply a boundary condition on ddt(f)

inline void apply_ddt(Field3D &f)

inline void apply_ddt(Vector2D &f)#

inline void apply_ddt(Vector3D &f)#

Private Members

std::shared_ptr<FieldGenerator> gen#

class BoundaryDirichlet_O3 : public BoundaryOp #

#include <boundary_standard.hxx>

3nd-order boundary condition

Public Functions

inline BoundaryDirichlet_O3()#

inline BoundaryDirichlet_O3(BoundaryRegion *region, std::shared_ptr<FieldGenerator> g)#

virtual BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args) override#

virtual void apply(Field2D &f) override#: Apply a boundary condition on field f.

virtual void apply(Field2D &f, BoutReal t) override#

virtual void apply(Field3D &f) override#

virtual void apply(Field3D &f, BoutReal t) override#

virtual void apply_ddt(Field2D &f) override#: Apply a boundary condition on ddt(f)

virtual void apply_ddt(Field3D &f) override#

inline BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args)

inline BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args, const std::map<std::string, std::string> &keywords)#: Clone using positional args and keywords If not implemented, check if keywords are passed, then call two-argument version

inline void apply_ddt(Field2D &f): Apply a boundary condition on ddt(f)

inline void apply_ddt(Field3D &f)

inline void apply_ddt(Vector2D &f)#

inline void apply_ddt(Vector3D &f)#

Private Members

std::shared_ptr<FieldGenerator> gen#

class BoundaryDirichlet_O4 : public BoundaryOp #

#include <boundary_standard.hxx>

4th-order boundary condition

Public Functions

inline BoundaryDirichlet_O4()#

inline BoundaryDirichlet_O4(BoundaryRegion *region, std::shared_ptr<FieldGenerator> g)#

virtual BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args) override#

virtual void apply(Field2D &f) override#: Apply a boundary condition on field f.

virtual void apply(Field2D &f, BoutReal t) override#

virtual void apply(Field3D &f) override#

virtual void apply(Field3D &f, BoutReal t) override#

virtual void apply_ddt(Field2D &f) override#: Apply a boundary condition on ddt(f)

virtual void apply_ddt(Field3D &f) override#

inline BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args)

inline BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args, const std::map<std::string, std::string> &keywords)#: Clone using positional args and keywords If not implemented, check if keywords are passed, then call two-argument version

inline void apply_ddt(Field2D &f): Apply a boundary condition on ddt(f)

inline void apply_ddt(Field3D &f)

inline void apply_ddt(Vector2D &f)#

inline void apply_ddt(Vector3D &f)#

Private Members

std::shared_ptr<FieldGenerator> gen#

class BoundaryDirichlet_4thOrder : public BoundaryOp #

#include <boundary_standard.hxx>

Dirichlet boundary condition set half way between guard cell and grid cell at 4th order accuracy.

Public Functions

inline BoundaryDirichlet_4thOrder()#

inline BoundaryDirichlet_4thOrder(BoutReal setval)#

inline BoundaryDirichlet_4thOrder(BoundaryRegion *region, BoutReal setval = 0.)#

virtual BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args) override#

virtual void apply(Field2D &f) override#: Apply a boundary condition on field f.

virtual void apply(Field3D &f) override#

virtual void apply_ddt(Field2D &f) override#: Apply a boundary condition on ddt(f)

virtual void apply_ddt(Field3D &f) override#

inline BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args)

inline BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args, const std::map<std::string, std::string> &keywords)#: Clone using positional args and keywords If not implemented, check if keywords are passed, then call two-argument version

inline void apply_ddt(Field2D &f): Apply a boundary condition on ddt(f)

inline void apply_ddt(Field3D &f)

inline void apply_ddt(Vector2D &f)#

inline void apply_ddt(Vector3D &f)#

Private Members

BoutReal val#

class BoundaryNeumann_NonOrthogonal : public BoundaryOp #

#include <boundary_standard.hxx>

Neumann (zero-gradient) boundary condition for non-orthogonal meshes.

Public Functions

inline BoundaryNeumann_NonOrthogonal()#

inline BoundaryNeumann_NonOrthogonal(BoutReal setval)#

inline BoundaryNeumann_NonOrthogonal(BoundaryRegion *region, BoutReal setval = 0.)#

virtual BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args) override#

virtual void apply(Field2D &f) override#: Apply a boundary condition on field f.

virtual void apply(Field3D &f) override#

inline BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args)

inline BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args, const std::map<std::string, std::string> &keywords)#: Clone using positional args and keywords If not implemented, check if keywords are passed, then call two-argument version

Private Members

BoutReal val#

class BoundaryNeumann2 : public BoundaryOp #

#include <boundary_standard.hxx>

Neumann (zero-gradient) boundary condition, using 2nd order on boundary.

Public Functions

inline BoundaryNeumann2()#

inline BoundaryNeumann2(BoundaryRegion *region)#

virtual BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args) override#

virtual void apply(Field2D &f) override#: Apply a boundary condition on field f.

virtual void apply(Field3D &f) override#

inline BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args)

inline BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args, const std::map<std::string, std::string> &keywords)#: Clone using positional args and keywords If not implemented, check if keywords are passed, then call two-argument version

class BoundaryNeumann_2ndOrder : public BoundaryOp #

#include <boundary_standard.hxx>

Neumann boundary condition set half way between guard cell and grid cell at 2nd order accuracy.

Public Functions

inline BoundaryNeumann_2ndOrder()#

inline BoundaryNeumann_2ndOrder(BoutReal setval)#

inline BoundaryNeumann_2ndOrder(BoundaryRegion *region, BoutReal setval = 0.)#

virtual BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args) override#

virtual void apply(Field2D &f) override#: Apply a boundary condition on field f.

virtual void apply(Field3D &f) override#

virtual void apply_ddt(Field2D &f) override#: Apply a boundary condition on ddt(f)

virtual void apply_ddt(Field3D &f) override#

inline BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args)

inline BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args, const std::map<std::string, std::string> &keywords)#: Clone using positional args and keywords If not implemented, check if keywords are passed, then call two-argument version

inline void apply_ddt(Field2D &f): Apply a boundary condition on ddt(f)

inline void apply_ddt(Field3D &f)

inline void apply_ddt(Vector2D &f)#

inline void apply_ddt(Vector3D &f)#

Private Members

BoutReal val#

class BoundaryNeumann : public BoundaryOp #

Public Functions

inline BoundaryNeumann()#

inline BoundaryNeumann(BoundaryRegion *region, std::shared_ptr<FieldGenerator> g)#

virtual BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args) override#

virtual void apply(Field2D &f) override#: Apply a boundary condition on field f.

virtual void apply(Field2D &f, BoutReal t) override#

virtual void apply(Field3D &f) override#

virtual void apply(Field3D &f, BoutReal t) override#

virtual void apply_ddt(Field2D &f) override#: Apply a boundary condition on ddt(f)

virtual void apply_ddt(Field3D &f) override#

inline BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args)

inline BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args, const std::map<std::string, std::string> &keywords)#: Clone using positional args and keywords If not implemented, check if keywords are passed, then call two-argument version

inline void apply_ddt(Field2D &f): Apply a boundary condition on ddt(f)

inline void apply_ddt(Field3D &f)

inline void apply_ddt(Vector2D &f)#

inline void apply_ddt(Vector3D &f)#

Private Members

std::shared_ptr<FieldGenerator> gen#

class BoundaryNeumann_4thOrder : public BoundaryOp #

#include <boundary_standard.hxx>

Neumann boundary condition set half way between guard cell and grid cell at 4th order accuracy.

Public Functions

inline BoundaryNeumann_4thOrder()#

inline BoundaryNeumann_4thOrder(BoutReal setval)#

inline BoundaryNeumann_4thOrder(BoundaryRegion *region, BoutReal setval = 0.)#

virtual BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args) override#

virtual void apply(Field2D &f) override#: Apply a boundary condition on field f.

virtual void apply(Field3D &f) override#

virtual void apply_ddt(Field2D &f) override#: Apply a boundary condition on ddt(f)

virtual void apply_ddt(Field3D &f) override#

inline BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args)

inline BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args, const std::map<std::string, std::string> &keywords)#: Clone using positional args and keywords If not implemented, check if keywords are passed, then call two-argument version

inline void apply_ddt(Field2D &f): Apply a boundary condition on ddt(f)

inline void apply_ddt(Field3D &f)

inline void apply_ddt(Vector2D &f)#

inline void apply_ddt(Vector3D &f)#

Private Members

BoutReal val#

class BoundaryNeumann_O4 : public BoundaryOp #

#include <boundary_standard.hxx>

Neumann boundary condition set half way between guard cell and grid cell at 4th order accuracy.

Public Functions

inline BoundaryNeumann_O4()#

inline BoundaryNeumann_O4(BoundaryRegion *region, std::shared_ptr<FieldGenerator> g)#

virtual BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args) override#

virtual void apply(Field2D &f) override#: Apply a boundary condition on field f.

virtual void apply(Field2D &f, BoutReal t) override#

virtual void apply(Field3D &f) override#

virtual void apply(Field3D &f, BoutReal t) override#

virtual void apply_ddt(Field2D &f) override#: Apply a boundary condition on ddt(f)

virtual void apply_ddt(Field3D &f) override#

inline BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args)

inline BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args, const std::map<std::string, std::string> &keywords)#: Clone using positional args and keywords If not implemented, check if keywords are passed, then call two-argument version

inline void apply_ddt(Field2D &f): Apply a boundary condition on ddt(f)

inline void apply_ddt(Field3D &f)

inline void apply_ddt(Vector2D &f)#

inline void apply_ddt(Vector3D &f)#

Private Members

std::shared_ptr<FieldGenerator> gen#

class BoundaryNeumannPar : public BoundaryOp #

#include <boundary_standard.hxx>

NeumannPar (zero-gradient) boundary condition on the variable / sqrt(g_22)

Public Functions

inline BoundaryNeumannPar()#

inline BoundaryNeumannPar(BoundaryRegion *region)#

virtual BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args) override#

virtual void apply(Field2D &f) override#: Apply a boundary condition on field f.

virtual void apply(Field3D &f) override#

inline BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args)

inline BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args, const std::map<std::string, std::string> &keywords)#: Clone using positional args and keywords If not implemented, check if keywords are passed, then call two-argument version

class BoundaryRobin : public BoundaryOp #

#include <boundary_standard.hxx>

Robin (mix of Dirichlet and Neumann)

Public Functions

inline BoundaryRobin()#

inline BoundaryRobin(BoundaryRegion *region, BoutReal a, BoutReal b, BoutReal g)#

virtual BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args) override#

virtual void apply(Field2D &f) override#: Apply a boundary condition on field f.

virtual void apply(Field3D &f) override#

inline BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args)

inline BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args, const std::map<std::string, std::string> &keywords)#: Clone using positional args and keywords If not implemented, check if keywords are passed, then call two-argument version

Private Members

BoutReal aval#

BoutReal bval#

BoutReal gval#

class BoundaryConstGradient : public BoundaryOp #

#include <boundary_standard.hxx>

Constant gradient (zero second derivative)

Public Functions

inline BoundaryConstGradient()#

inline BoundaryConstGradient(BoundaryRegion *region)#

virtual BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args) override#

virtual void apply(Field2D &f) override#: Apply a boundary condition on field f.

virtual void apply(Field3D &f) override#

inline BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args)

inline BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args, const std::map<std::string, std::string> &keywords)#: Clone using positional args and keywords If not implemented, check if keywords are passed, then call two-argument version

class BoundaryZeroLaplace : public BoundaryOp #

#include <boundary_standard.hxx>

Zero Laplacian, decaying solution.

Public Functions

inline BoundaryZeroLaplace()#

inline BoundaryZeroLaplace(BoundaryRegion *region)#

virtual BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args) override#

virtual void apply(Field2D &f) override#: Apply a boundary condition on field f.

virtual void apply(Field3D &f) override#

inline BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args)

inline BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args, const std::map<std::string, std::string> &keywords)#: Clone using positional args and keywords If not implemented, check if keywords are passed, then call two-argument version

class BoundaryZeroLaplace2 : public BoundaryOp #

#include <boundary_standard.hxx>

Zero Laplacian.

Public Functions

inline BoundaryZeroLaplace2()#

inline BoundaryZeroLaplace2(BoundaryRegion *region)#

virtual BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args) override#

virtual void apply(Field2D &f) override#: Apply a boundary condition on field f.

virtual void apply(Field3D &f) override#

inline BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args)

inline BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args, const std::map<std::string, std::string> &keywords)#: Clone using positional args and keywords If not implemented, check if keywords are passed, then call two-argument version

class BoundaryConstLaplace : public BoundaryOp #

#include <boundary_standard.hxx>

Constant Laplacian, decaying solution.

Public Functions

inline BoundaryConstLaplace()#

inline BoundaryConstLaplace(BoundaryRegion *region)#

virtual BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args) override#

virtual void apply(Field2D &f) override#: Apply a boundary condition on field f.

virtual void apply(Field3D &f) override#

inline BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args)

inline BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args, const std::map<std::string, std::string> &keywords)#: Clone using positional args and keywords If not implemented, check if keywords are passed, then call two-argument version

class BoundaryDivCurl : public BoundaryOp #

#include <boundary_standard.hxx>

Vector boundary condition Div(B) = 0, Curl(B) = 0.

Public Functions

inline BoundaryDivCurl()#

inline BoundaryDivCurl(BoundaryRegion *region)#

virtual BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args) override#

inline virtual void apply(Field2D &f) override#: Apply a boundary condition on field f.

inline virtual void apply(Field3D &f) override#

virtual void apply(Vector2D &f) override#

virtual void apply(Vector3D &f) override#

inline BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args)

inline BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args, const std::map<std::string, std::string> &keywords)#: Clone using positional args and keywords If not implemented, check if keywords are passed, then call two-argument version

class BoundaryFree : public BoundaryOp #

#include <boundary_standard.hxx>

Free boundary condition (evolve the field in the guard cells, using non-centred derivatives to calculate the ddt)

Public Functions

inline BoundaryFree()#

inline BoundaryFree(BoutReal setval)#

inline BoundaryFree(BoundaryRegion *region, BoutReal setval = 0.)#

virtual BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args) override#

virtual void apply(Field2D &f) override#: Apply a boundary condition on field f.

virtual void apply(Field3D &f) override#

virtual void apply_ddt(Field2D &f) override#: Apply a boundary condition on ddt(f)

virtual void apply_ddt(Field3D &f) override#

inline BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args)

inline BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args, const std::map<std::string, std::string> &keywords)#: Clone using positional args and keywords If not implemented, check if keywords are passed, then call two-argument version

inline void apply_ddt(Field2D &f): Apply a boundary condition on ddt(f)

inline void apply_ddt(Field3D &f)

inline void apply_ddt(Vector2D &f)#

inline void apply_ddt(Vector3D &f)#

Private Members

BoutReal val#

class BoundaryFree_O2 : public BoundaryOp #

#include <boundary_standard.hxx>

Alternative free boundary condition (evolve the field in the guard cells, using non-centred derivatives to calculate the ddt)

Public Functions

inline BoundaryFree_O2()#

inline BoundaryFree_O2(BoundaryRegion *region)#

virtual BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args) override#

virtual void apply(Field2D &f) override#: Apply a boundary condition on field f.

virtual void apply(Field3D &f) override#

virtual void apply_ddt(Field2D &f) override#: Apply a boundary condition on ddt(f)

virtual void apply_ddt(Field3D &f) override#

inline BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args)

inline BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args, const std::map<std::string, std::string> &keywords)#: Clone using positional args and keywords If not implemented, check if keywords are passed, then call two-argument version

inline void apply_ddt(Field2D &f): Apply a boundary condition on ddt(f)

inline void apply_ddt(Field3D &f)

inline void apply_ddt(Vector2D &f)#

inline void apply_ddt(Vector3D &f)#

class BoundaryFree_O3 : public BoundaryOp #

Public Functions

inline BoundaryFree_O3()#

inline BoundaryFree_O3(BoundaryRegion *region)#

virtual BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args) override#

virtual void apply(Field2D &f) override#: Apply a boundary condition on field f.

virtual void apply(Field3D &f) override#

virtual void apply_ddt(Field2D &f) override#: Apply a boundary condition on ddt(f)

virtual void apply_ddt(Field3D &f) override#

inline BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args)

inline BoundaryOp *clone(BoundaryRegion *region, const std::list<std::string> &args, const std::map<std::string, std::string> &keywords)#: Clone using positional args and keywords If not implemented, check if keywords are passed, then call two-argument version

inline void apply_ddt(Field2D &f): Apply a boundary condition on ddt(f)

inline void apply_ddt(Field3D &f)

inline void apply_ddt(Vector2D &f)#

inline void apply_ddt(Vector3D &f)#

class BoundaryRelax : public BoundaryModifier #

#include <boundary_standard.hxx>

Convert a boundary condition to a relaxing one.

Public Functions

inline BoundaryRelax()#

inline BoundaryRelax(BoundaryOp *operation, BoutReal rate)#

virtual BoundaryOp *cloneMod(BoundaryOp *op, const std::list<std::string> &args) override#

inline virtual void apply(Field2D &f) override#: Apply a boundary condition on field f.

virtual void apply(Field2D &f, BoutReal t) override#

inline virtual void apply(Field3D &f) override#

virtual void apply(Field3D &f, BoutReal t) override#

virtual void apply_ddt(Field2D &f) override#: Apply a boundary condition on ddt(f)

virtual void apply_ddt(Field3D &f) override#

Private Members

BoutReal r#

class BoundaryWidth : public BoundaryModifier #

#include <boundary_standard.hxx>

Increase the width of a boundary.

Public Functions

inline BoundaryWidth()#

inline BoundaryWidth(BoundaryOp *operation, int wid)#

virtual BoundaryOp *cloneMod(BoundaryOp *op, const std::list<std::string> &args) override#

inline virtual void apply(Field2D &f) override#: Apply a boundary condition on field f.

virtual void apply(Field2D &f, BoutReal t) override#

inline virtual void apply(Field3D &f) override#

virtual void apply(Field3D &f, BoutReal t) override#

virtual void apply_ddt(Field2D &f) override#: Apply a boundary condition on ddt(f)

virtual void apply_ddt(Field3D &f) override#

Private Members

int width#

class BoundaryToFieldAligned : public BoundaryModifier #

#include <boundary_standard.hxx>

Convert input field fromFieldAligned, apply boundary and then convert back toFieldAligned Equivalent to converting the boundary condition to “Field Aligned” from “orthogonal”

Public Functions

inline BoundaryToFieldAligned()#

inline BoundaryToFieldAligned(BoundaryOp *operation)#

virtual BoundaryOp *cloneMod(BoundaryOp *op, const std::list<std::string> &args) override#

inline virtual void apply(Field2D &f) override#: Apply a boundary condition on field f.

virtual void apply(Field2D &f, BoutReal t) override#

inline virtual void apply(Field3D &f) override#

virtual void apply(Field3D &f, BoutReal t) override#

virtual void apply_ddt(Field2D &f) override#: Apply a boundary condition on ddt(f)

virtual void apply_ddt(Field3D &f) override#

class BoundaryFromFieldAligned : public BoundaryModifier #

#include <boundary_standard.hxx>

Convert input field toFieldAligned, apply boundary and then convert back fromFieldAligned Equivalent to converting the boundary condition from “Field Aligned” to “orthogonal”

Public Functions

inline BoundaryFromFieldAligned()#

inline BoundaryFromFieldAligned(BoundaryOp *operation)#

virtual BoundaryOp *cloneMod(BoundaryOp *op, const std::list<std::string> &args) override#

inline virtual void apply(Field2D &f) override#: Apply a boundary condition on field f.

virtual void apply(Field2D &f, BoutReal t) override#

inline virtual void apply(Field3D &f) override#

virtual void apply(Field3D &f, BoutReal t) override#

virtual void apply_ddt(Field2D &f) override#: Apply a boundary condition on ddt(f)

virtual void apply_ddt(Field3D &f) override#