File interpolation_xz.hxx#

Typedefs

template<class DerivedType> using RegisterXZInterpolation = XZInterpolationFactory::RegisterInFactory<DerivedType>#

Functions

const Field3D interpolate(const Field3D &f, const Field3D &delta_x, const Field3D &delta_z): Interpolate a field onto a perturbed set of points.

const Field3D interpolate(const Field2D &f, const Field3D &delta_x, const Field3D &delta_z)

const Field3D interpolate(const Field2D &f, const Field3D &delta_x)

class XZInterpolation#

Subclassed by XZBilinear, XZHermiteSpline, XZLagrange4pt

Public Functions

inline XZInterpolation(int y_offset = 0, Mesh *localmeshIn = nullptr)#

inline XZInterpolation(const BoutMask &mask, int y_offset = 0, Mesh *mesh = nullptr)#

inline XZInterpolation(const std::string &region_name, int y_offset = 0, Mesh *mesh = nullptr)#

inline XZInterpolation(std::shared_ptr<Region<Ind3D>> region, int y_offset = 0, Mesh *mesh = nullptr)#

virtual ~XZInterpolation() = default#

inline void setMask(const BoutMask &mask)#

inline void setRegion(const std::string &region_name)#

inline void setRegion(const std::shared_ptr<Region<Ind3D>> &region)#

inline void setRegion(const Region<Ind3D> &region)#

inline Region<Ind3D> getRegion() const#

inline Region<Ind3D> getRegion(const std::string &region) const#

virtual void calcWeights(const Field3D &delta_x, const Field3D &delta_z, const std::string &region = "RGN_NOBNDRY") = 0#

virtual void calcWeights(const Field3D &delta_x, const Field3D &delta_z, const BoutMask &mask, const std::string &region = "RGN_NOBNDRY") = 0#

virtual Field3D interpolate(const Field3D &f, const std::string &region = "RGN_NOBNDRY") const = 0#

virtual Field3D interpolate(const Field3D &f, const Field3D &delta_x, const Field3D &delta_z, const std::string &region = "RGN_NOBNDRY") = 0#

virtual Field3D interpolate(const Field3D &f, const Field3D &delta_x, const Field3D &delta_z, const BoutMask &mask, const std::string &region = "RGN_NOBNDRY") = 0#

inline void setYOffset(int offset)#

inline virtual std::vector<ParallelTransform::PositionsAndWeights> getWeightsForYUpApproximation(int i, int j, int k)#

inline virtual std::vector<ParallelTransform::PositionsAndWeights> getWeightsForYDownApproximation(int i, int j, int k)#

inline virtual std::vector<ParallelTransform::PositionsAndWeights> getWeightsForYApproximation(int i, int j, int k, int yoffset)#

Public Members

int y_offset#

Protected Attributes

Mesh *localmesh = {nullptr}#

std::string region_name#

std::shared_ptr<Region<Ind3D>> region = {nullptr}#

class XZHermiteSpline : public XZInterpolation #

Subclassed by XZMonotonicHermiteSpline

Public Functions

inline XZHermiteSpline(Mesh *mesh = nullptr)#

XZHermiteSpline(int y_offset = 0, Mesh *mesh = nullptr)#

inline XZHermiteSpline(const BoutMask &mask, int y_offset = 0, Mesh *mesh = nullptr)#

virtual void calcWeights(const Field3D &delta_x, const Field3D &delta_z, const std::string &region = "RGN_NOBNDRY") override#

virtual void calcWeights(const Field3D &delta_x, const Field3D &delta_z, const BoutMask &mask, const std::string &region = "RGN_NOBNDRY") override#

virtual Field3D interpolate(const Field3D &f, const std::string &region = "RGN_NOBNDRY") const override#

virtual Field3D interpolate(const Field3D &f, const Field3D &delta_x, const Field3D &delta_z, const std::string &region = "RGN_NOBNDRY") override#

virtual Field3D interpolate(const Field3D &f, const Field3D &delta_x, const Field3D &delta_z, const BoutMask &mask, const std::string &region = "RGN_NOBNDRY") override#

virtual std::vector<ParallelTransform::PositionsAndWeights> getWeightsForYApproximation(int i, int j, int k, int yoffset) override#

Return position and weight of points needed to approximate the function value at the point that the field line through (i,j,k) meets the (j+1)-plane. For the case where only the z-direction is not aligned to grid points, the approximation is: f(i,j+1,k*) = h00_z * f(i,j+1,k) + h01_z * f(i,j+1,k+1)

h10_z * dfdz(i,j+1,k) + h11_z * dfdz(i,j+1,k+1) = h00_z * f(i,j+1,k) + h01_z * f(i,j+1,k+1)
h10_z * ( f(i,j+1,k+1) - f(i,j+1,k-1) ) / 2
h11_z * ( f(i,j+1,k+2) - f(i,j+1,k) ) / 2 for k* a point between k and k+1. Therefore, this function returns position weight (i, j+1, k-1) - h10_z / 2 (i, j+1, k) h00_z - h11_z / 2 (i, j+1, k+1) h01_z + h10_z / 2 (i, j+1, k+2) h11_z / 2

Protected Attributes

Tensor<int> i_corner#: This is protected rather than private so that it can be extended and used by HermiteSplineMonotonic

Tensor<int> k_corner#

Field3D h00_x#

Field3D h01_x#

Field3D h10_x#

Field3D h11_x#

Field3D h00_z#

Field3D h01_z#

Field3D h10_z#

Field3D h11_z#

class XZMonotonicHermiteSpline : public XZHermiteSpline #

#include <interpolation_xz.hxx>

Monotonic Hermite spline interpolator

Similar to XZHermiteSpline, so uses most of the same code. Forces the interpolated result to be in the range of the neighbouring cell values. This prevents unphysical overshoots, but also degrades accuracy near maxima and minima. Perhaps should only impose near boundaries, since that is where problems most obviously occur.

Public Functions

inline XZMonotonicHermiteSpline(Mesh *mesh = nullptr)#

inline XZMonotonicHermiteSpline(int y_offset = 0, Mesh *mesh = nullptr)#

inline XZMonotonicHermiteSpline(const BoutMask &mask, int y_offset = 0, Mesh *mesh = nullptr)#

virtual Field3D interpolate(const Field3D &f, const std::string &region = "RGN_NOBNDRY") const override#: Interpolate using precalculated weights. This function is called by the other interpolate functions in the base class XZHermiteSpline.

Field3D interpolate(const Field3D &f, const std::string &region = "RGN_NOBNDRY") const override

Field3D interpolate(const Field3D &f, const Field3D &delta_x, const Field3D &delta_z, const std::string &region = "RGN_NOBNDRY") override#

Field3D interpolate(const Field3D &f, const Field3D &delta_x, const Field3D &delta_z, const BoutMask &mask, const std::string &region = "RGN_NOBNDRY") override#

class XZLagrange4pt : public XZInterpolation #

Public Functions

inline XZLagrange4pt(Mesh *mesh = nullptr)#

XZLagrange4pt(int y_offset = 0, Mesh *mesh = nullptr)#

inline XZLagrange4pt(const BoutMask &mask, int y_offset = 0, Mesh *mesh = nullptr)#

virtual void calcWeights(const Field3D &delta_x, const Field3D &delta_z, const std::string &region = "RGN_NOBNDRY") override#

virtual void calcWeights(const Field3D &delta_x, const Field3D &delta_z, const BoutMask &mask, const std::string &region = "RGN_NOBNDRY") override#

virtual Field3D interpolate(const Field3D &f, const std::string &region = "RGN_NOBNDRY") const override#

virtual Field3D interpolate(const Field3D &f, const Field3D &delta_x, const Field3D &delta_z, const std::string &region = "RGN_NOBNDRY") override#

virtual Field3D interpolate(const Field3D &f, const Field3D &delta_x, const Field3D &delta_z, const BoutMask &mask, const std::string &region = "RGN_NOBNDRY") override#

BoutReal lagrange_4pt(BoutReal v2m, BoutReal vm, BoutReal vp, BoutReal v2p, BoutReal offset) const#

BoutReal lagrange_4pt(const BoutReal v[], BoutReal offset) const#

Private Members

Tensor<int> i_corner#

Tensor<int> k_corner#

Field3D t_x#

Field3D t_z#

class XZBilinear : public XZInterpolation #

Public Functions

inline XZBilinear(Mesh *mesh = nullptr)#

XZBilinear(int y_offset = 0, Mesh *mesh = nullptr)#

inline XZBilinear(const BoutMask &mask, int y_offset = 0, Mesh *mesh = nullptr)#

virtual void calcWeights(const Field3D &delta_x, const Field3D &delta_z, const std::string &region = "RGN_NOBNDRY") override#

virtual void calcWeights(const Field3D &delta_x, const Field3D &delta_z, const BoutMask &mask, const std::string &region = "RGN_NOBNDRY") override#

virtual Field3D interpolate(const Field3D &f, const std::string &region = "RGN_NOBNDRY") const override#

virtual Field3D interpolate(const Field3D &f, const Field3D &delta_x, const Field3D &delta_z, const std::string &region = "RGN_NOBNDRY") override#

virtual Field3D interpolate(const Field3D &f, const Field3D &delta_x, const Field3D &delta_z, const BoutMask &mask, const std::string &region = "RGN_NOBNDRY") override#