Nektar::StdRegions Namespace Reference

Classes
class	StdExpansion
	The base class for all shapes. More...
class	StdExpansion0D
class	StdExpansion1D
class	StdExpansion2D
class	StdExpansion3D
class	StdHexExp
	Class representing a hexehedral element in reference space. More...
class	StdMatrixKey
class	StdNodalPrismExp
class	StdNodalTetExp
class	StdNodalTriExp
class	StdPointExp
class	StdPrismExp
	Class representing a prismatic element in reference space. More...
class	StdPyrExp
class	StdQuadExp
class	StdSegExp
	Class representing a segment element in reference space All interface of this class sits in StdExpansion class. More...
class	StdTetExp
class	StdTriExp
struct	VarCoeffEntry
	Representation of a variable coefficient. More...

Typedefs
typedef std::shared_ptr< StdExpansion >	StdExpansionSharedPtr
typedef std::vector< StdExpansionSharedPtr >	StdExpansionVector
typedef std::shared_ptr< StdExpansion0D >	StdExpansion0DSharedPtr
typedef std::shared_ptr< StdExpansion1D >	StdExpansion1DSharedPtr
typedef std::shared_ptr< StdExpansion2D >	StdExpansion2DSharedPtr
typedef std::shared_ptr< StdExpansion3D >	StdExpansion3DSharedPtr
typedef std::shared_ptr< StdHexExp >	StdHexExpSharedPtr
typedef std::shared_ptr< StdMatrixKey >	StdMatrixKeySharedPtr
typedef std::shared_ptr< StdNodalPrismExp >	StdNodalPrismExpSharedPtr
typedef std::shared_ptr< StdNodalTetExp >	StdNodalTetExpSharedPtr
typedef std::shared_ptr< StdNodalTriExp >	StdNodalTriExpSharedPtr
typedef std::shared_ptr< StdPointExp >	StdPointExpSharedPtr
typedef std::shared_ptr< StdPrismExp >	StdPrismExpSharedPtr
typedef std::shared_ptr< StdPyrExp >	StdPyrExpSharedPtr
typedef std::shared_ptr< StdQuadExp >	StdQuadExpSharedPtr
typedef std::map< StdRegions::VarCoeffType, VarCoeffEntry >	VarCoeffMap
typedef std::map< ConstFactorType, NekDouble >	ConstFactorMap
typedef ConstFactorMap	FactorMap
typedef std::shared_ptr< StdSegExp >	StdSegExpSharedPtr
typedef std::shared_ptr< StdTetExp >	StdTetExpSharedPtr
typedef std::shared_ptr< StdTriExp >	StdTriExpSharedPtr

Enumerations
enum	ElementType {   eStdSegExp , eSegExp , eStdQuadExp , eStdTriExp ,   eStdNodalTriExp , eQuadExp , eTriExp , eNodalTriExp ,   eStdHexExp , eStdPrismExp , eStdPyrExp , eStdTetExp ,   eStdNodalTetExp , eHexExp , ePrismExp , ePyrExp ,   eTetExp , eNodalTetExp , SIZE_ElementType }
enum	MatrixType {   eNoMatrixType , eMass , eMassGJP , eInvMass ,   eLaplacian , eLaplacian00 , eLaplacian01 , eLaplacian02 ,   eLaplacian10 , eLaplacian11 , eLaplacian12 , eLaplacian20 ,   eLaplacian21 , eLaplacian22 , eInvLaplacianWithUnityMean , eWeakDeriv0 ,   eWeakDeriv1 , eWeakDeriv2 , eWeakDirectionalDeriv , eMassLevelCurvature ,   eLinearAdvection , eLinearAdvectionReaction , eLinearAdvectionDiffusionReaction , eLinearAdvectionDiffusionReactionGJP ,   eNBasisTrans , eInvNBasisTrans , eBwdTrans , eBwdMat ,   eIProductWRTBase , eIProductWRTDerivBase0 , eIProductWRTDerivBase1 , eIProductWRTDerivBase2 ,   eDerivBase0 , eDerivBase1 , eDerivBase2 , eHelmholtz ,   eHelmholtzGJP , eHybridDGHelmholtz , eInvHybridDGHelmholtz , eHybridDGHelmBndLam ,   eHybridDGLamToQ0 , eHybridDGLamToQ1 , eHybridDGLamToQ2 , eHybridDGLamToU ,   eFwdTrans , ePreconR , ePreconRMass , ePreconLinearSpace ,   ePreconLinearSpaceMass , eInterpGauss , eGaussDG , ePhysInterpToEquiSpaced ,   eEquiSpacedToCoeffs , eNormDerivOnTrace , SIZE_MatrixType }
enum	VarCoeffType {   eVarCoeffMass , eVarCoeffLaplacian , eVarCoeffWeakDeriv , eVarCoeffD00 ,   eVarCoeffD01 , eVarCoeffD02 , eVarCoeffD10 , eVarCoeffD11 ,   eVarCoeffD12 , eVarCoeffD20 , eVarCoeffD21 , eVarCoeffD22 ,   eVarCoeffVelX , eVarCoeffVelY , eVarCoeffVelZ , eVarCoeffMF1x ,   eVarCoeffMF1y , eVarCoeffMF1z , eVarCoeffMF1Div , eVarCoeffMF1Mag ,   eVarCoeffMF2x , eVarCoeffMF2y , eVarCoeffMF2z , eVarCoeffMF2Div ,   eVarCoeffMF2Mag , eVarCoeffMF3x , eVarCoeffMF3y , eVarCoeffMF3z ,   eVarCoeffMF3Div , eVarCoeffMF3Mag , eVarCoeffMF , eVarCoeffMFDiv ,   eVarCoeffGmat , eVarCoeffGJPNormVel , SIZE_VarCoeffType }
enum	ConstFactorType {   eFactorLambda , eFactorCoeffD00 , eFactorCoeffD11 , eFactorCoeffD22 ,   eFactorCoeffD01 , eFactorCoeffD02 , eFactorCoeffD12 , eFactorTau ,   eFactorTime , eFactorSVVCutoffRatio , eFactorSVVDiffCoeff , eFactorSVVPowerKerDiffCoeff ,   eFactorSVVDGKerDiffCoeff , eFactorGaussVertex , eFactorGaussEdge , eFactorGJP ,   eFactorConst , SIZE_ConstFactorType }
enum	Orientation {   eNoOrientation , eFwd , eBwd , eForwards ,   eBackwards , eDir1FwdDir1_Dir2FwdDir2 , eDir1FwdDir1_Dir2BwdDir2 , eDir1BwdDir1_Dir2FwdDir2 ,   eDir1BwdDir1_Dir2BwdDir2 , eDir1FwdDir2_Dir2FwdDir1 , eDir1FwdDir2_Dir2BwdDir1 , eDir1BwdDir2_Dir2FwdDir1 ,   eDir1BwdDir2_Dir2BwdDir1 , SIZE_Orientation }

Functions
LibUtilities::BasisKey	EvaluateQuadFaceBasisKey (const int facedir, const LibUtilities::BasisType faceDirBasisType, const int numpoints, const int nummodes)
LibUtilities::BasisKey	EvaluateTriFaceBasisKey (const int facedir, const LibUtilities::BasisType faceDirBasisType, const int numpoints, const int nummodes)
bool	operator< (const StdMatrixKey &lhs, const StdMatrixKey &rhs)
bool	operator== (const StdMatrixKey &lhs, const StdMatrixKey &rhs)
std::ostream &	operator<< (std::ostream &os, const StdMatrixKey &rhs)
VarCoeffMap	RestrictCoeffMap (const VarCoeffMap &m, size_t offset, size_t cnt)
template<class InputIterator , class EqualityComparable >
InputIterator	find (InputIterator first, InputIterator last, InputIterator startingpoint, const EqualityComparable &value)

Variables
const char *const	ElementTypeMap []
const char *const	MatrixTypeMap []
const char *const	VarCoeffTypeMap []
static VarCoeffMap	NullVarCoeffMap
const char *const	ConstFactorTypeMap []
static ConstFactorMap	NullConstFactorMap
static FactorMap	NullFactorMap
const char *const	OrientationMap []
const int	kSVVDGFiltermodesmin = 3
const int	kSVVDGFiltermodesmax = 11
const NekDouble	kSVVDGFilter [9][11]

Typedef Documentation

ConstFactorMap

typedef std::map<ConstFactorType, NekDouble> Nektar::StdRegions::ConstFactorMap

Definition at line 430 of file StdRegions.hpp.

FactorMap

typedef ConstFactorMap Nektar::StdRegions::FactorMap

Definition at line 434 of file StdRegions.hpp.

StdExpansion0DSharedPtr

typedef std::shared_ptr<StdExpansion0D> Nektar::StdRegions::StdExpansion0DSharedPtr

Definition at line 73 of file StdExpansion0D.h.

StdExpansion1DSharedPtr

typedef std::shared_ptr<StdExpansion1D> Nektar::StdRegions::StdExpansion1DSharedPtr

Definition at line 111 of file StdExpansion1D.h.

StdExpansion2DSharedPtr

typedef std::shared_ptr<StdExpansion2D> Nektar::StdRegions::StdExpansion2DSharedPtr

Definition at line 220 of file StdExpansion2D.h.

StdExpansion3DSharedPtr

typedef std::shared_ptr<StdExpansion3D> Nektar::StdRegions::StdExpansion3DSharedPtr

Definition at line 45 of file StdExpansion3D.h.

StdExpansionSharedPtr

typedef std::shared_ptr<StdExpansion> Nektar::StdRegions::StdExpansionSharedPtr

Definition at line 1768 of file StdExpansion.h.

StdExpansionVector

typedef std::vector<StdExpansionSharedPtr> Nektar::StdRegions::StdExpansionVector

Definition at line 1769 of file StdExpansion.h.

StdHexExpSharedPtr

typedef std::shared_ptr<StdHexExp> Nektar::StdRegions::StdHexExpSharedPtr

Definition at line 228 of file StdHexExp.h.

StdMatrixKeySharedPtr

typedef std::shared_ptr<StdMatrixKey> Nektar::StdRegions::StdMatrixKeySharedPtr

Definition at line 199 of file StdMatrixKey.h.

StdNodalPrismExpSharedPtr

typedef std::shared_ptr<StdNodalPrismExp> Nektar::StdRegions::StdNodalPrismExpSharedPtr

Definition at line 135 of file StdNodalPrismExp.h.

StdNodalTetExpSharedPtr

typedef std::shared_ptr<StdNodalTetExp> Nektar::StdRegions::StdNodalTetExpSharedPtr

Definition at line 135 of file StdNodalTetExp.h.

StdNodalTriExpSharedPtr

typedef std::shared_ptr<StdNodalTriExp> Nektar::StdRegions::StdNodalTriExpSharedPtr

Definition at line 167 of file StdNodalTriExp.h.

StdPointExpSharedPtr

typedef std::shared_ptr<StdPointExp> Nektar::StdRegions::StdPointExpSharedPtr

Definition at line 142 of file StdPointExp.h.

StdPrismExpSharedPtr

typedef std::shared_ptr<StdPrismExp> Nektar::StdRegions::StdPrismExpSharedPtr

Definition at line 218 of file StdPrismExp.h.

StdPyrExpSharedPtr

typedef std::shared_ptr<StdPyrExp> Nektar::StdRegions::StdPyrExpSharedPtr

Definition at line 214 of file StdPyrExp.h.

StdQuadExpSharedPtr

typedef std::shared_ptr<StdQuadExp> Nektar::StdRegions::StdQuadExpSharedPtr

Definition at line 224 of file StdQuadExp.h.

StdSegExpSharedPtr

typedef std::shared_ptr<StdSegExp> Nektar::StdRegions::StdSegExpSharedPtr

Definition at line 222 of file StdSegExp.h.

StdTetExpSharedPtr

typedef std::shared_ptr<StdTetExp> Nektar::StdRegions::StdTetExpSharedPtr

Definition at line 233 of file StdTetExp.h.

StdTriExpSharedPtr

typedef std::shared_ptr<StdTriExp> Nektar::StdRegions::StdTriExpSharedPtr

Definition at line 219 of file StdTriExp.h.

VarCoeffMap

typedef std::map<StdRegions::VarCoeffType, VarCoeffEntry> Nektar::StdRegions::VarCoeffMap

Definition at line 375 of file StdRegions.hpp.

Enumeration Type Documentation

ConstFactorType

enum Nektar::StdRegions::ConstFactorType

Enumerator
eFactorLambda
eFactorCoeffD00
eFactorCoeffD11
eFactorCoeffD22
eFactorCoeffD01
eFactorCoeffD02
eFactorCoeffD12
eFactorTau
eFactorTime
eFactorSVVCutoffRatio
eFactorSVVDiffCoeff
eFactorSVVPowerKerDiffCoeff
eFactorSVVDGKerDiffCoeff
eFactorGaussVertex
eFactorGaussEdge
eFactorGJP
eFactorConst
SIZE_ConstFactorType

Definition at line 391 of file StdRegions.hpp.

{
    eFactorLambda,
    eFactorCoeffD00,
    eFactorCoeffD11,
    eFactorCoeffD22,
    eFactorCoeffD01,
    eFactorCoeffD02,
    eFactorCoeffD12,
    eFactorTau,
    eFactorTime,
    eFactorSVVCutoffRatio,
    eFactorSVVDiffCoeff,
    eFactorSVVPowerKerDiffCoeff,
    eFactorSVVDGKerDiffCoeff,
    eFactorGaussVertex,
    eFactorGaussEdge,
    eFactorGJP,
    eFactorConst,
    SIZE_ConstFactorType
};

ElementType

enum Nektar::StdRegions::ElementType

Enumerator
eStdSegExp
eSegExp
eStdQuadExp
eStdTriExp
eStdNodalTriExp
eQuadExp
eTriExp
eNodalTriExp
eStdHexExp
eStdPrismExp
eStdPyrExp
eStdTetExp
eStdNodalTetExp
eHexExp
ePrismExp
ePyrExp
eTetExp
eNodalTetExp
SIZE_ElementType

Definition at line 45 of file StdRegions.hpp.

{
    // eStdPointExp,
    eStdSegExp,
    eSegExp,
    eStdQuadExp,
    eStdTriExp,
    eStdNodalTriExp,
    eQuadExp,
    eTriExp,
    eNodalTriExp,
    eStdHexExp,
    eStdPrismExp,
    eStdPyrExp,
    eStdTetExp,
    eStdNodalTetExp,
    eHexExp,
    ePrismExp,
    ePyrExp,
    eTetExp,
    eNodalTetExp,
    SIZE_ElementType
};

MatrixType

enum Nektar::StdRegions::MatrixType

Todo:

we need to tidy up matrix construction approach probably using a factory type approach

Enumerator
eNoMatrixType
eMass
eMassGJP
eInvMass
eLaplacian
eLaplacian00
eLaplacian01
eLaplacian02
eLaplacian10
eLaplacian11
eLaplacian12
eLaplacian20
eLaplacian21
eLaplacian22
eInvLaplacianWithUnityMean
eWeakDeriv0
eWeakDeriv1
eWeakDeriv2
eWeakDirectionalDeriv
eMassLevelCurvature
eLinearAdvection
eLinearAdvectionReaction
eLinearAdvectionDiffusionReaction
eLinearAdvectionDiffusionReactionGJP
eNBasisTrans
eInvNBasisTrans
eBwdTrans
eBwdMat
eIProductWRTBase
eIProductWRTDerivBase0
eIProductWRTDerivBase1
eIProductWRTDerivBase2
eDerivBase0
eDerivBase1
eDerivBase2
eHelmholtz
eHelmholtzGJP
eHybridDGHelmholtz
eInvHybridDGHelmholtz
eHybridDGHelmBndLam
eHybridDGLamToQ0
eHybridDGLamToQ1
eHybridDGLamToQ2
eHybridDGLamToU
eFwdTrans
ePreconR
ePreconRMass
ePreconLinearSpace
ePreconLinearSpaceMass
eInterpGauss
eGaussDG
ePhysInterpToEquiSpaced
eEquiSpacedToCoeffs
eNormDerivOnTrace
SIZE_MatrixType

Definition at line 80 of file StdRegions.hpp.

{
    eNoMatrixType,
    eMass,
    eMassGJP,
    eInvMass,
    eLaplacian,
    eLaplacian00,
    eLaplacian01,
    eLaplacian02,
    eLaplacian10,
    eLaplacian11,
    eLaplacian12,
    eLaplacian20,
    eLaplacian21,
    eLaplacian22,
    eInvLaplacianWithUnityMean,
    eWeakDeriv0,
    eWeakDeriv1,
    eWeakDeriv2,
    eWeakDirectionalDeriv,
    eMassLevelCurvature,
    eLinearAdvection,
    eLinearAdvectionReaction,
    eLinearAdvectionDiffusionReaction,
    eLinearAdvectionDiffusionReactionGJP,
    eNBasisTrans,
    eInvNBasisTrans,
    eBwdTrans,
    eBwdMat,
    eIProductWRTBase,
    eIProductWRTDerivBase0,
    eIProductWRTDerivBase1,
    eIProductWRTDerivBase2,
    eDerivBase0,
    eDerivBase1,
    eDerivBase2,
    eHelmholtz,
    eHelmholtzGJP,
    eHybridDGHelmholtz,
    eInvHybridDGHelmholtz,
    eHybridDGHelmBndLam,
    eHybridDGLamToQ0,
    eHybridDGLamToQ1,
    eHybridDGLamToQ2,
    eHybridDGLamToU,
    eFwdTrans,
    ePreconR,
    ePreconRMass,
    ePreconLinearSpace,
    ePreconLinearSpaceMass,
    eInterpGauss,
    eGaussDG,
    ePhysInterpToEquiSpaced,
    eEquiSpacedToCoeffs,
    eNormDerivOnTrace,
    SIZE_MatrixType
};

Orientation

enum Nektar::StdRegions::Orientation

Enumerator
eNoOrientation
eFwd
eBwd
eForwards
eBackwards
eDir1FwdDir1_Dir2FwdDir2
eDir1FwdDir1_Dir2BwdDir2
eDir1BwdDir1_Dir2FwdDir2
eDir1BwdDir1_Dir2BwdDir2
eDir1FwdDir2_Dir2FwdDir1
eDir1FwdDir2_Dir2BwdDir1
eDir1BwdDir2_Dir2FwdDir1
eDir1BwdDir2_Dir2BwdDir1
SIZE_Orientation

Definition at line 437 of file StdRegions.hpp.

{
    eNoOrientation,
    eFwd,
    eBwd,
    eForwards,
    eBackwards,
    eDir1FwdDir1_Dir2FwdDir2, // These flags are interpreted as
    eDir1FwdDir1_Dir2BwdDir2, // taking the second direction to the
    eDir1BwdDir1_Dir2FwdDir2, // first direction. So Dir1FwdDir2 takes
    eDir1BwdDir1_Dir2BwdDir2, // direction 2 and makes it backward
    eDir1FwdDir2_Dir2FwdDir1, // to direction 1 in the mapped face.
    eDir1FwdDir2_Dir2BwdDir1, // Note be careful not to flip this
    eDir1BwdDir2_Dir2FwdDir1, // convention especially when using
    eDir1BwdDir2_Dir2BwdDir1, // transposed mappings.
    SIZE_Orientation
};

VarCoeffType

enum Nektar::StdRegions::VarCoeffType

Enumerator
eVarCoeffMass
eVarCoeffLaplacian
eVarCoeffWeakDeriv
eVarCoeffD00
eVarCoeffD01
eVarCoeffD02
eVarCoeffD10
eVarCoeffD11
eVarCoeffD12
eVarCoeffD20
eVarCoeffD21
eVarCoeffD22
eVarCoeffVelX
eVarCoeffVelY
eVarCoeffVelZ
eVarCoeffMF1x
eVarCoeffMF1y
eVarCoeffMF1z
eVarCoeffMF1Div
eVarCoeffMF1Mag
eVarCoeffMF2x
eVarCoeffMF2y
eVarCoeffMF2z
eVarCoeffMF2Div
eVarCoeffMF2Mag
eVarCoeffMF3x
eVarCoeffMF3y
eVarCoeffMF3z
eVarCoeffMF3Div
eVarCoeffMF3Mag
eVarCoeffMF
eVarCoeffMFDiv
eVarCoeffGmat
eVarCoeffGJPNormVel
SIZE_VarCoeffType

Definition at line 195 of file StdRegions.hpp.

{
    eVarCoeffMass,
    eVarCoeffLaplacian,
    eVarCoeffWeakDeriv,
    eVarCoeffD00,
    eVarCoeffD01,
    eVarCoeffD02,
    eVarCoeffD10,
    eVarCoeffD11,
    eVarCoeffD12,
    eVarCoeffD20,
    eVarCoeffD21,
    eVarCoeffD22,
    eVarCoeffVelX,
    eVarCoeffVelY,
    eVarCoeffVelZ,
    eVarCoeffMF1x,
    eVarCoeffMF1y,
    eVarCoeffMF1z,
    eVarCoeffMF1Div,
    eVarCoeffMF1Mag,
    eVarCoeffMF2x,
    eVarCoeffMF2y,
    eVarCoeffMF2z,
    eVarCoeffMF2Div,
    eVarCoeffMF2Mag,
    eVarCoeffMF3x,
    eVarCoeffMF3y,
    eVarCoeffMF3z,
    eVarCoeffMF3Div,
    eVarCoeffMF3Mag,
    eVarCoeffMF,
    eVarCoeffMFDiv,
    eVarCoeffGmat,
    eVarCoeffGJPNormVel,
    SIZE_VarCoeffType
};

Function Documentation

EvaluateQuadFaceBasisKey()

LibUtilities::BasisKey Nektar::StdRegions::EvaluateQuadFaceBasisKey	(	const int	facedir,
		const LibUtilities::BasisType	faceDirBasisType,
		const int	numpoints,
		const int	nummodes
	)

Definition at line 438 of file StdExpansion3D.cpp.

{
 
    switch (faceDirBasisType)
    {
        case LibUtilities::eModified_A:
        {
            const LibUtilities::PointsKey pkey(
                numpoints, LibUtilities::eGaussLobattoLegendre);
            return LibUtilities::BasisKey(LibUtilities::eModified_A, nummodes,
                                          pkey);
        }
        case LibUtilities::eModified_B:
        case LibUtilities::eModified_C:
        {
            const LibUtilities::PointsKey pkey(
                numpoints + 1, LibUtilities::eGaussLobattoLegendre);
            return LibUtilities::BasisKey(LibUtilities::eModified_A, nummodes,
                                          pkey);
        }
        case LibUtilities::eGLL_Lagrange:
        {
            const LibUtilities::PointsKey pkey(
                numpoints, LibUtilities::eGaussLobattoLegendre);
            return LibUtilities::BasisKey(LibUtilities::eGLL_Lagrange, nummodes,
                                          pkey);
        }
        case LibUtilities::eOrtho_A:
        {
            const LibUtilities::PointsKey pkey(
                numpoints, LibUtilities::eGaussLobattoLegendre);
            return LibUtilities::BasisKey(LibUtilities::eOrtho_A, nummodes,
                                          pkey);
        }
        case LibUtilities::eOrtho_B:
        case LibUtilities::eOrtho_C:
        {
            const LibUtilities::PointsKey pkey(
                numpoints + 1, LibUtilities::eGaussLobattoLegendre);
            return LibUtilities::BasisKey(LibUtilities::eOrtho_A, nummodes,
                                          pkey);
        }
        default:
        {
            NEKERROR(ErrorUtil::efatal, "expansion type unknown");
            break;
        }
    }
 
    // Keep things happy by returning a value.
    return LibUtilities::NullBasisKey;
}

References Nektar::ErrorUtil::efatal, Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eGLL_Lagrange, Nektar::LibUtilities::eModified_A, Nektar::LibUtilities::eModified_B, Nektar::LibUtilities::eModified_C, Nektar::LibUtilities::eOrtho_A, Nektar::LibUtilities::eOrtho_B, Nektar::LibUtilities::eOrtho_C, NEKERROR, and Nektar::LibUtilities::NullBasisKey().

Referenced by Nektar::StdRegions::StdHexExp::v_GetTraceBasisKey(), Nektar::StdRegions::StdPrismExp::v_GetTraceBasisKey(), and Nektar::StdRegions::StdPyrExp::v_GetTraceBasisKey().

EvaluateTriFaceBasisKey()

LibUtilities::BasisKey Nektar::StdRegions::EvaluateTriFaceBasisKey	(	const int	facedir,
		const LibUtilities::BasisType	faceDirBasisType,
		const int	numpoints,
		const int	nummodes
	)

Definition at line 494 of file StdExpansion3D.cpp.

{
    switch (faceDirBasisType)
    {
        case LibUtilities::eModified_A:
        {
            const LibUtilities::PointsKey pkey(
                numpoints, LibUtilities::eGaussLobattoLegendre);
            return LibUtilities::BasisKey(LibUtilities::eModified_A, nummodes,
                                          pkey);
        }
        case LibUtilities::eModified_B:
        case LibUtilities::eModified_C:
        case LibUtilities::eModifiedPyr_C:
        {
            switch (facedir)
            {
                case 0:
                {
                    const LibUtilities::PointsKey pkey(
                        numpoints + 1, LibUtilities::eGaussLobattoLegendre);
                    return LibUtilities::BasisKey(LibUtilities::eModified_A,
                                                  nummodes, pkey);
                }
                case 1:
                {
                    const LibUtilities::PointsKey pkey(
                        numpoints, LibUtilities::eGaussRadauMAlpha1Beta0);
                    return LibUtilities::BasisKey(LibUtilities::eModified_B,
                                                  nummodes, pkey);
                }
                default:
                {
 
                    NEKERROR(ErrorUtil::efatal, "invalid value to flag");
                    break;
                }
            }
            break;
        }
 
        case LibUtilities::eGLL_Lagrange:
        {
            switch (facedir)
            {
                case 0:
                {
                    const LibUtilities::PointsKey pkey(
                        numpoints, LibUtilities::eGaussLobattoLegendre);
                    return LibUtilities::BasisKey(LibUtilities::eOrtho_A,
                                                  nummodes, pkey);
                }
                case 1:
                {
                    const LibUtilities::PointsKey pkey(
                        numpoints, LibUtilities::eGaussRadauMAlpha1Beta0);
                    return LibUtilities::BasisKey(LibUtilities::eOrtho_B,
                                                  nummodes, pkey);
                }
                default:
                {
                    NEKERROR(ErrorUtil::efatal, "invalid value to flag");
                    break;
                }
            }
            break;
        }
 
        case LibUtilities::eOrtho_A:
        case LibUtilities::eOrtho_B:
        case LibUtilities::eOrtho_C:
        case LibUtilities::eOrthoPyr_C:
        {
            switch (facedir)
            {
                case 0:
                {
                    const LibUtilities::PointsKey pkey(
                        numpoints, LibUtilities::eGaussLobattoLegendre);
                    return LibUtilities::BasisKey(LibUtilities::eOrtho_A,
                                                  nummodes, pkey);
                }
                case 1:
                {
                    const LibUtilities::PointsKey pkey(
                        numpoints, LibUtilities::eGaussRadauMAlpha1Beta0);
                    return LibUtilities::BasisKey(LibUtilities::eOrtho_B,
                                                  nummodes, pkey);
                }
                default:
                {
                    NEKERROR(ErrorUtil::efatal, "invalid value to flag");
                    break;
                }
            }
            break;
        }
        default:
        {
            NEKERROR(ErrorUtil::efatal, "expansion type unknown");
            break;
        }
    }
 
    // Keep things happy by returning a value.
    return LibUtilities::NullBasisKey;
}

References Nektar::ErrorUtil::efatal, Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eGLL_Lagrange, Nektar::LibUtilities::eModified_A, Nektar::LibUtilities::eModified_B, Nektar::LibUtilities::eModified_C, Nektar::LibUtilities::eModifiedPyr_C, Nektar::LibUtilities::eOrtho_A, Nektar::LibUtilities::eOrtho_B, Nektar::LibUtilities::eOrtho_C, Nektar::LibUtilities::eOrthoPyr_C, NEKERROR, and Nektar::LibUtilities::NullBasisKey().

Referenced by Nektar::StdRegions::StdPrismExp::v_GetTraceBasisKey(), Nektar::StdRegions::StdPyrExp::v_GetTraceBasisKey(), and Nektar::StdRegions::StdTetExp::v_GetTraceBasisKey().

find()

template<class InputIterator , class EqualityComparable >

InputIterator Nektar::StdRegions::find	(	InputIterator	first,
		InputIterator	last,
		InputIterator	startingpoint,
		const EqualityComparable &	value
	)

Definition at line 475 of file StdRegions.hpp.

{
    InputIterator val;
 
    if (startingpoint == first)
    {
        val = find(first, last, value);
    }
    else
    {
        val = find(startingpoint, last, value);
        if (val == last)
        {
            val = find(first, startingpoint, value);
            if (val == startingpoint)
            {
                val = last;
            }
        }
    }
    return val;
}

References find().

Referenced by Nektar::SolverUtils::ForcingAbsorption::CalcAbsorption(), Nektar::FieldUtils::Iso::Condense(), Nektar::SolverUtils::FilterThresholdMax::FilterThresholdMax(), Nektar::SolverUtils::FilterThresholdMin::FilterThresholdMin(), find(), Nektar::SolverUtils::Coupling::GenerateVariableMapping(), Nektar::ParseUtils::GenerateVariableVector(), Nektar::SpatialDomains::MeshGraph::GetCompositeList(), Nektar::LibUtilities::Interpreter::ExpressionEvaluator::GetConstant(), Nektar::FieldUtils::ProcessMapping::GetMapping(), Nektar::MultiRegions::AssemblyCommDG::InitialiseStructure(), Nektar::FieldUtils::ProcessCreateExp::LoadFieldData(), Nektar::SpatialDomains::BoundaryConditions::ReadBoundaryConditions(), Nektar::SpatialDomains::MeshGraph::ReadExpansionInfo(), Nektar::FieldUtils::Field::ReadFieldDefs(), Nektar::LibUtilities::SessionReader::ReadVariables(), Nektar::LibUtilities::CsvIO::v_ImportPtsFieldData(), Nektar::SolverUtils::FilterAeroForces::v_Initialise(), Nektar::FilterMovingBody::v_Initialise(), Nektar::Dummy::v_InitObject(), Nektar::Dummy::v_PostIntegrate(), Nektar::FieldUtils::InputFld::v_Process(), Nektar::FieldUtils::ProcessAddCompositeID::v_Process(), Nektar::FieldUtils::ProcessAddFld::v_Process(), Nektar::FieldUtils::ProcessFieldFromString::v_Process(), Nektar::FieldUtils::ProcessRemoveField::v_Process(), and Nektar::SpatialDomains::MeshGraphIOXml::v_ReadCurves().

operator<()

bool Nektar::StdRegions::operator<	(	const StdMatrixKey &	lhs,
		const StdMatrixKey &	rhs
	)

Definition at line 94 of file StdMatrixKey.cpp.

{
    if (lhs.m_matrixType < rhs.m_matrixType)
    {
        return true;
    }
 
    if (lhs.m_matrixType > rhs.m_matrixType)
    {
        return false;
    }
 
    if (lhs.m_ncoeffs < rhs.m_ncoeffs) // probably do not need this check since
                                       // checking the m_base below?
    {
        return true;
    }
 
    if (lhs.m_ncoeffs > rhs.m_ncoeffs)
    {
        return false;
    }
 
    if (LibUtilities::ShapeTypeDimMap[lhs.m_shapeType] <
        LibUtilities::ShapeTypeDimMap[rhs.m_shapeType])
    {
        return true;
    }
 
    if (LibUtilities::ShapeTypeDimMap[lhs.m_shapeType] >
        LibUtilities::ShapeTypeDimMap[rhs.m_shapeType])
    {
        return false;
    }
 
    for (unsigned int i = 0; i < LibUtilities::ShapeTypeDimMap[lhs.m_shapeType];
         ++i)
    {
        if (lhs.m_base[i].get() < rhs.m_base[i].get())
        {
            return true;
        }
 
        if (lhs.m_base[i].get() > rhs.m_base[i].get())
        {
            return false;
        }
    }
 
    if (lhs.m_factors.size() < rhs.m_factors.size())
    {
        return true;
    }
    else if (lhs.m_factors.size() > rhs.m_factors.size())
    {
        return false;
    }
    else
    {
        for (auto x = lhs.m_factors.begin(), y = rhs.m_factors.begin();
             x != lhs.m_factors.end(); ++x, ++y)
        {
            if (x->second < y->second)
            {
                return true;
            }
            if (x->second > y->second)
            {
                return false;
            }
        }
    }
 
    if (lhs.m_varcoeffs.size() < rhs.m_varcoeffs.size())
    {
        return true;
    }
 
    if (lhs.m_varcoeffs.size() > rhs.m_varcoeffs.size())
    {
        return false;
    }
 
    for (unsigned int i = 0; i < lhs.m_varcoeff_hashes.size(); ++i)
    {
        if (lhs.m_varcoeff_hashes[i] < rhs.m_varcoeff_hashes[i])
        {
            return true;
        }
        if (lhs.m_varcoeff_hashes[i] > rhs.m_varcoeff_hashes[i])
        {
            return false;
        }
    }
 
    if (lhs.m_nodalPointsType < rhs.m_nodalPointsType)
    {
        return true;
    }
 
    if (lhs.m_nodalPointsType > rhs.m_nodalPointsType)
    {
        return false;
    }
 
    return false;
}

operator<<()

std::ostream & Nektar::StdRegions::operator<<	(	std::ostream &	os,
		const StdMatrixKey &	rhs
	)

Definition at line 277 of file StdMatrixKey.cpp.

{
    os << "MatrixType: " << MatrixTypeMap[rhs.GetMatrixType()]
       << ", ShapeType: " << LibUtilities::ShapeTypeMap[rhs.GetShapeType()]
       << ", Ncoeffs: " << rhs.GetNcoeffs() << std::endl;
 
    if (rhs.GetConstFactors().size())
    {
        os << "Constants: " << endl;
        for (auto &x : rhs.GetConstFactors())
        {
            os << "\t value " << ConstFactorTypeMap[x.first] << " : "
               << x.second << endl;
        }
    }
    if (rhs.GetVarCoeffs().size())
    {
        os << "Variable coefficients: " << endl;
        unsigned int i = 0;
        for (auto &x : rhs.GetVarCoeffs())
        {
            os << "\t Coeff defined: " << VarCoeffTypeMap[x.first] << endl;
            os << "\t Hash:          " << rhs.GetVarCoeffHashes()[i++] << endl;
        }
    }
 
    for (unsigned int i = 0;
         i < LibUtilities::ShapeTypeDimMap[rhs.GetShapeType()]; ++i)
    {
        os << rhs.GetBase()[i]->GetBasisKey();
    }
 
    return os;
}

References ConstFactorTypeMap, Nektar::StdRegions::StdMatrixKey::GetBase(), Nektar::StdRegions::StdMatrixKey::GetConstFactors(), Nektar::StdRegions::StdMatrixKey::GetMatrixType(), Nektar::StdRegions::StdMatrixKey::GetNcoeffs(), Nektar::StdRegions::StdMatrixKey::GetShapeType(), Nektar::StdRegions::StdMatrixKey::GetVarCoeffHashes(), Nektar::StdRegions::StdMatrixKey::GetVarCoeffs(), MatrixTypeMap, Nektar::LibUtilities::ShapeTypeDimMap, Nektar::LibUtilities::ShapeTypeMap, and VarCoeffTypeMap.

operator==()

bool Nektar::StdRegions::operator==	(	const StdMatrixKey &	lhs,
		const StdMatrixKey &	rhs
	)

Definition at line 202 of file StdMatrixKey.cpp.

{
    if (lhs.m_matrixType != rhs.m_matrixType)
    {
        return false;
    }
 
    if (lhs.m_ncoeffs != rhs.m_ncoeffs)
    {
        return false;
    }
 
    for (unsigned int i = 0; i < LibUtilities::ShapeTypeDimMap[lhs.m_shapeType];
         ++i)
    {
        if (lhs.m_base[i].get() != rhs.m_base[i].get())
        {
            return false;
        }
    }
 
    if (lhs.m_factors.size() != rhs.m_factors.size())
    {
        return false;
    }
 
    if (!std::equal(lhs.m_factors.begin(), lhs.m_factors.end(),
                    rhs.m_factors.begin()))
    {
        return false;
    }
 
    if (lhs.m_nodalPointsType != rhs.m_nodalPointsType)
    {
        return false;
    }
 
    if (lhs.m_varcoeffs.size() != rhs.m_varcoeffs.size())
    {
        return false;
    }
 
    for (unsigned int i = 0; i < lhs.m_varcoeff_hashes.size(); ++i)
    {
        if (lhs.m_varcoeff_hashes[i] != rhs.m_varcoeff_hashes[i])
        {
            return false;
        }
    }
 
    for (auto &x : lhs.m_varcoeffs)
    {
        auto y = rhs.m_varcoeffs.find(x.first);
        // Check var coeff is found
        if (y == rhs.m_varcoeffs.end())
        {
            return false;
        }
 
        if (x.second.GetValue() != y->second.GetValue())
        {
            return false;
        }
    }
    for (unsigned int i = 0; i < lhs.m_varcoeffs.size(); ++i)
    {
        if (lhs.m_varcoeff_hashes[i] != rhs.m_varcoeff_hashes[i])
        {
            return false;
        }
    }
 
    return true;
}

RestrictCoeffMap()

VarCoeffMap Nektar::StdRegions::RestrictCoeffMap ( const VarCoeffMap &  m, size_t  offset, size_t  cnt  )

inline

Definition at line 378 of file StdRegions.hpp.

{
    VarCoeffMap ret;
 
    for (auto &x : m)
    {
        ret[x.first] = x.second.restrict(offset, cnt);
    }
 
    return ret;
}

Referenced by Nektar::MultiRegions::ExpList::GenBlockMatrix(), Nektar::MultiRegions::ExpList::GeneralMatrixOp(), Nektar::MultiRegions::ExpList::GenGlobalMatrix(), Nektar::MultiRegions::ExpList::GenGlobalMatrixFull(), Nektar::MultiRegions::GlobalLinSys::GetBlockMatrixKey(), Nektar::Collections::Helmholtz_NoCollection::operator()(), and Nektar::Collections::LinearAdvectionDiffusionReaction_NoCollection::operator()().

Variable Documentation

ConstFactorTypeMap

const char* const Nektar::StdRegions::ConstFactorTypeMap[]

Initial value:

= {"FactorLambda",
                                          "FactorCoeffD00",
                                          "FactorCoeffD11",
                                          "FactorCoeffD22",
                                          "FactorCoeffD01",
                                          "FactorCoeffD02",
                                          "FactorCoeffD12",
                                          "FactorTau",
                                          "FactorTime",
                                          "FactorSVVCutoffRatio",
                                          "FactorSVVDiffCoeff",
                                          "FactorSVVPowerKerDiffCoeff",
                                          "FactorSVVDGKerDiffCoeff",
                                          "FactorGaussVertex",
                                          "FactorGaussEdge",
                                          "FactorGJP",
                                          "FactorConstant"}

Definition at line 413 of file StdRegions.hpp.

Referenced by export_StdMatrixKey(), Nektar::StdRegions::StdMatrixKey::GetConstFactor(), Nektar::MultiRegions::operator<<(), operator<<(), Nektar::Collections::Helmholtz_IterPerExp::UpdateFactors(), Nektar::Collections::Helmholtz_MatrixFree::UpdateFactors(), Nektar::Collections::LinearAdvectionDiffusionReaction_IterPerExp::UpdateFactors(), Nektar::Collections::LinearAdvectionDiffusionReaction_MatrixFree::UpdateFactors(), Nektar::Collections::PhysInterp1DScaled_Helper::UpdateFactors(), and Nektar::Collections::PhysInterp1DScaled_MatrixFree::UpdateFactors().

ElementTypeMap

const char* const Nektar::StdRegions::ElementTypeMap[]

Initial value:

= {
    
    "StdSegExp", "SegExp",    "StdQuadExp",     "StdTriExp", "StdNodalTriExp",
    "QuadExp",   "TriExp",    "NodalTriExp",    "StdHexExp", "StdPrismExp",
    "StdPyrExp", "StdTetExp", "StdNodalTetExp", "HexExp",    "PrismExp",
    "PyrExp",    "TetExp",    "NodalTetExp",
}

Definition at line 69 of file StdRegions.hpp.

kSVVDGFilter

const NekDouble Nektar::StdRegions::kSVVDGFilter[9][11]

Initial value:

= {
    {0, 0.36212, 1, 0, 0, 0, 0, 0, 0, 0, 0},
    {0, 0.70546, 0.078836, 1, 0, 0, 0, 0, 0, 0, 0},
    {0, 0, 0.49411, 0.072394, 1, 0, 0, 0, 0, 0, 0},
    {0, 0, 0.000073566, 0.40506, 0.094122, 1, 0, 0, 0, 0, 0},
    {0, 0, 0, 0.0001422, 0.36863, 0.11815, 1, 0, 0, 0, 0},
    {0, 0, 0, 0, 0.00019497, 0.41397, 0.16927, 1, 0, 0, 0},
    {0, 0, 0, 0, 0, 0.0009762, 0.12747, 0.13763, 1, 0, 0},
    {0, 0, 0, 0, 0, 0, 0.0023592, 0.23683, 0.17196, 1, 0},
    {0, 0, 0, 0, 0, 0, 0, 0.0026055, 0.28682, 0.22473, 1}}

Definition at line 503 of file StdRegions.hpp.

Referenced by Nektar::StdRegions::StdHexExp::v_SVVLaplacianFilter(), Nektar::StdRegions::StdPrismExp::v_SVVLaplacianFilter(), Nektar::StdRegions::StdPyrExp::v_SVVLaplacianFilter(), Nektar::StdRegions::StdQuadExp::v_SVVLaplacianFilter(), Nektar::StdRegions::StdTetExp::v_SVVLaplacianFilter(), and Nektar::StdRegions::StdTriExp::v_SVVLaplacianFilter().

kSVVDGFiltermodesmax

const int Nektar::StdRegions::kSVVDGFiltermodesmax = 11

Definition at line 501 of file StdRegions.hpp.

Referenced by Nektar::StdRegions::StdHexExp::v_SVVLaplacianFilter(), Nektar::StdRegions::StdPrismExp::v_SVVLaplacianFilter(), Nektar::StdRegions::StdPyrExp::v_SVVLaplacianFilter(), Nektar::StdRegions::StdQuadExp::v_SVVLaplacianFilter(), Nektar::StdRegions::StdTetExp::v_SVVLaplacianFilter(), and Nektar::StdRegions::StdTriExp::v_SVVLaplacianFilter().

kSVVDGFiltermodesmin

const int Nektar::StdRegions::kSVVDGFiltermodesmin = 3

Definition at line 500 of file StdRegions.hpp.

Referenced by Nektar::StdRegions::StdHexExp::v_SVVLaplacianFilter(), Nektar::StdRegions::StdPrismExp::v_SVVLaplacianFilter(), Nektar::StdRegions::StdPyrExp::v_SVVLaplacianFilter(), Nektar::StdRegions::StdQuadExp::v_SVVLaplacianFilter(), Nektar::StdRegions::StdTetExp::v_SVVLaplacianFilter(), and Nektar::StdRegions::StdTriExp::v_SVVLaplacianFilter().

MatrixTypeMap

const char* const Nektar::StdRegions::MatrixTypeMap[]

Definition at line 139 of file StdRegions.hpp.

Referenced by Nektar::StdRegions::StdExpansion::CreateGeneralMatrix(), export_StdMatrixKey(), Nektar::MultiRegions::GlobalLinSysIterative::GlobalLinSysIterative(), Nektar::MultiRegions::operator<<(), and operator<<().

NullConstFactorMap

ConstFactorMap Nektar::StdRegions::NullConstFactorMap

static

Definition at line 431 of file StdRegions.hpp.

Referenced by Nektar::LocalRegions::Expansion2D::AddHDGHelmholtzEdgeTerms(), Nektar::LocalRegions::Expansion3D::AddHDGHelmholtzFaceTerms(), Nektar::StdRegions::StdExpansion::CreateGeneralMatrix(), Nektar::LocalRegions::Expansion2D::CreateMatrix(), ExpList_HelmSolve(), Nektar::LocalRegions::NodalTriExp::FwdTrans(), MatrixKey_Init(), Nektar::StdRegions::StdNodalPrismExp::ModalToNodal(), Nektar::StdRegions::StdNodalTetExp::ModalToNodal(), Nektar::StdRegions::StdNodalTriExp::ModalToNodal(), Nektar::StdRegions::StdNodalPrismExp::NodalToModal(), Nektar::StdRegions::StdNodalTetExp::NodalToModal(), Nektar::StdRegions::StdNodalTriExp::NodalToModal(), Nektar::StdRegions::StdNodalPrismExp::NodalToModalTranspose(), Nektar::StdRegions::StdNodalTetExp::NodalToModalTranspose(), Nektar::StdRegions::StdNodalTriExp::NodalToModalTranspose(), StdMatrixKey_Init(), Nektar::LocalRegions::Expansion2D::v_AddRobinMassMatrix(), Nektar::LocalRegions::Expansion3D::v_AddRobinMassMatrix(), Nektar::LocalRegions::Expansion2D::v_AddRobinTraceContribution(), Nektar::StdRegions::StdNodalPrismExp::v_FwdTrans(), Nektar::StdRegions::StdNodalTetExp::v_FwdTrans(), Nektar::StdRegions::StdNodalTriExp::v_FwdTrans(), Nektar::LocalRegions::Expansion2D::v_GenMatrix(), and Nektar::LocalRegions::Expansion3D::v_GenMatrix().

NullFactorMap

FactorMap Nektar::StdRegions::NullFactorMap

static

Definition at line 435 of file StdRegions.hpp.

Referenced by Nektar::Collections::Helmholtz_IterPerExp::Helmholtz_IterPerExp(), Nektar::Collections::Helmholtz_MatrixFree::Helmholtz_MatrixFree(), Nektar::Collections::LinearAdvectionDiffusionReaction_IterPerExp::LinearAdvectionDiffusionReaction_IterPerExp(), and Nektar::Collections::LinearAdvectionDiffusionReaction_MatrixFree::LinearAdvectionDiffusionReaction_MatrixFree().

NullVarCoeffMap

VarCoeffMap Nektar::StdRegions::NullVarCoeffMap

static

Definition at line 376 of file StdRegions.hpp.

Referenced by Nektar::StdRegions::StdExpansion::CreateGeneralMatrix(), Nektar::LocalRegions::Expansion2D::CreateMatrix(), Nektar::LocalRegions::Expansion3D::CreateMatrix(), ExpList_HelmSolve(), Nektar::LocalRegions::NodalTriExp::FwdTrans(), Nektar::Collections::Helmholtz_IterPerExp::Helmholtz_IterPerExp(), Nektar::Collections::Helmholtz_MatrixFree::Helmholtz_MatrixFree(), Nektar::Collections::Helmholtz_NoCollection::Helmholtz_NoCollection(), Nektar::Collections::LinearAdvectionDiffusionReaction_IterPerExp::LinearAdvectionDiffusionReaction_IterPerExp(), Nektar::Collections::LinearAdvectionDiffusionReaction_MatrixFree::LinearAdvectionDiffusionReaction_MatrixFree(), Nektar::Collections::LinearAdvectionDiffusionReaction_NoCollection::LinearAdvectionDiffusionReaction_NoCollection(), MatrixKey_Init(), Nektar::StdRegions::StdNodalPrismExp::ModalToNodal(), Nektar::StdRegions::StdNodalTetExp::ModalToNodal(), Nektar::StdRegions::StdNodalTriExp::ModalToNodal(), Nektar::StdRegions::StdNodalPrismExp::NodalToModal(), Nektar::StdRegions::StdNodalTetExp::NodalToModal(), Nektar::StdRegions::StdNodalTriExp::NodalToModal(), Nektar::StdRegions::StdNodalPrismExp::NodalToModalTranspose(), Nektar::StdRegions::StdNodalTetExp::NodalToModalTranspose(), Nektar::StdRegions::StdNodalTriExp::NodalToModalTranspose(), Nektar::Collections::Helmholtz_NoCollection::operator()(), Nektar::Collections::LinearAdvectionDiffusionReaction_NoCollection::operator()(), StdMatrixKey_Init(), Nektar::StdRegions::StdNodalPrismExp::v_FwdTrans(), Nektar::StdRegions::StdNodalTetExp::v_FwdTrans(), Nektar::StdRegions::StdNodalTriExp::v_FwdTrans(), Nektar::VCSImplicit::v_SolvePressure(), Nektar::VCSWeakPressure::v_SolvePressure(), and Nektar::VelocityCorrectionScheme::v_SolveViscous().

OrientationMap

const char* const Nektar::StdRegions::OrientationMap[]

Initial value:

= {"NoOrientation",
                                      "Fwd",
                                      "Bwd",
                                      "Forwards",
                                      "Backwards",
                                      "Dir1FwdDir1_Dir2FwdDir2",
                                      "Dir1FwdDir1_Dir2BwdDir2",
                                      "Dir1BwdDir1_Dir2FwdDir2",
                                      "Dir1BwdDir1_Dir2BwdDir2",
                                      "Dir1FwdDir2_Dir2FwdDir1",
                                      "Dir1FwdDir2_Dir2BwdDir1",
                                      "Dir1BwdDir2_Dir2FwdDir1",
                                      "Dir1BwdDir2_Dir2BwdDir1"}

Definition at line 455 of file StdRegions.hpp.

VarCoeffTypeMap

const char* const Nektar::StdRegions::VarCoeffTypeMap[]

Initial value:

= {
    "VarCoeffMass",      "VarCoeffLaplacian", "VarCoeffWeakDeriv",
    "VarCoeffD00",       "VarCoeffD01",       "VarCoeffD02",
    "VarCoeffD10",       "VarCoeffD11",       "VarCoeffD12",
    "VarCoeffD20",       "VarCoeffD21",       "VarCoeffD22",
    "VarCoeffVelX",      "VarCoeffVelY",      "VarCoeffVelZ",
    "VarCoeffMF1x",      "VarCoeffMF1y",      "VarCoeffMF1z",
    "VarCoeffMF1Div",    "VarCoeffMF1Mag",    "VarCoeffMF2x",
    "VarCoeffMF2y",      "VarCoeffMF2z",      "VarCoeffMF2Div",
    "VarCoeffMF2Mag",    "VarCoeffMF3x",      "VarCoeffMF3y",
    "VarCoeffMF3z",      "VarCoeffMF3Div",    "VarCoeffMF3Mag",
    "VarCoeffMF",        "VarCoeffMFDiv",     "VarCoeffGmat",
    "VarCoeffGJPNormVel"}

Definition at line 234 of file StdRegions.hpp.

Referenced by export_StdMatrixKey(), Nektar::StdRegions::StdMatrixKey::GetVarCoeff(), Nektar::StdRegions::StdMatrixKey::GetVarCoeffAsMap(), and operator<<().