Nektar++
Loading...
Searching...
No Matches
Classes | Typedefs | Enumerations | Functions | Variables
Nektar::StdRegions Namespace Reference

Classes

class  StdExpansion
 The base class for all shapes. More...
 
class  StdExpansion0D
 
class  StdExpansion1D
 
class  StdExpansion2D
 
class  StdExpansion3D
 
struct  StdFacKey
 
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...
 
struct  VarCoeffList
 

Typedefs

typedef std::shared_ptr< StdExpansion > StdExpansionSharedPtr
 
typedef std::vector< StdExpansionSharedPtr > StdExpansionVector
 
typedef std::shared_ptr< StdExpansion0D > StdExpansion0DSharedPtr
 
using vec_t = tinysimd::scalarT< double >
 
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::map< StdRegions::ConstFactorType, Array< OneD, NekDouble > > VarFactorsMap
 
typedef std::shared_ptr< StdSegExp > StdSegExpSharedPtr
 
typedef std::shared_ptr< StdTetExp > StdTetExpSharedPtr
 
typedef std::shared_ptr< StdTriExp > StdTriExpSharedPtr
 

Enumerations

enum  StdFacType {
  eWeights1 , eWeights2 , eHalfMultOnePlusZ0 , eHalfMultOnePlusZ1 ,
  eTwoOverOneMinusZ1 , eTwoOverOneMinusZ2
}
 
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 , eInvBwdTrans ,
  eBwdMat , eIProductWRTBase , eInvIProductWRTBase , eIProductWRTDerivBase0 ,
  eIProductWRTDerivBase1 , eIProductWRTDerivBase2 , eDerivBase0 , eDerivBase1 ,
  eDerivBase2 , eHelmholtz , eHelmholtzGJP , eHybridDGHelmholtz ,
  eInvHybridDGHelmholtz , eHybridDGHelmBndLam , eHybridDGLamToQ0 , eHybridDGLamToQ1 ,
  eHybridDGLamToQ2 , eHybridDGLamToU , eFwdTrans , ePreconR ,
  ePreconRMass , ePreconLinearSpace , ePreconLinearSpaceMass , eInterpGauss ,
  eGaussDG , ePhysInterpToEquiSpaced , ePhysInterpToGLL , eCoeffsToEquiSpaced ,
  eEquiSpacedToCoeffs , eCoeffsToGLL , eGLLToCoeffs , eEquiSpacedToPhys ,
  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 ,
  eFactorGJPTraceWeight , 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::BasisSharedPtr &faceDirBasis)
 
LibUtilities::BasisKey EvaluateTriFaceBasisKey (const int facedir, const LibUtilities::BasisSharedPtr &faceDirBasis, bool UseGLL)
 
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 []
 
constexpr std::array< VarCoeffType, 1 > massVarCoeffs {eVarCoeffMass}
 
constexpr std::array< VarCoeffType, 10 > laplacianVarCoeffs
 
constexpr std::array< VarCoeffType, 3 > advectionVarCoeffs
 
constexpr std::array< std::pair< MatrixType, VarCoeffList >, 3 > MatrixTypeToVarCoeffsMap
 
static VarCoeffMap NullVarCoeffMap
 
const char *const ConstFactorTypeMap []
 
static ConstFactorMap NullConstFactorMap
 
static FactorMap NullFactorMap
 
static VarFactorsMap NullVarFactorsMap
 
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 489 of file StdRegions.hpp.

◆ FactorMap

typedef ConstFactorMap Nektar::StdRegions::FactorMap

Definition at line 493 of file StdRegions.hpp.

◆ StdExpansion0DSharedPtr

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

Definition at line 74 of file StdExpansion0D.h.

◆ StdExpansion1DSharedPtr

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

Definition at line 132 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 1817 of file StdExpansion.h.

◆ StdExpansionVector

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

Definition at line 1818 of file StdExpansion.h.

◆ StdHexExpSharedPtr

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

Definition at line 193 of file StdHexExp.h.

◆ StdMatrixKeySharedPtr

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

Definition at line 255 of file StdMatrixKey.h.

◆ StdNodalPrismExpSharedPtr

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

Definition at line 128 of file StdNodalPrismExp.h.

◆ StdNodalTetExpSharedPtr

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

Definition at line 128 of file StdNodalTetExp.h.

◆ StdNodalTriExpSharedPtr

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

Definition at line 156 of file StdNodalTriExp.h.

◆ StdPointExpSharedPtr

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

Definition at line 132 of file StdPointExp.h.

◆ StdPrismExpSharedPtr

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

Definition at line 184 of file StdPrismExp.h.

◆ StdPyrExpSharedPtr

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

Definition at line 178 of file StdPyrExp.h.

◆ StdQuadExpSharedPtr

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

Definition at line 181 of file StdQuadExp.h.

◆ StdSegExpSharedPtr

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

Definition at line 182 of file StdSegExp.h.

◆ StdTetExpSharedPtr

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

Definition at line 187 of file StdTetExp.h.

◆ StdTriExpSharedPtr

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

Definition at line 177 of file StdTriExp.h.

◆ VarCoeffMap

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

Definition at line 432 of file StdRegions.hpp.

◆ VarFactorsMap

typedef std::map<StdRegions::ConstFactorType, Array<OneD, NekDouble> > Nektar::StdRegions::VarFactorsMap

Definition at line 498 of file StdRegions.hpp.

◆ vec_t

typedef tinysimd::scalarT< double > Nektar::StdRegions::vec_t

Definition at line 47 of file StdExpansion1D.cpp.

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 
eFactorGJPTraceWeight 
eFactorConst 
SIZE_ConstFactorType 

Definition at line 448 of file StdRegions.hpp.

449{
450 eFactorLambda,
451 eFactorCoeffD00,
452 eFactorCoeffD11,
453 eFactorCoeffD22,
454 eFactorCoeffD01,
455 eFactorCoeffD02,
456 eFactorCoeffD12,
457 eFactorTau,
458 eFactorTime,
459 eFactorSVVCutoffRatio,
460 eFactorSVVDiffCoeff,
461 eFactorSVVPowerKerDiffCoeff,
462 eFactorSVVDGKerDiffCoeff,
463 eFactorGaussVertex,
464 eFactorGaussEdge,
465 eFactorGJP,
466 eFactorGJPTraceWeight,
467 eFactorConst,
468 SIZE_ConstFactorType
469};

◆ 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 47 of file StdRegions.hpp.

48{
49 // eStdPointExp,
50 eStdSegExp,
51 eSegExp,
52 eStdQuadExp,
53 eStdTriExp,
54 eStdNodalTriExp,
55 eQuadExp,
56 eTriExp,
57 eNodalTriExp,
58 eStdHexExp,
59 eStdPrismExp,
60 eStdPyrExp,
61 eStdTetExp,
62 eStdNodalTetExp,
63 eHexExp,
64 ePrismExp,
65 ePyrExp,
66 eTetExp,
67 eNodalTetExp,
68 SIZE_ElementType
69};

◆ 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 
eInvBwdTrans 
eBwdMat 
eIProductWRTBase 
eInvIProductWRTBase 
eIProductWRTDerivBase0 
eIProductWRTDerivBase1 
eIProductWRTDerivBase2 
eDerivBase0 
eDerivBase1 
eDerivBase2 
eHelmholtz 
eHelmholtzGJP 
eHybridDGHelmholtz 
eInvHybridDGHelmholtz 
eHybridDGHelmBndLam 
eHybridDGLamToQ0 
eHybridDGLamToQ1 
eHybridDGLamToQ2 
eHybridDGLamToU 
eFwdTrans 
ePreconR 
ePreconRMass 
ePreconLinearSpace 
ePreconLinearSpaceMass 
eInterpGauss 
eGaussDG 
ePhysInterpToEquiSpaced 
ePhysInterpToGLL 
eCoeffsToEquiSpaced 
eEquiSpacedToCoeffs 
eCoeffsToGLL 
eGLLToCoeffs 
eEquiSpacedToPhys 
eNormDerivOnTrace 
SIZE_MatrixType 

Definition at line 82 of file StdRegions.hpp.

83{
84 eNoMatrixType,
85 eMass,
86 eMassGJP,
87 eInvMass,
88 eLaplacian,
89 eLaplacian00,
90 eLaplacian01,
91 eLaplacian02,
92 eLaplacian10,
93 eLaplacian11,
94 eLaplacian12,
95 eLaplacian20,
96 eLaplacian21,
97 eLaplacian22,
98 eInvLaplacianWithUnityMean,
99 eWeakDeriv0,
100 eWeakDeriv1,
101 eWeakDeriv2,
102 eWeakDirectionalDeriv,
103 eMassLevelCurvature,
104 eLinearAdvection,
105 eLinearAdvectionReaction,
106 eLinearAdvectionDiffusionReaction,
107 eLinearAdvectionDiffusionReactionGJP,
108 eNBasisTrans,
109 eInvNBasisTrans,
110 eBwdTrans,
111 eInvBwdTrans,
112 eBwdMat,
113 eIProductWRTBase,
114 eInvIProductWRTBase,
115 eIProductWRTDerivBase0,
116 eIProductWRTDerivBase1,
117 eIProductWRTDerivBase2,
118 eDerivBase0,
119 eDerivBase1,
120 eDerivBase2,
121 eHelmholtz,
122 eHelmholtzGJP,
123 eHybridDGHelmholtz,
124 eInvHybridDGHelmholtz,
125 eHybridDGHelmBndLam,
126 eHybridDGLamToQ0,
127 eHybridDGLamToQ1,
128 eHybridDGLamToQ2,
129 eHybridDGLamToU,
130 eFwdTrans,
131 ePreconR,
132 ePreconRMass,
133 ePreconLinearSpace,
134 ePreconLinearSpaceMass,
135 eInterpGauss,
136 eGaussDG,
137 ePhysInterpToEquiSpaced,
138 ePhysInterpToGLL,
139 eCoeffsToEquiSpaced,
140 eEquiSpacedToCoeffs,
141 eCoeffsToGLL,
142 eGLLToCoeffs,
143 eEquiSpacedToPhys,
144 eNormDerivOnTrace,
145 SIZE_MatrixType
146};

◆ 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 501 of file StdRegions.hpp.

502{
503 eNoOrientation,
504 eFwd,
505 eBwd,
506 eForwards,
507 eBackwards,
508 eDir1FwdDir1_Dir2FwdDir2, // These flags are interpreted as
509 eDir1FwdDir1_Dir2BwdDir2, // taking the first direction to the
510 eDir1BwdDir1_Dir2FwdDir2, // second direction. So Dir1FwdDir2 takes
511 eDir1BwdDir1_Dir2BwdDir2, // direction 1 in the original face and makes it
512 eDir1FwdDir2_Dir2FwdDir1, // backwards to direction 2 in the mapped face.
513 eDir1FwdDir2_Dir2BwdDir1, // Note be careful not to flip this
514 eDir1BwdDir2_Dir2FwdDir1, // convention especially when using
515 eDir1BwdDir2_Dir2BwdDir1, // transposed mappings.
516 SIZE_Orientation
517};

◆ StdFacType

enum Nektar::StdRegions::StdFacType
Enumerator
eWeights1 
eWeights2 
eHalfMultOnePlusZ0 
eHalfMultOnePlusZ1 
eTwoOverOneMinusZ1 
eTwoOverOneMinusZ2 

Definition at line 58 of file StdExpansion.h.

59{
60 eWeights1,
61 eWeights2,
62 eHalfMultOnePlusZ0,
63 eHalfMultOnePlusZ1,
64 eTwoOverOneMinusZ1,
65 eTwoOverOneMinusZ2
66
67};

◆ 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 211 of file StdRegions.hpp.

212{
213 eVarCoeffMass,
214 eVarCoeffLaplacian,
215 eVarCoeffWeakDeriv,
216 eVarCoeffD00,
217 eVarCoeffD01,
218 eVarCoeffD02,
219 eVarCoeffD10,
220 eVarCoeffD11,
221 eVarCoeffD12,
222 eVarCoeffD20,
223 eVarCoeffD21,
224 eVarCoeffD22,
225 eVarCoeffVelX,
226 eVarCoeffVelY,
227 eVarCoeffVelZ,
228 eVarCoeffMF1x,
229 eVarCoeffMF1y,
230 eVarCoeffMF1z,
231 eVarCoeffMF1Div,
232 eVarCoeffMF1Mag,
233 eVarCoeffMF2x,
234 eVarCoeffMF2y,
235 eVarCoeffMF2z,
236 eVarCoeffMF2Div,
237 eVarCoeffMF2Mag,
238 eVarCoeffMF3x,
239 eVarCoeffMF3y,
240 eVarCoeffMF3z,
241 eVarCoeffMF3Div,
242 eVarCoeffMF3Mag,
243 eVarCoeffMF,
244 eVarCoeffMFDiv,
245 eVarCoeffGmat,
246 eVarCoeffGJPNormVel,
247 SIZE_VarCoeffType
248};

Function Documentation

◆ EvaluateQuadFaceBasisKey()

LibUtilities::BasisKey Nektar::StdRegions::EvaluateQuadFaceBasisKey ( const int  facedir,
const LibUtilities::BasisSharedPtr &  faceDirBasis 
)

Definition at line 701 of file StdExpansion3D.cpp.

704{
705 auto faceDirBasisType = faceDirBasis->GetBasisType();
706 auto pointsType = faceDirBasis->GetPointsType();
707 auto nummodes = faceDirBasis->GetNumModes();
708 auto numpoints = faceDirBasis->GetNumPoints();
709
710 switch (faceDirBasisType)
711 {
712 case LibUtilities::eModified_A:
713 case LibUtilities::eModified_B:
714 case LibUtilities::eModified_C:
715 {
716 LibUtilities::PointsType pType;
717 switch (pointsType)
718 {
719 case LibUtilities::eGaussRadauMLegendre:
720 case LibUtilities::eGaussRadauMAlpha2Beta0:
721 case LibUtilities::eGaussRadauMAlpha1Beta0:
722 {
723 numpoints = numpoints + 1;
724 pType = LibUtilities::eGaussLobattoLegendre;
725 }
726 break;
727 case LibUtilities::eGaussLegendreWithM:
728 {
729 numpoints = numpoints + 1;
730 pType = LibUtilities::eGaussLegendreWithMP;
731 }
732 break;
733 default: // do not change points
734 {
735 pType = faceDirBasis->GetPointsType();
736 }
737 }
738 const LibUtilities::PointsKey pkey(numpoints, pType);
739 return LibUtilities::BasisKey(LibUtilities::eModified_A, nummodes,
740 pkey);
741 }
742 case LibUtilities::eGLL_Lagrange:
743 {
744 const LibUtilities::PointsKey pkey(
745 numpoints, LibUtilities::eGaussLobattoLegendre);
746 return LibUtilities::BasisKey(LibUtilities::eGLL_Lagrange, nummodes,
747 pkey);
748 }
749 case LibUtilities::eOrtho_A:
750 case LibUtilities::eOrtho_B:
751 case LibUtilities::eOrtho_C:
752 {
753 LibUtilities::PointsType pType;
754 switch (pointsType)
755 {
756 case LibUtilities::eGaussRadauMLegendre:
757 case LibUtilities::eGaussRadauMAlpha2Beta0:
758 case LibUtilities::eGaussRadauMAlpha1Beta0:
759 {
760 numpoints = numpoints + 1;
761 pType = LibUtilities::eGaussLobattoLegendre;
762 }
763 break;
764 case LibUtilities::eGaussLegendreWithM:
765 {
766 numpoints = numpoints + 1;
767 pType = LibUtilities::eGaussLegendreWithMP;
768 }
769 break;
770 default: // do not change points
771 {
772 pType = faceDirBasis->GetPointsType();
773 break;
774 }
775 }
776 const LibUtilities::PointsKey pkey(numpoints, pType);
777 return LibUtilities::BasisKey(LibUtilities::eOrtho_A, nummodes,
778 pkey);
779 }
780 default:
781 {
782 NEKERROR(ErrorUtil::efatal, "expansion type unknown");
783 break;
784 }
785 }
786
787 // Keep things happy by returning a value.
788 return LibUtilities::NullBasisKey;
789}
NEKERROR
#define NEKERROR(type, msg)
Assert Level 0 – Fundamental assert which is used whether in FULLDEBUG, DEBUG or OPT compilation mode...
Definition ErrorUtil.hpp:210

References Nektar::ErrorUtil::efatal, Nektar::LibUtilities::eGaussLegendreWithM, Nektar::LibUtilities::eGaussLegendreWithMP, Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eGaussRadauMLegendre, 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, Nektar::LibUtilities::BasisKey::GetBasisType(), 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::BasisSharedPtr &  faceDirBasis,
bool  UseGLL 
)

Definition at line 791 of file StdExpansion3D.cpp.

794{
795 auto faceDirBasisType = faceDirBasis->GetBasisType();
796 auto pointsType = faceDirBasis->GetPointsType();
797 auto nummodes = faceDirBasis->GetNumModes();
798 auto numpoints = faceDirBasis->GetNumPoints();
799
800 switch (faceDirBasisType)
801 {
802 case LibUtilities::eModified_A:
803 case LibUtilities::eModified_B:
804 case LibUtilities::eModified_C:
805 case LibUtilities::eModifiedPyr_C:
806 {
807 LibUtilities::BasisType bType = LibUtilities::eNoBasisType;
808 LibUtilities::PointsKey pkey = LibUtilities::NullPointsKey;
809 switch (facedir) // determine the basis type
810 {
811 case 0:
812 {
813 bType = LibUtilities::eModified_A;
814
815 switch (pointsType) // determine the points type
816 {
817 case LibUtilities::eGaussRadauMLegendre:
818 // case LibUtilities::eGaussRadauMAlpha2Beta0: don't
819 // this this is posssible
820 case LibUtilities::eGaussRadauMAlpha1Beta0:
821 {
822 pkey = LibUtilities::PointsKey(
823 numpoints + 1,
824 LibUtilities::eGaussLobattoLegendre);
825 }
826 break;
827 case LibUtilities::eGaussLegendreWithM:
828 {
829 pkey = LibUtilities::PointsKey(
830 numpoints + 1,
831 LibUtilities::eGaussLegendreWithMP);
832 }
833 break;
834 default: // For other points type, just return the
835 // points key
836 {
837 pkey = faceDirBasis->GetPointsKey();
838 }
839 }
840 }
841 break;
842 case 1: // this never appears together with Modified_A
843 {
844 bType = LibUtilities::eModified_B;
845
846 switch (pointsType) // determine the points type
847 {
848 case LibUtilities::eGaussRadauMLegendre:
849 case LibUtilities::eGaussRadauMAlpha2Beta0:
850 case LibUtilities::eGaussRadauMAlpha1Beta0:
851 {
852 if (UseGLL) // force to use GLL
853 {
854 pkey = LibUtilities::PointsKey(
855 numpoints + 1,
856 LibUtilities::eGaussLobattoLegendre);
857 }
858 else
859 {
860 pkey = LibUtilities::PointsKey(
861 numpoints,
862 LibUtilities::eGaussRadauMAlpha1Beta0);
863 }
864 }
865 break;
866 default: // For other points type, just return the
867 // points key
868 {
869 pkey = faceDirBasis->GetPointsKey();
870 }
871 }
872 }
873 break;
874 default:
875 {
876 NEKERROR(ErrorUtil::efatal, "invalid value to flag");
877 break;
878 }
879 }
880 return LibUtilities::BasisKey(bType, nummodes, pkey);
881 }
882
883 case LibUtilities::eGLL_Lagrange:
884 {
885 switch (facedir)
886 {
887 case 0:
888 {
889 const LibUtilities::PointsKey pkey(
890 numpoints, LibUtilities::eGaussLobattoLegendre);
891 return LibUtilities::BasisKey(LibUtilities::eOrtho_A,
892 nummodes, pkey);
893 }
894 break;
895 case 1:
896 {
897 const LibUtilities::PointsKey pkey(
898 numpoints, LibUtilities::eGaussRadauMAlpha1Beta0);
899 return LibUtilities::BasisKey(LibUtilities::eOrtho_B,
900 nummodes, pkey);
901 }
902 break;
903 default:
904 {
905 NEKERROR(ErrorUtil::efatal, "invalid value to flag");
906 break;
907 }
908 }
909 break;
910 }
911
912 case LibUtilities::eOrtho_A:
913 case LibUtilities::eOrtho_B:
914 case LibUtilities::eOrtho_C:
915 case LibUtilities::eOrthoPyr_C:
916 {
917 LibUtilities::BasisType bType = LibUtilities::eNoBasisType;
918 LibUtilities::PointsKey pkey = LibUtilities::NullPointsKey;
919 switch (facedir) // determine the basis type
920 {
921 case 0:
922 {
923 bType = LibUtilities::eOrtho_A;
924
925 switch (pointsType) // determine the points type
926 {
927 case LibUtilities::eGaussRadauMLegendre:
928 case LibUtilities::eGaussRadauMAlpha2Beta0:
929 case LibUtilities::eGaussRadauMAlpha1Beta0:
930 {
931 pkey = LibUtilities::PointsKey(
932 numpoints + 1,
933 LibUtilities::eGaussLobattoLegendre);
934 }
935 break;
936 case LibUtilities::eGaussLegendreWithM:
937 {
938 pkey = LibUtilities::PointsKey(
939 numpoints + 1,
940 LibUtilities::eGaussLegendreWithMP);
941 }
942 break;
943 default: // For other points type, just return the
944 // points key
945 {
946 pkey = faceDirBasis->GetPointsKey();
947 }
948 }
949 }
950 break;
951 case 1: // this never appears together with Ortho_A
952 {
953 bType = LibUtilities::eOrtho_B;
954
955 switch (pointsType) // determine the points type
956 {
957 case LibUtilities::eGaussRadauMLegendre:
958 case LibUtilities::eGaussRadauMAlpha2Beta0:
959 {
960 pkey = LibUtilities::PointsKey(
961 numpoints,
962 LibUtilities::eGaussRadauMAlpha1Beta0);
963 }
964 break;
965 default: // For other points type, just return the
966 // points key
967 {
968 pkey = faceDirBasis->GetPointsKey();
969 }
970 }
971 }
972 break;
973 default:
974 {
975 NEKERROR(ErrorUtil::efatal, "invalid value to flag");
976 break;
977 }
978 }
979 return LibUtilities::BasisKey(bType, nummodes, pkey);
980 }
981 default:
982 {
983 NEKERROR(ErrorUtil::efatal, "expansion type unknown");
984 break;
985 }
986 }
987
988 // Keep things happy by returning a value.
989 return LibUtilities::NullBasisKey;
990}
Nektar::LibUtilities::PointsKey
Defines a specification for a set of points.
Definition Points.h:50

References Nektar::ErrorUtil::efatal, Nektar::LibUtilities::eGaussLegendreWithM, Nektar::LibUtilities::eGaussLegendreWithMP, Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eGaussRadauMLegendre, Nektar::LibUtilities::eGLL_Lagrange, Nektar::LibUtilities::eModified_A, Nektar::LibUtilities::eModified_B, Nektar::LibUtilities::eModified_C, Nektar::LibUtilities::eModifiedPyr_C, Nektar::LibUtilities::eNoBasisType, Nektar::LibUtilities::eOrtho_A, Nektar::LibUtilities::eOrtho_B, Nektar::LibUtilities::eOrtho_C, Nektar::LibUtilities::eOrthoPyr_C, Nektar::LibUtilities::BasisKey::GetBasisType(), NEKERROR, Nektar::LibUtilities::NullBasisKey(), and Nektar::LibUtilities::NullPointsKey().

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 539 of file StdRegions.hpp.

541{
542 InputIterator val;
543
544 if (startingpoint == first)
545 {
546 val = find(first, last, value);
547 }
548 else
549 {
550 val = find(startingpoint, last, value);
551 if (val == last)
552 {
553 val = find(first, startingpoint, value);
554 if (val == startingpoint)
555 {
556 val = last;
557 }
558 }
559 }
560 return val;
561}
Nektar::StdRegions::find
InputIterator find(InputIterator first, InputIterator last, InputIterator startingpoint, const EqualityComparable &value)
Definition StdRegions.hpp:539

References find().

Referenced by find().

◆ operator<()

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

Definition at line 110 of file StdMatrixKey.cpp.

111{
112 if (lhs.m_matrixType < rhs.m_matrixType)
113 {
114 return true;
115 }
116
117 if (lhs.m_matrixType > rhs.m_matrixType)
118 {
119 return false;
120 }
121
122 if (lhs.m_ncoeffs < rhs.m_ncoeffs) // probably do not need this check since
123 // checking the m_base below?
124 {
125 return true;
126 }
127
128 if (lhs.m_ncoeffs > rhs.m_ncoeffs)
129 {
130 return false;
131 }
132
133 if (LibUtilities::ShapeTypeDimMap[lhs.m_shapeType] <
134 LibUtilities::ShapeTypeDimMap[rhs.m_shapeType])
135 {
136 return true;
137 }
138
139 if (LibUtilities::ShapeTypeDimMap[lhs.m_shapeType] >
140 LibUtilities::ShapeTypeDimMap[rhs.m_shapeType])
141 {
142 return false;
143 }
144
145 for (unsigned int i = 0; i < LibUtilities::ShapeTypeDimMap[lhs.m_shapeType];
146 ++i)
147 {
148 if (lhs.m_base[i].get() < rhs.m_base[i].get())
149 {
150 return true;
151 }
152
153 if (lhs.m_base[i].get() > rhs.m_base[i].get())
154 {
155 return false;
156 }
157 }
158
159 if (lhs.m_factors.size() < rhs.m_factors.size())
160 {
161 return true;
162 }
163 else if (lhs.m_factors.size() > rhs.m_factors.size())
164 {
165 return false;
166 }
167 else
168 {
169 for (auto x = lhs.m_factors.begin(), y = rhs.m_factors.begin();
170 x != lhs.m_factors.end(); ++x, ++y)
171 {
172 if (x->second < y->second)
173 {
174 return true;
175 }
176 if (x->second > y->second)
177 {
178 return false;
179 }
180 }
181 }
182
183 if (lhs.m_varfactors.size() < rhs.m_varfactors.size())
184 {
185 return true;
186 }
187
188 if (lhs.m_varfactors.size() > rhs.m_varfactors.size())
189 {
190 return false;
191 }
192
193 for (unsigned int i = 0; i < lhs.m_varfactor_hashes.size(); ++i)
194 {
195 if (lhs.m_varfactor_hashes[i] < rhs.m_varfactor_hashes[i])
196 {
197 return true;
198 }
199 if (lhs.m_varfactor_hashes[i] > rhs.m_varfactor_hashes[i])
200 {
201 return false;
202 }
203 }
204
205 if (lhs.m_varcoeffs.size() < rhs.m_varcoeffs.size())
206 {
207 return true;
208 }
209
210 if (lhs.m_varcoeffs.size() > rhs.m_varcoeffs.size())
211 {
212 return false;
213 }
214
215 for (unsigned int i = 0; i < lhs.m_varcoeff_hashes.size(); ++i)
216 {
217 if (lhs.m_varcoeff_hashes[i] < rhs.m_varcoeff_hashes[i])
218 {
219 return true;
220 }
221 if (lhs.m_varcoeff_hashes[i] > rhs.m_varcoeff_hashes[i])
222 {
223 return false;
224 }
225 }
226
227 if (lhs.m_nodalPointsType < rhs.m_nodalPointsType)
228 {
229 return true;
230 }
231
232 if (lhs.m_nodalPointsType > rhs.m_nodalPointsType)
233 {
234 return false;
235 }
236
237 return false;
238}
Nektar::StdRegions::StdMatrixKey::m_nodalPointsType
LibUtilities::PointsType m_nodalPointsType
Definition StdMatrixKey.h:239
Nektar::StdRegions::StdMatrixKey::m_base
Array< OneD, const LibUtilities::BasisSharedPtr > m_base
Definition StdMatrixKey.h:235
Nektar::StdRegions::StdMatrixKey::m_varfactor_hashes
std::vector< std::size_t > m_varfactor_hashes
Definition StdMatrixKey.h:245
Nektar::StdRegions::StdMatrixKey::m_shapeType
LibUtilities::ShapeType m_shapeType
Definition StdMatrixKey.h:234
Nektar::StdRegions::StdMatrixKey::m_varcoeff_hashes
std::vector< std::size_t > m_varcoeff_hashes
Definition StdMatrixKey.h:246

◆ operator<<()

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

Definition at line 329 of file StdMatrixKey.cpp.

330{
331 os << "MatrixType: " << MatrixTypeMap[rhs.GetMatrixType()]
332 << ", ShapeType: " << LibUtilities::ShapeTypeMap[rhs.GetShapeType()]
333 << ", Ncoeffs: " << rhs.GetNcoeffs() << std::endl;
334
335 if (rhs.GetConstFactors().size())
336 {
337 os << "Constants: " << endl;
338 for (auto &x : rhs.GetConstFactors())
339 {
340 os << "\t value " << ConstFactorTypeMap[x.first] << " : "
341 << x.second << endl;
342 }
343 }
344 if (rhs.GetVarCoeffs().size())
345 {
346 os << "Variable coefficients: " << endl;
347 unsigned int i = 0;
348 for (auto &x : rhs.GetVarCoeffs())
349 {
350 os << "\t Coeff defined: " << VarCoeffTypeMap[x.first] << endl;
351 os << "\t Hash: " << rhs.GetVarCoeffHashes()[i++] << endl;
352 }
353 }
354
355 for (unsigned int i = 0;
356 i < LibUtilities::ShapeTypeDimMap[rhs.GetShapeType()]; ++i)
357 {
358 os << rhs.GetBase()[i]->GetBasisKey();
359 }
360
361 return os;
362}
Nektar::StdRegions::StdMatrixKey::GetBase
const Array< OneD, const LibUtilities::BasisSharedPtr > & GetBase() const
Definition StdMatrixKey.h:104
Nektar::StdRegions::StdMatrixKey::GetShapeType
LibUtilities::ShapeType GetShapeType() const
Definition StdMatrixKey.h:89
Nektar::StdRegions::StdMatrixKey::GetVarCoeffs
const VarCoeffMap & GetVarCoeffs() const
Definition StdMatrixKey.h:170
Nektar::StdRegions::StdMatrixKey::GetMatrixType
MatrixType GetMatrixType() const
Definition StdMatrixKey.h:84
Nektar::StdRegions::StdMatrixKey::GetConstFactors
const ConstFactorMap & GetConstFactors() const
Definition StdMatrixKey.h:139
Nektar::StdRegions::StdMatrixKey::GetVarCoeffHashes
std::vector< std::size_t > GetVarCoeffHashes() const
Definition StdMatrixKey.h:110
Nektar::StdRegions::ConstFactorTypeMap
const char *const ConstFactorTypeMap[]
Definition StdRegions.hpp:471
Nektar::StdRegions::MatrixTypeMap
const char *const MatrixTypeMap[]
Definition StdRegions.hpp:148

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 240 of file StdMatrixKey.cpp.

241{
242 if (lhs.m_matrixType != rhs.m_matrixType)
243 {
244 return false;
245 }
246
247 if (lhs.m_ncoeffs != rhs.m_ncoeffs)
248 {
249 return false;
250 }
251
252 for (unsigned int i = 0; i < LibUtilities::ShapeTypeDimMap[lhs.m_shapeType];
253 ++i)
254 {
255 if (lhs.m_base[i].get() != rhs.m_base[i].get())
256 {
257 return false;
258 }
259 }
260
261 if (lhs.m_factors.size() != rhs.m_factors.size())
262 {
263 return false;
264 }
265
266 if (!std::equal(lhs.m_factors.begin(), lhs.m_factors.end(),
267 rhs.m_factors.begin()))
268 {
269 return false;
270 }
271
272 if (lhs.m_nodalPointsType != rhs.m_nodalPointsType)
273 {
274 return false;
275 }
276
277 if (lhs.m_varcoeffs.size() != rhs.m_varcoeffs.size())
278 {
279 return false;
280 }
281
282 if (lhs.m_varfactors.size() != rhs.m_varfactors.size())
283 {
284 return false;
285 }
286
287 for (unsigned int i = 0; i < lhs.m_varfactor_hashes.size(); ++i)
288 {
289 if (lhs.m_varfactor_hashes[i] != rhs.m_varfactor_hashes[i])
290 {
291 return false;
292 }
293 }
294
295 for (unsigned int i = 0; i < lhs.m_varcoeff_hashes.size(); ++i)
296 {
297 if (lhs.m_varcoeff_hashes[i] != rhs.m_varcoeff_hashes[i])
298 {
299 return false;
300 }
301 }
302
303 for (auto &x : lhs.m_varcoeffs)
304 {
305 auto y = rhs.m_varcoeffs.find(x.first);
306 // Check var coeff is found
307 if (y == rhs.m_varcoeffs.end())
308 {
309 return false;
310 }
311
312 if (x.second.GetValue() != y->second.GetValue())
313 {
314 return false;
315 }
316 }
317
318 for (unsigned int i = 0; i < lhs.m_varcoeffs.size(); ++i)
319 {
320 if (lhs.m_varcoeff_hashes[i] != rhs.m_varcoeff_hashes[i])
321 {
322 return false;
323 }
324 }
325
326 return true;
327}

◆ RestrictCoeffMap()

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

Definition at line 435 of file StdRegions.hpp.

437{
438 VarCoeffMap ret;
439
440 for (auto &x : m)
441 {
442 ret[x.first] = x.second.restrict(offset, cnt);
443 }
444
445 return ret;
446}
Nektar::StdRegions::VarCoeffMap
std::map< StdRegions::VarCoeffType, VarCoeffEntry > VarCoeffMap
Definition StdRegions.hpp:432

Referenced by Nektar::MultiRegions::GlobalLinSys::GetBlockMatrixKey(), Nektar::Collections::Helmholtz_NoCollection::operator()(), and Nektar::Collections::LinearAdvectionDiffusionReaction_NoCollection::operator()().

Variable Documentation

◆ advectionVarCoeffs

constexpr std::array<VarCoeffType, 3> Nektar::StdRegions::advectionVarCoeffs
constexpr
Initial value:
{
eVarCoeffVelX, eVarCoeffVelY, eVarCoeffVelZ}

Definition at line 293 of file StdRegions.hpp.

293 {
294 eVarCoeffVelX, eVarCoeffVelY, eVarCoeffVelZ};

◆ 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",
"FactorGJPTraceWeight",
"FactorConstant"}

Definition at line 471 of file StdRegions.hpp.

471 {"FactorLambda",
472 "FactorCoeffD00",
473 "FactorCoeffD11",
474 "FactorCoeffD22",
475 "FactorCoeffD01",
476 "FactorCoeffD02",
477 "FactorCoeffD12",
478 "FactorTau",
479 "FactorTime",
480 "FactorSVVCutoffRatio",
481 "FactorSVVDiffCoeff",
482 "FactorSVVPowerKerDiffCoeff",
483 "FactorSVVDGKerDiffCoeff",
484 "FactorGaussVertex",
485 "FactorGaussEdge",
486 "FactorGJP",
487 "FactorGJPTraceWeight",
488 "FactorConstant"};

Referenced by export_StdMatrixKey(), Nektar::StdRegions::StdMatrixKey::GetConstFactor(), Nektar::StdRegions::StdMatrixKey::GetVarFactors(), Nektar::MultiRegions::operator<<(), 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 71 of file StdRegions.hpp.

71 {
72 //"StdPointExp",
73 "StdSegExp", "SegExp", "StdQuadExp", "StdTriExp", "StdNodalTriExp",
74 "QuadExp", "TriExp", "NodalTriExp", "StdHexExp", "StdPrismExp",
75 "StdPyrExp", "StdTetExp", "StdNodalTetExp", "HexExp", "PrismExp",
76 "PyrExp", "TetExp", "NodalTetExp",
77};

◆ 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 567 of file StdRegions.hpp.

567 {
568 {0, 0.36212, 1, 0, 0, 0, 0, 0, 0, 0, 0},
569 {0, 0.70546, 0.078836, 1, 0, 0, 0, 0, 0, 0, 0},
570 {0, 0, 0.49411, 0.072394, 1, 0, 0, 0, 0, 0, 0},
571 {0, 0, 0.000073566, 0.40506, 0.094122, 1, 0, 0, 0, 0, 0},
572 {0, 0, 0, 0.0001422, 0.36863, 0.11815, 1, 0, 0, 0, 0},
573 {0, 0, 0, 0, 0.00019497, 0.41397, 0.16927, 1, 0, 0, 0},
574 {0, 0, 0, 0, 0, 0.0009762, 0.12747, 0.13763, 1, 0, 0},
575 {0, 0, 0, 0, 0, 0, 0.0023592, 0.23683, 0.17196, 1, 0},
576 {0, 0, 0, 0, 0, 0, 0, 0.0026055, 0.28682, 0.22473, 1}};

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 565 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 564 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().

◆ laplacianVarCoeffs

constexpr std::array<VarCoeffType, 10> Nektar::StdRegions::laplacianVarCoeffs
constexpr
Initial value:
{
eVarCoeffLaplacian, eVarCoeffD00, eVarCoeffD01, eVarCoeffD02, eVarCoeffD10,
eVarCoeffD11, eVarCoeffD12, eVarCoeffD20, eVarCoeffD21, eVarCoeffD22}

Definition at line 288 of file StdRegions.hpp.

288 {
289 eVarCoeffLaplacian, eVarCoeffD00, eVarCoeffD01, eVarCoeffD02, eVarCoeffD10,
290 eVarCoeffD11, eVarCoeffD12, eVarCoeffD20, eVarCoeffD21, eVarCoeffD22};

◆ massVarCoeffs

constexpr std::array<VarCoeffType, 1> Nektar::StdRegions::massVarCoeffs {eVarCoeffMass}
constexpr

Definition at line 284 of file StdRegions.hpp.

284{eVarCoeffMass};

◆ MatrixTypeMap

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

Definition at line 148 of file StdRegions.hpp.

148 {
149 "NoMatrixType",
150 "Mass",
151 "Mass with Diagonal GJP",
152 "InvMass",
153 "Laplacian",
154 "Laplacian00",
155 "Laplacian01",
156 "Laplacian02",
157 "Laplacian10",
158 "Laplacian11",
159 "Laplacian12",
160 "Laplacian20",
161 "Laplacian21",
162 "Laplacian22",
163 "InvLaplacianWithUnityMean",
164 "WeakDeriv0",
165 "WeakDeriv1",
166 "WeakDeriv2",
167 "WeakDirectionalDeriv",
168 "MassLevelCurvature",
169 "LinearAdvection",
170 "LinearAdvectionReaction",
171 "LinearAdvectionDiffusionReaction",
172 "LinearAdvectionDiffusionReaction with Diagonal GJP",
173 "NBasisTrans",
174 "InvNBasisTrans",
175 "BwdTrans",
176 "InvBwdTrans",
177 "BwdMat",
178 "IProductWRTBase",
179 "InvIProductWRTBase",
180 "IProductWRTDerivBase0",
181 "IProductWRTDerivBase1",
182 "IProductWRTDerivBase2",
183 "DerivBase0",
184 "DerivBase1",
185 "DerivBase2",
186 "Helmholtz",
187 "Helmholtz with Diagonal GJP",
188 "HybridDGHelmholz",
189 "InvHybridDGHelmholtz",
190 "HybridDGHelmBndLam",
191 "HybridDGLamToQ0",
192 "HybridDGLamToQ1",
193 "HybridDGLamToQ2",
194 "HybridDGLamToU",
195 "FwdTrans",
196 "PreconR",
197 "PreconRMass",
198 "PreconLinearSpace",
199 "PreconLinearSpaceMass",
200 "InterpGauss",
201 "GaussDG",
202 "PhysInterpToEquiSpaced",
203 "PhysInterpToGLL",
204 "CoeffsToEquiSpaced",
205 "EquiSpacedToCoeffs",
206 "CoeffsToGLL",
207 "GLLToCoeffs",
208 "EquiSpacedToPhys",
209 "NormDerivOnTrace"};

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

◆ MatrixTypeToVarCoeffsMap

constexpr std::array<std::pair<MatrixType, VarCoeffList>, 3> Nektar::StdRegions::MatrixTypeToVarCoeffsMap
constexpr
Initial value:
{
std::pair{eMass,
VarCoeffList{massVarCoeffs.data(), massVarCoeffs.size()}},
std::pair{eLaplacian, VarCoeffList{laplacianVarCoeffs.data(),
laplacianVarCoeffs.size()}},
std::pair{eLinearAdvection, VarCoeffList{advectionVarCoeffs.data(),
advectionVarCoeffs.size()}}}
Nektar::StdRegions::massVarCoeffs
constexpr std::array< VarCoeffType, 1 > massVarCoeffs
Definition StdRegions.hpp:284
Nektar::StdRegions::advectionVarCoeffs
constexpr std::array< VarCoeffType, 3 > advectionVarCoeffs
Definition StdRegions.hpp:293

Definition at line 297 of file StdRegions.hpp.

297 {
298 std::pair{eMass,
299 VarCoeffList{massVarCoeffs.data(), massVarCoeffs.size()}},
300 std::pair{eLaplacian, VarCoeffList{laplacianVarCoeffs.data(),
301 laplacianVarCoeffs.size()}},
302 std::pair{eLinearAdvection, VarCoeffList{advectionVarCoeffs.data(),
303 advectionVarCoeffs.size()}}};

Referenced by Nektar::StdRegions::StdMatrixKey::HasVarCoeffForMatrixType().

◆ NullConstFactorMap

ConstFactorMap Nektar::StdRegions::NullConstFactorMap
static

Definition at line 490 of file StdRegions.hpp.

Referenced by Nektar::LocalRegions::Expansion2D::AddHDGHelmholtzEdgeTerms(), Nektar::LocalRegions::Expansion3D::AddHDGHelmholtzFaceTerms(), Nektar::StdRegions::StdExpansion::CreateGeneralMatrix(), Nektar::LocalRegions::Expansion2D::CreateMatrix(), export_ExpList(), export_MatrixKey(), export_StdMatrixKey(), Nektar::StdRegions::StdNodalPrismExp::ModalToNodal(), Nektar::StdRegions::StdNodalTetExp::ModalToNodal(), Nektar::StdRegions::StdNodalTriExp::ModalToNodal(), Nektar::StdRegions::StdNodalPrismExp::NodalToModal(), Nektar::StdRegions::StdNodalTetExp::NodalToModal(), Nektar::StdRegions::StdNodalPrismExp::NodalToModalTranspose(), Nektar::StdRegions::StdNodalTetExp::NodalToModalTranspose(), Nektar::StdRegions::StdNodalTriExp::NodalToModalTranspose(), Nektar::LocalRegions::Expansion2D::v_AddRobinMassMatrix(), Nektar::LocalRegions::Expansion3D::v_AddRobinMassMatrix(), Nektar::LocalRegions::Expansion2D::v_AddRobinTraceContribution(), Nektar::StdRegions::StdExpansion::v_FwdTrans(), Nektar::LocalRegions::Expansion::v_FwdTrans(), Nektar::LocalRegions::Expansion2D::v_GenMatrix(), Nektar::LocalRegions::Expansion3D::v_GenMatrix(), and Nektar::StdRegions::StdNodalTriExp::v_NodalToModal().

◆ NullFactorMap

FactorMap Nektar::StdRegions::NullFactorMap
static

Definition at line 494 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 433 of file StdRegions.hpp.

Referenced by Nektar::StdRegions::StdExpansion::CreateGeneralMatrix(), Nektar::LocalRegions::Expansion2D::CreateMatrix(), Nektar::LocalRegions::Expansion3D::CreateMatrix(), Nektar::LocalRegions::SegExp::CreateMatrix(), export_ExpList(), export_MatrixKey(), export_StdMatrixKey(), 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(), Nektar::StdRegions::StdNodalPrismExp::ModalToNodal(), Nektar::StdRegions::StdNodalTetExp::ModalToNodal(), Nektar::StdRegions::StdNodalTriExp::ModalToNodal(), Nektar::StdRegions::StdNodalPrismExp::NodalToModal(), Nektar::StdRegions::StdNodalTetExp::NodalToModal(), Nektar::StdRegions::StdNodalPrismExp::NodalToModalTranspose(), Nektar::StdRegions::StdNodalTetExp::NodalToModalTranspose(), Nektar::StdRegions::StdNodalTriExp::NodalToModalTranspose(), Nektar::Collections::Helmholtz_NoCollection::operator()(), Nektar::Collections::LinearAdvectionDiffusionReaction_NoCollection::operator()(), Nektar::StdRegions::StdExpansion::v_FwdTrans(), Nektar::LocalRegions::Expansion::v_FwdTrans(), Nektar::StdRegions::StdNodalTriExp::v_NodalToModal(), Nektar::VCSImplicit::v_SolvePressure(), Nektar::VCSWeakPressure::v_SolvePressure(), and Nektar::VelocityCorrectionScheme::v_SolveViscous().

◆ NullVarFactorsMap

VarFactorsMap Nektar::StdRegions::NullVarFactorsMap
static

Definition at line 499 of file StdRegions.hpp.

Referenced by Nektar::StdRegions::StdExpansion::CreateGeneralMatrix(), Nektar::StdRegions::StdNodalPrismExp::ModalToNodal(), Nektar::StdRegions::StdNodalTetExp::ModalToNodal(), Nektar::StdRegions::StdNodalTriExp::ModalToNodal(), Nektar::StdRegions::StdNodalPrismExp::NodalToModal(), Nektar::StdRegions::StdNodalTetExp::NodalToModal(), Nektar::StdRegions::StdNodalPrismExp::NodalToModalTranspose(), Nektar::StdRegions::StdNodalTetExp::NodalToModalTranspose(), Nektar::StdRegions::StdNodalTriExp::NodalToModalTranspose(), Nektar::SolverUtils::CouplingCwipi::ReceiveCwipi(), Nektar::StdRegions::StdExpansion::v_FwdTrans(), Nektar::LocalRegions::Expansion::v_FwdTrans(), Nektar::StdRegions::StdNodalTriExp::v_NodalToModal(), Nektar::VCSImplicit::v_SolvePressure(), Nektar::VCSWeakPressure::v_SolvePressure(), Nektar::VelocityCorrectionScheme::v_SolveViscous(), and Nektar::VCSImplicit::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 519 of file StdRegions.hpp.

519 {"NoOrientation",
520 "Fwd",
521 "Bwd",
522 "Forwards",
523 "Backwards",
524 "Dir1FwdDir1_Dir2FwdDir2",
525 "Dir1FwdDir1_Dir2BwdDir2",
526 "Dir1BwdDir1_Dir2FwdDir2",
527 "Dir1BwdDir1_Dir2BwdDir2",
528 "Dir1FwdDir2_Dir2FwdDir1",
529 "Dir1FwdDir2_Dir2BwdDir1",
530 "Dir1BwdDir2_Dir2FwdDir1",
531 "Dir1BwdDir2_Dir2BwdDir1"};

◆ 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", "VarCoeffTraceWeight"}

Definition at line 250 of file StdRegions.hpp.

250 {
251 "VarCoeffMass", "VarCoeffLaplacian", "VarCoeffWeakDeriv",
252 "VarCoeffD00", "VarCoeffD01", "VarCoeffD02",
253 "VarCoeffD10", "VarCoeffD11", "VarCoeffD12",
254 "VarCoeffD20", "VarCoeffD21", "VarCoeffD22",
255 "VarCoeffVelX", "VarCoeffVelY", "VarCoeffVelZ",
256 "VarCoeffMF1x", "VarCoeffMF1y", "VarCoeffMF1z",
257 "VarCoeffMF1Div", "VarCoeffMF1Mag", "VarCoeffMF2x",
258 "VarCoeffMF2y", "VarCoeffMF2z", "VarCoeffMF2Div",
259 "VarCoeffMF2Mag", "VarCoeffMF3x", "VarCoeffMF3y",
260 "VarCoeffMF3z", "VarCoeffMF3Div", "VarCoeffMF3Mag",
261 "VarCoeffMF", "VarCoeffMFDiv", "VarCoeffGmat",
262 "VarCoeffGJPNormVel", "VarCoeffTraceWeight"};

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

Generated on Sat Jul 4 2026 01:02:32 for Nektar++ by doxygen 1.9.8