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
 
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::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 []
 
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 105 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 1783 of file StdExpansion.h.

◆ StdExpansionVector

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

Definition at line 1784 of file StdExpansion.h.

◆ StdHexExpSharedPtr

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

Definition at line 225 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 215 of file StdPrismExp.h.

◆ StdPyrExpSharedPtr

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

Definition at line 211 of file StdPyrExp.h.

◆ StdQuadExpSharedPtr

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

Definition at line 218 of file StdQuadExp.h.

◆ StdSegExpSharedPtr

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

Definition at line 214 of file StdSegExp.h.

◆ StdTetExpSharedPtr

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

Definition at line 224 of file StdTetExp.h.

◆ StdTriExpSharedPtr

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

Definition at line 215 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.

392{
393 eFactorLambda,
394 eFactorCoeffD00,
395 eFactorCoeffD11,
396 eFactorCoeffD22,
397 eFactorCoeffD01,
398 eFactorCoeffD02,
399 eFactorCoeffD12,
400 eFactorTau,
401 eFactorTime,
402 eFactorSVVCutoffRatio,
403 eFactorSVVDiffCoeff,
404 eFactorSVVPowerKerDiffCoeff,
405 eFactorSVVDGKerDiffCoeff,
406 eFactorGaussVertex,
407 eFactorGaussEdge,
408 eFactorGJP,
409 eFactorConst,
410 SIZE_ConstFactorType
411};

◆ 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.

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

◆ 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.

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

◆ 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.

438{
439 eNoOrientation,
440 eFwd,
441 eBwd,
442 eForwards,
443 eBackwards,
444 eDir1FwdDir1_Dir2FwdDir2, // These flags are interpreted as
445 eDir1FwdDir1_Dir2BwdDir2, // taking the second direction to the
446 eDir1BwdDir1_Dir2FwdDir2, // first direction. So Dir1FwdDir2 takes
447 eDir1BwdDir1_Dir2BwdDir2, // direction 2 and makes it backward
448 eDir1FwdDir2_Dir2FwdDir1, // to direction 1 in the mapped face.
449 eDir1FwdDir2_Dir2BwdDir1, // Note be careful not to flip this
450 eDir1BwdDir2_Dir2FwdDir1, // convention especially when using
451 eDir1BwdDir2_Dir2BwdDir1, // transposed mappings.
452 SIZE_Orientation
453};

◆ 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.

196{
197 eVarCoeffMass,
198 eVarCoeffLaplacian,
199 eVarCoeffWeakDeriv,
200 eVarCoeffD00,
201 eVarCoeffD01,
202 eVarCoeffD02,
203 eVarCoeffD10,
204 eVarCoeffD11,
205 eVarCoeffD12,
206 eVarCoeffD20,
207 eVarCoeffD21,
208 eVarCoeffD22,
209 eVarCoeffVelX,
210 eVarCoeffVelY,
211 eVarCoeffVelZ,
212 eVarCoeffMF1x,
213 eVarCoeffMF1y,
214 eVarCoeffMF1z,
215 eVarCoeffMF1Div,
216 eVarCoeffMF1Mag,
217 eVarCoeffMF2x,
218 eVarCoeffMF2y,
219 eVarCoeffMF2z,
220 eVarCoeffMF2Div,
221 eVarCoeffMF2Mag,
222 eVarCoeffMF3x,
223 eVarCoeffMF3y,
224 eVarCoeffMF3z,
225 eVarCoeffMF3Div,
226 eVarCoeffMF3Mag,
227 eVarCoeffMF,
228 eVarCoeffMFDiv,
229 eVarCoeffGmat,
230 eVarCoeffGJPNormVel,
231 SIZE_VarCoeffType
232};

Function Documentation

◆ EvaluateQuadFaceBasisKey()

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

Definition at line 431 of file StdExpansion3D.cpp.

434{
435 auto faceDirBasisType = faceDirBasis->GetBasisType();
436 auto pointsType = faceDirBasis->GetPointsType();
437 auto nummodes = faceDirBasis->GetNumModes();
438 auto numpoints = faceDirBasis->GetNumPoints();
439
440 switch (faceDirBasisType)
441 {
442 case LibUtilities::eModified_A:
443 case LibUtilities::eModified_B:
444 case LibUtilities::eModified_C:
445 {
446 LibUtilities::PointsType pType;
447 switch (pointsType)
448 {
449 case LibUtilities::eGaussRadauMLegendre:
450 case LibUtilities::eGaussRadauMAlpha2Beta0:
451 case LibUtilities::eGaussRadauMAlpha1Beta0:
452 {
453 numpoints = numpoints + 1;
454 pType = LibUtilities::eGaussLobattoLegendre;
455 }
456 break;
457 case LibUtilities::eGaussLegendreWithM:
458 {
459 numpoints = numpoints + 1;
460 pType = LibUtilities::eGaussLegendreWithMP;
461 }
462 break;
463 default: // do not change points
464 {
465 pType = faceDirBasis->GetPointsType();
466 }
467 }
468 const LibUtilities::PointsKey pkey(numpoints, pType);
469 return LibUtilities::BasisKey(LibUtilities::eModified_A, nummodes,
470 pkey);
471 }
472 case LibUtilities::eGLL_Lagrange:
473 {
474 const LibUtilities::PointsKey pkey(
475 numpoints, LibUtilities::eGaussLobattoLegendre);
476 return LibUtilities::BasisKey(LibUtilities::eGLL_Lagrange, nummodes,
477 pkey);
478 }
479 case LibUtilities::eOrtho_A:
480 case LibUtilities::eOrtho_B:
481 case LibUtilities::eOrtho_C:
482 {
483 LibUtilities::PointsType pType;
484 switch (pointsType)
485 {
486 case LibUtilities::eGaussRadauMLegendre:
487 case LibUtilities::eGaussRadauMAlpha2Beta0:
488 case LibUtilities::eGaussRadauMAlpha1Beta0:
489 {
490 numpoints = numpoints + 1;
491 pType = LibUtilities::eGaussLobattoLegendre;
492 }
493 break;
494 case LibUtilities::eGaussLegendreWithM:
495 {
496 numpoints = numpoints + 1;
497 pType = LibUtilities::eGaussLegendreWithMP;
498 }
499 break;
500 default: // do not change points
501 {
502 pType = faceDirBasis->GetPointsType();
503 break;
504 }
505 }
506 const LibUtilities::PointsKey pkey(numpoints, pType);
507 return LibUtilities::BasisKey(LibUtilities::eOrtho_A, nummodes,
508 pkey);
509 }
510 default:
511 {
512 NEKERROR(ErrorUtil::efatal, "expansion type unknown");
513 break;
514 }
515 }
516
517 // Keep things happy by returning a value.
518 return LibUtilities::NullBasisKey;
519}
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 521 of file StdExpansion3D.cpp.

524{
525 auto faceDirBasisType = faceDirBasis->GetBasisType();
526 auto pointsType = faceDirBasis->GetPointsType();
527 auto nummodes = faceDirBasis->GetNumModes();
528 auto numpoints = faceDirBasis->GetNumPoints();
529
530 switch (faceDirBasisType)
531 {
532 case LibUtilities::eModified_A:
533 case LibUtilities::eModified_B:
534 case LibUtilities::eModified_C:
535 case LibUtilities::eModifiedPyr_C:
536 {
537 LibUtilities::BasisType bType = LibUtilities::eNoBasisType;
538 LibUtilities::PointsKey pkey = LibUtilities::NullPointsKey;
539 switch (facedir) // determine the basis type
540 {
541 case 0:
542 {
543 bType = LibUtilities::eModified_A;
544
545 switch (pointsType) // determine the points type
546 {
547 case LibUtilities::eGaussRadauMLegendre:
548 case LibUtilities::eGaussRadauMAlpha2Beta0:
549 case LibUtilities::eGaussRadauMAlpha1Beta0:
550 {
551 pkey = LibUtilities::PointsKey(
552 numpoints + 1,
553 LibUtilities::eGaussLobattoLegendre);
554 }
555 break;
556 case LibUtilities::eGaussLegendreWithM:
557 {
558 pkey = LibUtilities::PointsKey(
559 numpoints + 1,
560 LibUtilities::eGaussLegendreWithMP);
561 }
562 break;
563 default: // For other points type, just return the
564 // points key
565 {
566 pkey = faceDirBasis->GetPointsKey();
567 }
568 }
569 }
570 break;
571 case 1: // this never appears together with Modified_A
572 {
573 bType = LibUtilities::eModified_B;
574
575 switch (pointsType) // determine the points type
576 {
577 case LibUtilities::eGaussRadauMLegendre:
578 case LibUtilities::eGaussRadauMAlpha2Beta0:
579 case LibUtilities::eGaussRadauMAlpha1Beta0:
580 {
581 if (UseGLL) // force to use GLL
582 {
583 pkey = LibUtilities::PointsKey(
584 numpoints + 1,
585 LibUtilities::eGaussLobattoLegendre);
586 }
587 else
588 {
589 pkey = LibUtilities::PointsKey(
590 numpoints,
591 LibUtilities::eGaussRadauMAlpha1Beta0);
592 }
593 }
594 break;
595 default: // For other points type, just return the
596 // points key
597 {
598 pkey = faceDirBasis->GetPointsKey();
599 }
600 }
601 }
602 break;
603 default:
604 {
605 NEKERROR(ErrorUtil::efatal, "invalid value to flag");
606 break;
607 }
608 }
609 return LibUtilities::BasisKey(bType, nummodes, pkey);
610 }
611
612 case LibUtilities::eGLL_Lagrange:
613 {
614 switch (facedir)
615 {
616 case 0:
617 {
618 const LibUtilities::PointsKey pkey(
619 numpoints, LibUtilities::eGaussLobattoLegendre);
620 return LibUtilities::BasisKey(LibUtilities::eOrtho_A,
621 nummodes, pkey);
622 }
623 break;
624 case 1:
625 {
626 const LibUtilities::PointsKey pkey(
627 numpoints, LibUtilities::eGaussRadauMAlpha1Beta0);
628 return LibUtilities::BasisKey(LibUtilities::eOrtho_B,
629 nummodes, pkey);
630 }
631 break;
632 default:
633 {
634 NEKERROR(ErrorUtil::efatal, "invalid value to flag");
635 break;
636 }
637 }
638 break;
639 }
640
641 case LibUtilities::eOrtho_A:
642 case LibUtilities::eOrtho_B:
643 case LibUtilities::eOrtho_C:
644 case LibUtilities::eOrthoPyr_C:
645 {
646 LibUtilities::BasisType bType = LibUtilities::eNoBasisType;
647 LibUtilities::PointsKey pkey = LibUtilities::NullPointsKey;
648 switch (facedir) // determine the basis type
649 {
650 case 0:
651 {
652 bType = LibUtilities::eOrtho_A;
653
654 switch (pointsType) // determine the points type
655 {
656 case LibUtilities::eGaussRadauMLegendre:
657 case LibUtilities::eGaussRadauMAlpha2Beta0:
658 case LibUtilities::eGaussRadauMAlpha1Beta0:
659 {
660 pkey = LibUtilities::PointsKey(
661 numpoints + 1,
662 LibUtilities::eGaussLobattoLegendre);
663 }
664 break;
665 case LibUtilities::eGaussLegendreWithM:
666 {
667 pkey = LibUtilities::PointsKey(
668 numpoints + 1,
669 LibUtilities::eGaussLegendreWithMP);
670 }
671 break;
672 default: // For other points type, just return the
673 // points key
674 {
675 pkey = faceDirBasis->GetPointsKey();
676 }
677 }
678 }
679 break;
680 case 1: // this never appears together with Ortho_A
681 {
682 bType = LibUtilities::eOrtho_B;
683
684 switch (pointsType) // determine the points type
685 {
686 case LibUtilities::eGaussRadauMLegendre:
687 case LibUtilities::eGaussRadauMAlpha2Beta0:
688 {
689 pkey = LibUtilities::PointsKey(
690 numpoints,
691 LibUtilities::eGaussRadauMAlpha1Beta0);
692 }
693 break;
694 default: // For other points type, just return the
695 // points key
696 {
697 pkey = faceDirBasis->GetPointsKey();
698 }
699 }
700 }
701 break;
702 default:
703 {
704 NEKERROR(ErrorUtil::efatal, "invalid value to flag");
705 break;
706 }
707 }
708 return LibUtilities::BasisKey(bType, nummodes, pkey);
709 }
710 default:
711 {
712 NEKERROR(ErrorUtil::efatal, "expansion type unknown");
713 break;
714 }
715 }
716
717 // Keep things happy by returning a value.
718 return LibUtilities::NullBasisKey;
719}
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 475 of file StdRegions.hpp.

477{
478 InputIterator val;
479
480 if (startingpoint == first)
481 {
482 val = find(first, last, value);
483 }
484 else
485 {
486 val = find(startingpoint, last, value);
487 if (val == last)
488 {
489 val = find(first, startingpoint, value);
490 if (val == startingpoint)
491 {
492 val = last;
493 }
494 }
495 }
496 return val;
497}
Nektar::StdRegions::find
InputIterator find(InputIterator first, InputIterator last, InputIterator startingpoint, const EqualityComparable &value)
Definition StdRegions.hpp:475

References find().

Referenced by find().

◆ operator<()

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

Definition at line 94 of file StdMatrixKey.cpp.

95{
96 if (lhs.m_matrixType < rhs.m_matrixType)
97 {
98 return true;
99 }
100
101 if (lhs.m_matrixType > rhs.m_matrixType)
102 {
103 return false;
104 }
105
106 if (lhs.m_ncoeffs < rhs.m_ncoeffs) // probably do not need this check since
107 // checking the m_base below?
108 {
109 return true;
110 }
111
112 if (lhs.m_ncoeffs > rhs.m_ncoeffs)
113 {
114 return false;
115 }
116
117 if (LibUtilities::ShapeTypeDimMap[lhs.m_shapeType] <
118 LibUtilities::ShapeTypeDimMap[rhs.m_shapeType])
119 {
120 return true;
121 }
122
123 if (LibUtilities::ShapeTypeDimMap[lhs.m_shapeType] >
124 LibUtilities::ShapeTypeDimMap[rhs.m_shapeType])
125 {
126 return false;
127 }
128
129 for (unsigned int i = 0; i < LibUtilities::ShapeTypeDimMap[lhs.m_shapeType];
130 ++i)
131 {
132 if (lhs.m_base[i].get() < rhs.m_base[i].get())
133 {
134 return true;
135 }
136
137 if (lhs.m_base[i].get() > rhs.m_base[i].get())
138 {
139 return false;
140 }
141 }
142
143 if (lhs.m_factors.size() < rhs.m_factors.size())
144 {
145 return true;
146 }
147 else if (lhs.m_factors.size() > rhs.m_factors.size())
148 {
149 return false;
150 }
151 else
152 {
153 for (auto x = lhs.m_factors.begin(), y = rhs.m_factors.begin();
154 x != lhs.m_factors.end(); ++x, ++y)
155 {
156 if (x->second < y->second)
157 {
158 return true;
159 }
160 if (x->second > y->second)
161 {
162 return false;
163 }
164 }
165 }
166
167 if (lhs.m_varcoeffs.size() < rhs.m_varcoeffs.size())
168 {
169 return true;
170 }
171
172 if (lhs.m_varcoeffs.size() > rhs.m_varcoeffs.size())
173 {
174 return false;
175 }
176
177 for (unsigned int i = 0; i < lhs.m_varcoeff_hashes.size(); ++i)
178 {
179 if (lhs.m_varcoeff_hashes[i] < rhs.m_varcoeff_hashes[i])
180 {
181 return true;
182 }
183 if (lhs.m_varcoeff_hashes[i] > rhs.m_varcoeff_hashes[i])
184 {
185 return false;
186 }
187 }
188
189 if (lhs.m_nodalPointsType < rhs.m_nodalPointsType)
190 {
191 return true;
192 }
193
194 if (lhs.m_nodalPointsType > rhs.m_nodalPointsType)
195 {
196 return false;
197 }
198
199 return false;
200}
Nektar::StdRegions::StdMatrixKey::m_nodalPointsType
LibUtilities::PointsType m_nodalPointsType
Definition StdMatrixKey.h:185
Nektar::StdRegions::StdMatrixKey::m_base
Array< OneD, const LibUtilities::BasisSharedPtr > m_base
Definition StdMatrixKey.h:181
Nektar::StdRegions::StdMatrixKey::m_shapeType
LibUtilities::ShapeType m_shapeType
Definition StdMatrixKey.h:180
Nektar::StdRegions::StdMatrixKey::m_varcoeff_hashes
std::vector< std::size_t > m_varcoeff_hashes
Definition StdMatrixKey.h:190

◆ operator<<()

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

Definition at line 277 of file StdMatrixKey.cpp.

278{
279 os << "MatrixType: " << MatrixTypeMap[rhs.GetMatrixType()]
280 << ", ShapeType: " << LibUtilities::ShapeTypeMap[rhs.GetShapeType()]
281 << ", Ncoeffs: " << rhs.GetNcoeffs() << std::endl;
282
283 if (rhs.GetConstFactors().size())
284 {
285 os << "Constants: " << endl;
286 for (auto &x : rhs.GetConstFactors())
287 {
288 os << "\t value " << ConstFactorTypeMap[x.first] << " : "
289 << x.second << endl;
290 }
291 }
292 if (rhs.GetVarCoeffs().size())
293 {
294 os << "Variable coefficients: " << endl;
295 unsigned int i = 0;
296 for (auto &x : rhs.GetVarCoeffs())
297 {
298 os << "\t Coeff defined: " << VarCoeffTypeMap[x.first] << endl;
299 os << "\t Hash: " << rhs.GetVarCoeffHashes()[i++] << endl;
300 }
301 }
302
303 for (unsigned int i = 0;
304 i < LibUtilities::ShapeTypeDimMap[rhs.GetShapeType()]; ++i)
305 {
306 os << rhs.GetBase()[i]->GetBasisKey();
307 }
308
309 return os;
310}
Nektar::StdRegions::StdMatrixKey::GetBase
const Array< OneD, const LibUtilities::BasisSharedPtr > & GetBase() const
Definition StdMatrixKey.h:103
Nektar::StdRegions::StdMatrixKey::GetShapeType
LibUtilities::ShapeType GetShapeType() const
Definition StdMatrixKey.h:88
Nektar::StdRegions::StdMatrixKey::GetVarCoeffs
const VarCoeffMap & GetVarCoeffs() const
Definition StdMatrixKey.h:169
Nektar::StdRegions::StdMatrixKey::GetMatrixType
MatrixType GetMatrixType() const
Definition StdMatrixKey.h:83
Nektar::StdRegions::StdMatrixKey::GetConstFactors
const ConstFactorMap & GetConstFactors() const
Definition StdMatrixKey.h:138
Nektar::StdRegions::StdMatrixKey::GetVarCoeffHashes
std::vector< std::size_t > GetVarCoeffHashes() const
Definition StdMatrixKey.h:109
Nektar::StdRegions::ConstFactorTypeMap
const char *const ConstFactorTypeMap[]
Definition StdRegions.hpp:413
Nektar::StdRegions::MatrixTypeMap
const char *const MatrixTypeMap[]
Definition StdRegions.hpp:139

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.

203{
204 if (lhs.m_matrixType != rhs.m_matrixType)
205 {
206 return false;
207 }
208
209 if (lhs.m_ncoeffs != rhs.m_ncoeffs)
210 {
211 return false;
212 }
213
214 for (unsigned int i = 0; i < LibUtilities::ShapeTypeDimMap[lhs.m_shapeType];
215 ++i)
216 {
217 if (lhs.m_base[i].get() != rhs.m_base[i].get())
218 {
219 return false;
220 }
221 }
222
223 if (lhs.m_factors.size() != rhs.m_factors.size())
224 {
225 return false;
226 }
227
228 if (!std::equal(lhs.m_factors.begin(), lhs.m_factors.end(),
229 rhs.m_factors.begin()))
230 {
231 return false;
232 }
233
234 if (lhs.m_nodalPointsType != rhs.m_nodalPointsType)
235 {
236 return false;
237 }
238
239 if (lhs.m_varcoeffs.size() != rhs.m_varcoeffs.size())
240 {
241 return false;
242 }
243
244 for (unsigned int i = 0; i < lhs.m_varcoeff_hashes.size(); ++i)
245 {
246 if (lhs.m_varcoeff_hashes[i] != rhs.m_varcoeff_hashes[i])
247 {
248 return false;
249 }
250 }
251
252 for (auto &x : lhs.m_varcoeffs)
253 {
254 auto y = rhs.m_varcoeffs.find(x.first);
255 // Check var coeff is found
256 if (y == rhs.m_varcoeffs.end())
257 {
258 return false;
259 }
260
261 if (x.second.GetValue() != y->second.GetValue())
262 {
263 return false;
264 }
265 }
266 for (unsigned int i = 0; i < lhs.m_varcoeffs.size(); ++i)
267 {
268 if (lhs.m_varcoeff_hashes[i] != rhs.m_varcoeff_hashes[i])
269 {
270 return false;
271 }
272 }
273
274 return true;
275}

◆ RestrictCoeffMap()

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

Definition at line 378 of file StdRegions.hpp.

380{
381 VarCoeffMap ret;
382
383 for (auto &x : m)
384 {
385 ret[x.first] = x.second.restrict(offset, cnt);
386 }
387
388 return ret;
389}
Nektar::StdRegions::VarCoeffMap
std::map< StdRegions::VarCoeffType, VarCoeffEntry > VarCoeffMap
Definition StdRegions.hpp:375

Referenced by 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.

413 {"FactorLambda",
414 "FactorCoeffD00",
415 "FactorCoeffD11",
416 "FactorCoeffD22",
417 "FactorCoeffD01",
418 "FactorCoeffD02",
419 "FactorCoeffD12",
420 "FactorTau",
421 "FactorTime",
422 "FactorSVVCutoffRatio",
423 "FactorSVVDiffCoeff",
424 "FactorSVVPowerKerDiffCoeff",
425 "FactorSVVDGKerDiffCoeff",
426 "FactorGaussVertex",
427 "FactorGaussEdge",
428 "FactorGJP",
429 "FactorConstant"};

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

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

◆ 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.

503 {
504 {0, 0.36212, 1, 0, 0, 0, 0, 0, 0, 0, 0},
505 {0, 0.70546, 0.078836, 1, 0, 0, 0, 0, 0, 0, 0},
506 {0, 0, 0.49411, 0.072394, 1, 0, 0, 0, 0, 0, 0},
507 {0, 0, 0.000073566, 0.40506, 0.094122, 1, 0, 0, 0, 0, 0},
508 {0, 0, 0, 0.0001422, 0.36863, 0.11815, 1, 0, 0, 0, 0},
509 {0, 0, 0, 0, 0.00019497, 0.41397, 0.16927, 1, 0, 0, 0},
510 {0, 0, 0, 0, 0, 0.0009762, 0.12747, 0.13763, 1, 0, 0},
511 {0, 0, 0, 0, 0, 0, 0.0023592, 0.23683, 0.17196, 1, 0},
512 {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 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.

139 {
140 "NoMatrixType",
141 "Mass",
142 "Mass wiht Diagonal GJP",
143 "InvMass",
144 "Laplacian",
145 "Laplacian00",
146 "Laplacian01",
147 "Laplacian02",
148 "Laplacian10",
149 "Laplacian11",
150 "Laplacian12",
151 "Laplacian20",
152 "Laplacian21",
153 "Laplacian22",
154 "InvLaplacianWithUnityMean",
155 "WeakDeriv0",
156 "WeakDeriv1",
157 "WeakDeriv2",
158 "WeakDirectionalDeriv",
159 "MassLevelCurvature",
160 "LinearAdvection",
161 "LinearAdvectionReaction",
162 "LinearAdvectionDiffusionReaction",
163 "LinearAdvectionDiffusionReaction with Diagonal GJP",
164 "NBasisTrans",
165 "InvNBasisTrans",
166 "BwdTrans",
167 "BwdMat",
168 "IProductWRTBase",
169 "IProductWRTDerivBase0",
170 "IProductWRTDerivBase1",
171 "IProductWRTDerivBase2",
172 "DerivBase0",
173 "DerivBase1",
174 "DerivBase2",
175 "Helmholtz",
176 "Helmholtz with Diagonal GJP",
177 "HybridDGHelmholz",
178 "InvHybridDGHelmholtz",
179 "HybridDGHelmBndLam",
180 "HybridDGLamToQ0",
181 "HybridDGLamToQ1",
182 "HybridDGLamToQ2",
183 "HybridDGLamToU",
184 "FwdTrans",
185 "PreconR",
186 "PreconRMass",
187 "PreconLinearSpace",
188 "PreconLinearSpaceMass",
189 "InterpGauss",
190 "GaussDG",
191 "PhysInterpToEquiSpaced",
192 "EquiSpacedToCoeffs",
193 "NormDerivOnTrace"};

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(), 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::LocalRegions::NodalTriExp::v_FwdTrans(), Nektar::StdRegions::StdNodalPrismExp::v_FwdTrans(), Nektar::StdRegions::StdNodalTetExp::v_FwdTrans(), Nektar::StdRegions::StdNodalTriExp::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 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(), 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::LocalRegions::NodalTriExp::v_FwdTrans(), Nektar::StdRegions::StdNodalPrismExp::v_FwdTrans(), Nektar::StdRegions::StdNodalTetExp::v_FwdTrans(), Nektar::StdRegions::StdNodalTriExp::v_FwdTrans(), Nektar::StdRegions::StdNodalTriExp::v_NodalToModal(), 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.

455 {"NoOrientation",
456 "Fwd",
457 "Bwd",
458 "Forwards",
459 "Backwards",
460 "Dir1FwdDir1_Dir2FwdDir2",
461 "Dir1FwdDir1_Dir2BwdDir2",
462 "Dir1BwdDir1_Dir2FwdDir2",
463 "Dir1BwdDir1_Dir2BwdDir2",
464 "Dir1FwdDir2_Dir2FwdDir1",
465 "Dir1FwdDir2_Dir2BwdDir1",
466 "Dir1BwdDir2_Dir2FwdDir1",
467 "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"}

Definition at line 234 of file StdRegions.hpp.

234 {
235 "VarCoeffMass", "VarCoeffLaplacian", "VarCoeffWeakDeriv",
236 "VarCoeffD00", "VarCoeffD01", "VarCoeffD02",
237 "VarCoeffD10", "VarCoeffD11", "VarCoeffD12",
238 "VarCoeffD20", "VarCoeffD21", "VarCoeffD22",
239 "VarCoeffVelX", "VarCoeffVelY", "VarCoeffVelZ",
240 "VarCoeffMF1x", "VarCoeffMF1y", "VarCoeffMF1z",
241 "VarCoeffMF1Div", "VarCoeffMF1Mag", "VarCoeffMF2x",
242 "VarCoeffMF2y", "VarCoeffMF2z", "VarCoeffMF2Div",
243 "VarCoeffMF2Mag", "VarCoeffMF3x", "VarCoeffMF3y",
244 "VarCoeffMF3z", "VarCoeffMF3Div", "VarCoeffMF3Mag",
245 "VarCoeffMF", "VarCoeffMFDiv", "VarCoeffGmat",
246 "VarCoeffGJPNormVel"};

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

Generated on Sun Nov 9 2025 20:17:08 for Nektar++ by doxygen 1.9.8