Nektar++
Classes | Typedefs | Enumerations | Functions | Variables
Nektar::StdRegions Namespace Reference

The namespace associated with the the StdRegions library (StdRegions introduction) More...

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  StdLinSysKey
 
class  StdMatrixKey
 
class  StdNodalPrismExp
 
class  StdNodalTetExp
 
class  StdNodalTriExp
 
class  StdPointExp
 
class  StdPrismExp
 Class representing a prismatic element in reference space. More...
 
struct  cmpop
 
class  StdPyrExp
 
class  StdQuadExp
 
struct  VarCoeffEntry
 Representation of a variable coefficient. More...
 
class  StdSegExp
 Class representing a segment element in reference space All interface of this class sits in StdExpansion class. More...
 
class  StdTetExp
 
class  StdTriExp
 

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::tuple< unsigned int, unsigned int, unsigned int, unsigned int > Mode
 
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 ,
  eLinearAdvectionReaction , eLinearAdvectionDiffusionReaction , 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 ,
  eVarCoeffD11 , eVarCoeffD22 , eVarCoeffD01 , eVarCoeffD02 ,
  eVarCoeffD12 , eVarCoeffVelX , eVarCoeffVelY , eVarCoeffVelZ ,
  eVarCoeffMF1x , eVarCoeffMF1y , eVarCoeffMF1z , eVarCoeffMF1Div ,
  eVarCoeffMF1Mag , eVarCoeffMF2x , eVarCoeffMF2y , eVarCoeffMF2z ,
  eVarCoeffMF2Div , eVarCoeffMF2Mag , eVarCoeffMF3x , eVarCoeffMF3y ,
  eVarCoeffMF3z , eVarCoeffMF3Div , eVarCoeffMF3Mag , eVarCoeffMF ,
  eVarCoeffMFDiv , eVarCoeffGmat , eVarCoeffGJPNormVel , SIZE_VarCoeffType
}
 
enum  ConstFactorType {
  eFactorLambda , eFactorCoeffD00 , eFactorCoeffD11 , eFactorCoeffD22 ,
  eFactorCoeffD01 , eFactorCoeffD02 , eFactorCoeffD12 , eFactorTau ,
  eFactorTime , eFactorSVVCutoffRatio , eFactorSVVDiffCoeff , eFactorSVVPowerKerDiffCoeff ,
  eFactorSVVDGKerDiffCoeff , eFactorGaussVertex , eFactorGaussEdge , eFactorGJP ,
  eFactorConst , SIZE_ConstFactorType
}
 
enum  Orientation {
  eNoOrientation , eFwd , eBwd , eForwards ,
  eBackwards , eDir1FwdDir1_Dir2FwdDir2 , eDir1FwdDir1_Dir2BwdDir2 , eDir1BwdDir1_Dir2FwdDir2 ,
  eDir1BwdDir1_Dir2BwdDir2 , eDir1FwdDir2_Dir2FwdDir1 , eDir1FwdDir2_Dir2BwdDir1 , eDir1BwdDir2_Dir2FwdDir1 ,
  eDir1BwdDir2_Dir2BwdDir1 , SIZE_Orientation
}
 

Functions

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

Variables

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

Detailed Description

The namespace associated with the the StdRegions library (StdRegions introduction)

Typedef Documentation

◆ ConstFactorMap

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

Definition at line 399 of file StdRegions.hpp.

◆ FactorMap

typedef ConstFactorMap Nektar::StdRegions::FactorMap

Definition at line 403 of file StdRegions.hpp.

◆ Mode

typedef std::tuple<unsigned int, unsigned int, unsigned int, unsigned int> Nektar::StdRegions::Mode

Definition at line 47 of file StdPyrExp.h.

◆ StdExpansion0DSharedPtr

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

Definition at line 83 of file StdExpansion0D.h.

◆ StdExpansion1DSharedPtr

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

Definition at line 118 of file StdExpansion1D.h.

◆ StdExpansion2DSharedPtr

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

Definition at line 224 of file StdExpansion2D.h.

◆ StdExpansion3DSharedPtr

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

Definition at line 49 of file StdExpansion3D.h.

◆ StdExpansionSharedPtr

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

Definition at line 1760 of file StdExpansion.h.

◆ StdExpansionVector

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

Definition at line 1761 of file StdExpansion.h.

◆ StdHexExpSharedPtr

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

Definition at line 255 of file StdHexExp.h.

◆ StdMatrixKeySharedPtr

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

Definition at line 201 of file StdMatrixKey.h.

◆ StdNodalPrismExpSharedPtr

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

Definition at line 138 of file StdNodalPrismExp.h.

◆ StdNodalTetExpSharedPtr

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

Definition at line 138 of file StdNodalTetExp.h.

◆ StdNodalTriExpSharedPtr

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

Definition at line 174 of file StdNodalTriExp.h.

◆ StdPointExpSharedPtr

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

Definition at line 152 of file StdPointExp.h.

◆ StdPrismExpSharedPtr

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

Definition at line 239 of file StdPrismExp.h.

◆ StdPyrExpSharedPtr

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

Definition at line 258 of file StdPyrExp.h.

◆ StdQuadExpSharedPtr

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

Definition at line 243 of file StdQuadExp.h.

◆ StdSegExpSharedPtr

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

Definition at line 267 of file StdSegExp.h.

◆ StdTetExpSharedPtr

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

Definition at line 255 of file StdTetExp.h.

◆ StdTriExpSharedPtr

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

Definition at line 232 of file StdTriExp.h.

◆ VarCoeffMap

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

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

361 {
362  eFactorLambda,
363  eFactorCoeffD00,
364  eFactorCoeffD11,
365  eFactorCoeffD22,
366  eFactorCoeffD01,
367  eFactorCoeffD02,
368  eFactorCoeffD12,
369  eFactorTau,
370  eFactorTime,
371  eFactorSVVCutoffRatio,
372  eFactorSVVDiffCoeff,
373  eFactorSVVPowerKerDiffCoeff,
374  eFactorSVVDGKerDiffCoeff,
375  eFactorGaussVertex,
376  eFactorGaussEdge,
377  eFactorGJP,
378  eFactorConst,
379  SIZE_ConstFactorType
380 };

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

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

◆ 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 
eLinearAdvectionReaction 
eLinearAdvectionDiffusionReaction 
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 86 of file StdRegions.hpp.

87 {
88  eNoMatrixType,
89  eMass,
90  eMassGJP,
91  eInvMass,
92  eLaplacian,
93  eLaplacian00,
94  eLaplacian01,
95  eLaplacian02,
96  eLaplacian10,
97  eLaplacian11,
98  eLaplacian12,
99  eLaplacian20,
100  eLaplacian21,
101  eLaplacian22,
102  eInvLaplacianWithUnityMean,
103  eWeakDeriv0,
104  eWeakDeriv1,
105  eWeakDeriv2,
106  eWeakDirectionalDeriv,
107  eMassLevelCurvature,
108  eLinearAdvectionReaction,
109  eLinearAdvectionDiffusionReaction,
110  eNBasisTrans,
111  eInvNBasisTrans,
112  eBwdTrans,
113  eBwdMat,
114  eIProductWRTBase,
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  eEquiSpacedToCoeffs,
139  eNormDerivOnTrace,
140  SIZE_MatrixType
141 };

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

407 {
408  eNoOrientation,
409  eFwd,
410  eBwd,
411  eForwards,
412  eBackwards,
413  eDir1FwdDir1_Dir2FwdDir2, // These flags are interpreted as
414  eDir1FwdDir1_Dir2BwdDir2, // taking the second direction to the
415  eDir1BwdDir1_Dir2FwdDir2, // first direction. So Dir1FwdDir2 takes
416  eDir1BwdDir1_Dir2BwdDir2, // direction 2 and makes it backward
417  eDir1FwdDir2_Dir2FwdDir1, // to direction 1 in the mapped face.
418  eDir1FwdDir2_Dir2BwdDir1, // Note be careful not to flip this
419  eDir1BwdDir2_Dir2FwdDir1, // convention especially when using
420  eDir1BwdDir2_Dir2BwdDir1, // transposed mappings.
421  SIZE_Orientation
422 };

◆ VarCoeffType

enum Nektar::StdRegions::VarCoeffType
Enumerator
eVarCoeffMass 
eVarCoeffLaplacian 
eVarCoeffWeakDeriv 
eVarCoeffD00 
eVarCoeffD11 
eVarCoeffD22 
eVarCoeffD01 
eVarCoeffD02 
eVarCoeffD12 
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 196 of file StdRegions.hpp.

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

Function Documentation

◆ EvaluateQuadFaceBasisKey()

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

Definition at line 453 of file StdExpansion3D.cpp.

456 {
457  boost::ignore_unused(facedir);
458 
459  switch (faceDirBasisType)
460  {
461  case LibUtilities::eModified_A:
462  {
463  const LibUtilities::PointsKey pkey(
464  numpoints, LibUtilities::eGaussLobattoLegendre);
465  return LibUtilities::BasisKey(LibUtilities::eModified_A, nummodes,
466  pkey);
467  }
468  case LibUtilities::eModified_B:
469  case LibUtilities::eModified_C:
470  {
471  const LibUtilities::PointsKey pkey(
472  numpoints + 1, LibUtilities::eGaussLobattoLegendre);
473  return LibUtilities::BasisKey(LibUtilities::eModified_A, nummodes,
474  pkey);
475  }
476  case LibUtilities::eGLL_Lagrange:
477  {
478  const LibUtilities::PointsKey pkey(
479  numpoints, LibUtilities::eGaussLobattoLegendre);
480  return LibUtilities::BasisKey(LibUtilities::eGLL_Lagrange, nummodes,
481  pkey);
482  }
483  case LibUtilities::eOrtho_A:
484  {
485  const LibUtilities::PointsKey pkey(
486  numpoints, LibUtilities::eGaussLobattoLegendre);
487  return LibUtilities::BasisKey(LibUtilities::eOrtho_A, nummodes,
488  pkey);
489  }
490  case LibUtilities::eOrtho_B:
491  case LibUtilities::eOrtho_C:
492  {
493  const LibUtilities::PointsKey pkey(
494  numpoints + 1, LibUtilities::eGaussLobattoLegendre);
495  return LibUtilities::BasisKey(LibUtilities::eOrtho_A, nummodes,
496  pkey);
497  }
498  default:
499  {
500  NEKERROR(ErrorUtil::efatal, "expansion type unknown");
501  break;
502  }
503  }
504 
505  // Keep things happy by returning a value.
506  return LibUtilities::NullBasisKey;
507 }
NEKERROR
#define NEKERROR(type, msg)
Assert Level 0 – Fundamental assert which is used whether in FULLDEBUG, DEBUG or OPT compilation mode...
Definition: ErrorUtil.hpp:209
Nektar::LibUtilities::NullBasisKey
static const BasisKey NullBasisKey(eNoBasisType, 0, NullPointsKey)
Defines a null basis with no type or points.
Nektar::LibUtilities::eGaussLobattoLegendre
@ eGaussLobattoLegendre
1D Gauss-Lobatto-Legendre quadrature points
Definition: PointsType.h:53
Nektar::LibUtilities::eModified_B
@ eModified_B
Principle Modified Functions .
Definition: BasisType.h:51
Nektar::LibUtilities::eOrtho_A
@ eOrtho_A
Principle Orthogonal Functions .
Definition: BasisType.h:44
Nektar::LibUtilities::eModified_C
@ eModified_C
Principle Modified Functions .
Definition: BasisType.h:52
Nektar::LibUtilities::eGLL_Lagrange
@ eGLL_Lagrange
Lagrange for SEM basis .
Definition: BasisType.h:58
Nektar::LibUtilities::eOrtho_C
@ eOrtho_C
Principle Orthogonal Functions .
Definition: BasisType.h:48
Nektar::LibUtilities::eOrtho_B
@ eOrtho_B
Principle Orthogonal Functions .
Definition: BasisType.h:46
Nektar::LibUtilities::eModified_A
@ eModified_A
Principle Modified Functions .
Definition: BasisType.h:50

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

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

◆ EvaluateTriFaceBasisKey()

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

Definition at line 509 of file StdExpansion3D.cpp.

512 {
513  switch (faceDirBasisType)
514  {
515  case LibUtilities::eModified_A:
516  {
517  const LibUtilities::PointsKey pkey(
518  numpoints, LibUtilities::eGaussLobattoLegendre);
519  return LibUtilities::BasisKey(LibUtilities::eModified_A, nummodes,
520  pkey);
521  }
522  case LibUtilities::eModified_B:
523  case LibUtilities::eModified_C:
524  case LibUtilities::eModifiedPyr_C:
525  {
526  switch (facedir)
527  {
528  case 0:
529  {
530  const LibUtilities::PointsKey pkey(
531  numpoints + 1, LibUtilities::eGaussLobattoLegendre);
532  return LibUtilities::BasisKey(LibUtilities::eModified_A,
533  nummodes, pkey);
534  }
535  case 1:
536  {
537  // const LibUtilities::PointsKey pkey(
538  // numpoints+1,
539  // LibUtilities::eGaussLobattoLegendre);
540  const LibUtilities::PointsKey pkey(
541  numpoints, LibUtilities::eGaussRadauMAlpha1Beta0);
542  return LibUtilities::BasisKey(LibUtilities::eModified_B,
543  nummodes, pkey);
544  }
545  default:
546  {
547 
548  NEKERROR(ErrorUtil::efatal, "invalid value to flag");
549  break;
550  }
551  }
552  break;
553  }
554 
555  case LibUtilities::eGLL_Lagrange:
556  {
557  switch (facedir)
558  {
559  case 0:
560  {
561  const LibUtilities::PointsKey pkey(
562  numpoints, LibUtilities::eGaussLobattoLegendre);
563  return LibUtilities::BasisKey(LibUtilities::eOrtho_A,
564  nummodes, pkey);
565  }
566  case 1:
567  {
568  const LibUtilities::PointsKey pkey(
569  numpoints, LibUtilities::eGaussRadauMAlpha1Beta0);
570  return LibUtilities::BasisKey(LibUtilities::eOrtho_B,
571  nummodes, pkey);
572  }
573  default:
574  {
575  NEKERROR(ErrorUtil::efatal, "invalid value to flag");
576  break;
577  }
578  }
579  break;
580  }
581 
582  case LibUtilities::eOrtho_A:
583  case LibUtilities::eOrtho_B:
584  case LibUtilities::eOrtho_C:
585  case LibUtilities::eOrthoPyr_C:
586  {
587  switch (facedir)
588  {
589  case 0:
590  {
591  const LibUtilities::PointsKey pkey(
592  numpoints, LibUtilities::eGaussLobattoLegendre);
593  return LibUtilities::BasisKey(LibUtilities::eOrtho_A,
594  nummodes, pkey);
595  }
596  case 1:
597  {
598  const LibUtilities::PointsKey pkey(
599  numpoints, LibUtilities::eGaussRadauMAlpha1Beta0);
600  return LibUtilities::BasisKey(LibUtilities::eOrtho_B,
601  nummodes, pkey);
602  }
603  default:
604  {
605  NEKERROR(ErrorUtil::efatal, "invalid value to flag");
606  break;
607  }
608  }
609  break;
610  }
611  default:
612  {
613  NEKERROR(ErrorUtil::efatal, "expansion type unknown");
614  break;
615  }
616  }
617 
618  // Keep things happy by returning a value.
619  return LibUtilities::NullBasisKey;
620 }
Nektar::LibUtilities::eModifiedPyr_C
@ eModifiedPyr_C
Principle Modified Functions.
Definition: BasisType.h:55
Nektar::LibUtilities::eOrthoPyr_C
@ eOrthoPyr_C
Principle Orthogonal Functions .
Definition: BasisType.h:53

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

Referenced by Nektar::SpatialDomains::MeshGraph::GetFaceBasisKey(), 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 444 of file StdRegions.hpp.

446 {
447  InputIterator val;
448 
449  if (startingpoint == first)
450  {
451  val = find(first, last, value);
452  }
453  else
454  {
455  val = find(startingpoint, last, value);
456  if (val == last)
457  {
458  val = find(first, startingpoint, value);
459  if (val == startingpoint)
460  {
461  val = last;
462  }
463  }
464  }
465  return val;
466 }
Nektar::StdRegions::find
InputIterator find(InputIterator first, InputIterator last, InputIterator startingpoint, const EqualityComparable &value)
Definition: StdRegions.hpp:444

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

◆ operator<()

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

Definition at line 91 of file StdMatrixKey.cpp.

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

◆ operator<<()

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

Definition at line 274 of file StdMatrixKey.cpp.

275 {
276  os << "MatrixType: " << MatrixTypeMap[rhs.GetMatrixType()]
277  << ", ShapeType: " << LibUtilities::ShapeTypeMap[rhs.GetShapeType()]
278  << ", Ncoeffs: " << rhs.GetNcoeffs() << std::endl;
279 
280  if (rhs.GetConstFactors().size())
281  {
282  os << "Constants: " << endl;
283  for (auto &x : rhs.GetConstFactors())
284  {
285  os << "\t value " << ConstFactorTypeMap[x.first] << " : "
286  << x.second << endl;
287  }
288  }
289  if (rhs.GetVarCoeffs().size())
290  {
291  os << "Variable coefficients: " << endl;
292  unsigned int i = 0;
293  for (auto &x : rhs.GetVarCoeffs())
294  {
295  os << "\t Coeff defined: " << VarCoeffTypeMap[x.first] << endl;
296  os << "\t Hash: " << rhs.GetVarCoeffHashes()[i++] << endl;
297  }
298  }
299 
300  for (unsigned int i = 0;
301  i < LibUtilities::ShapeTypeDimMap[rhs.GetShapeType()]; ++i)
302  {
303  os << rhs.GetBase()[i]->GetBasisKey();
304  }
305 
306  return os;
307 }
Nektar::LibUtilities::ShapeTypeMap
const char *const ShapeTypeMap[SIZE_ShapeType]
Definition: ShapeType.hpp:79
Nektar::StdRegions::VarCoeffTypeMap
const char *const VarCoeffTypeMap[]
Definition: StdRegions.hpp:232
Nektar::StdRegions::ConstFactorTypeMap
const char *const ConstFactorTypeMap[]
Definition: StdRegions.hpp:382
Nektar::StdRegions::MatrixTypeMap
const char *const MatrixTypeMap[]
Definition: StdRegions.hpp:143

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

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

◆ RestrictCoeffMap()

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

Definition at line 346 of file StdRegions.hpp.

348 {
349  VarCoeffMap ret;
350 
351  for (auto &x : m)
352  {
353  ret[x.first] =
354  Array<OneD, NekDouble>(cnt, x.second.GetValue() + offset);
355  }
356 
357  return ret;
358 }
Nektar::StdRegions::VarCoeffMap
std::map< StdRegions::VarCoeffType, VarCoeffEntry > VarCoeffMap
Definition: StdRegions.hpp:343

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

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

Referenced by Nektar::Collections::Helmholtz_IterPerExp::CheckFactors(), Nektar::Collections::Helmholtz_MatrixFree::CheckFactors(), export_StdMatrixKey(), Nektar::StdRegions::StdMatrixKey::GetConstFactor(), Nektar::MultiRegions::operator<<(), and operator<<().

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

◆ kSVVDGFilter

const NekDouble Nektar::StdRegions::kSVVDGFilter[9][11]
Initial value:
= {
{0, 0.36212, 1, 0, 0, 0, 0, 0, 0, 0, 0},
{0, 0.70546, 0.078836, 1, 0, 0, 0, 0, 0, 0, 0},
{0, 0, 0.49411, 0.072394, 1, 0, 0, 0, 0, 0, 0},
{0, 0, 0.000073566, 0.40506, 0.094122, 1, 0, 0, 0, 0, 0},
{0, 0, 0, 0.0001422, 0.36863, 0.11815, 1, 0, 0, 0, 0},
{0, 0, 0, 0, 0.00019497, 0.41397, 0.16927, 1, 0, 0, 0},
{0, 0, 0, 0, 0, 0.0009762, 0.12747, 0.13763, 1, 0, 0},
{0, 0, 0, 0, 0, 0, 0.0023592, 0.23683, 0.17196, 1, 0},
{0, 0, 0, 0, 0, 0, 0, 0.0026055, 0.28682, 0.22473, 1}}

Definition at line 472 of file StdRegions.hpp.

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

◆ kSVVDGFiltermodesmax

const int Nektar::StdRegions::kSVVDGFiltermodesmax = 11

Definition at line 470 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 469 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 143 of file StdRegions.hpp.

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

◆ NullConstFactorMap

ConstFactorMap Nektar::StdRegions::NullConstFactorMap
static

Definition at line 400 of file StdRegions.hpp.

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

◆ NullFactorMap

FactorMap Nektar::StdRegions::NullFactorMap
static

Definition at line 404 of file StdRegions.hpp.

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

◆ NullVarCoeffMap

VarCoeffMap Nektar::StdRegions::NullVarCoeffMap
static

Definition at line 344 of file StdRegions.hpp.

Referenced by Nektar::StdRegions::StdExpansion::CreateGeneralMatrix(), ExpList_HelmSolve(), Nektar::LocalRegions::NodalTriExp::FwdTrans(), MatrixKey_Init(), Nektar::StdRegions::StdNodalPrismExp::ModalToNodal(), Nektar::StdRegions::StdNodalTetExp::ModalToNodal(), Nektar::StdRegions::StdNodalTriExp::ModalToNodal(), Nektar::StdRegions::StdNodalPrismExp::NodalToModal(), Nektar::StdRegions::StdNodalTetExp::NodalToModal(), Nektar::StdRegions::StdNodalTriExp::NodalToModal(), Nektar::StdRegions::StdNodalPrismExp::NodalToModalTranspose(), Nektar::StdRegions::StdNodalTetExp::NodalToModalTranspose(), Nektar::StdRegions::StdNodalTriExp::NodalToModalTranspose(), StdMatrixKey_Init(), Nektar::StdRegions::StdNodalPrismExp::v_FwdTrans(), Nektar::StdRegions::StdNodalTetExp::v_FwdTrans(), Nektar::StdRegions::StdNodalTriExp::v_FwdTrans(), 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 424 of file StdRegions.hpp.

◆ VarCoeffTypeMap

const char* const Nektar::StdRegions::VarCoeffTypeMap[]
Initial value:
= {
"VarCoeffMass", "VarCoeffLaplacian", "VarCoeffWeakDeriv",
"VarCoeffD00", "VarCoeffD11", "VarCoeffD22",
"VarCoeffD01", "VarCoeffD02", "VarCoeffD12",
"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 232 of file StdRegions.hpp.

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

Generated on Sat Mar 25 2023 12:36:01 for Nektar++ by doxygen 1.9.1