File spt.hxx#

class LaplaceSPT : public Laplacian #

Simple parallelisation of the Thomas tridiagonal solver algorithm (serial code)

This is a reference code which performs the same operations as the serial code. To invert a single XZ slice (FieldPerp object), data must pass from the innermost processor (localmesh->PE_XIND = 0) to the outermost (localmesh->PE_XIND = localmesh->NXPE-1) and back again.

Some parallelism is achieved by running several inversions simultaneously, so while processor #1 is inverting Y=0, processor #0 is starting on Y=1. This works ok as long as the number of slices to be inverted is greater than the number of X processors (MYSUB > localmesh->NXPE). If MYSUB < localmesh->NXPE then not all processors can be busy at once, and so efficiency will fall sharply.

Param b:: [in] RHS values (Ax = b)
Param flags:: [in] Inversion settings (see boundary.h for values)
Param a:: [in] This is a 2D matrix which allows solution of A = Delp2 + a
Param data:: [out] Structure containing data needed for second half of inversion
Param ccoef:: [in] Optional coefficient for first-order derivative
Param d:: [in] Optional factor to multiply the Delp2 operator

Public Functions

LaplaceSPT(Options *opt = nullptr, const CELL_LOC = CELL_CENTRE, Mesh *mesh_in = nullptr, Solver *solver = nullptr)#

inline virtual void setCoefA(const Field2D &val) override#: Set coefficients for inversion. Re-builds matrices if necessary.

inline virtual void setCoefC(const Field2D &val) override#

inline virtual void setCoefD(const Field2D &val) override#

inline virtual void setCoefEx(const Field2D &val) override#

inline virtual void setCoefEz(const Field2D &val) override#

virtual FieldPerp solve(const FieldPerp &b) override#

virtual FieldPerp solve(const FieldPerp &b, const FieldPerp &x0) override#

virtual Field3D solve(const Field3D &b) override#

virtual Field3D solve(const Field3D &b, const Field3D &x0) override#

void setCoefA(const Field2D &val) = 0: Set coefficients for inversion. Re-builds matrices if necessary.

inline void setCoefA(const Field3D &val)#

inline void setCoefA(BoutReal r)#

void setCoefC(const Field2D &val) = 0

inline void setCoefC(const Field3D &val)#

inline void setCoefC(BoutReal r)#

void setCoefD(const Field2D &val) = 0

inline void setCoefD(const Field3D &val)#

inline void setCoefD(BoutReal r)#

void setCoefEx(const Field2D &val) = 0

inline void setCoefEx(const Field3D &val)#

inline void setCoefEx(BoutReal r)#

void setCoefEz(const Field2D &val) = 0

inline void setCoefEz(const Field3D &val)#

inline void setCoefEz(BoutReal r)#

FieldPerp solve(const FieldPerp &b) = 0

Field3D solve(const Field3D &b)

Field2D solve(const Field2D &b)#

inline FieldPerp solve(const FieldPerp &b, const FieldPerp &x0)

Field3D solve(const Field3D &b, const Field3D &x0)

Field2D solve(const Field2D &b, const Field2D &x0)#

Private Functions

void tridagForward(dcomplex *a, dcomplex *b, dcomplex *c, dcomplex *r, dcomplex *u, int n, dcomplex *gam, dcomplex &bet, dcomplex &um, bool start = false)#

void tridagBack(dcomplex *u, int n, dcomplex *gam, dcomplex &gp, dcomplex &up)#

int start(const FieldPerp &b, SPT_data &data)#

int next(SPT_data &data)#

void finish(SPT_data &data, FieldPerp &x)#

Private Members

Field2D Acoef#

Field2D Ccoef#

Field2D Dcoef#

int ys#

int ye#

SPT_data slicedata#

Array<SPT_data> alldata#

Array<dcomplex> dc1d#: 1D in Z for taking FFTs

Private Static Attributes

static constexpr int SPT_DATA = 1123#: ‘magic’ number for SPT MPI messages

struct SPT_data#

Data structure for SPT algorithm.

Public Functions

void allocate(int mm, int nx)#

Public Members

int jy = 0#: Y index.

Matrix<dcomplex> bk#: b vector in Fourier space

Matrix<dcomplex> xk#

Matrix<dcomplex> gam#

Matrix<dcomplex> avec#

Matrix<dcomplex> bvec#

Matrix<dcomplex> cvec#: Diagonal bands of matrix.

int proc = 0#

int dir = 1#

comm_handle recv_handle = nullptr#

int comm_tag = SPT_DATA #

Array<BoutReal> buffer#