Nektar++
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
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
 
class  StdSegExp
 Class representing a segment element in reference space. 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, Array< OneD, NekDouble > > 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 {
  eMass , 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 ,
  eHybridDGHelmholtz , eInvHybridDGHelmholtz , eHybridDGHelmBndLam , eHybridDGLamToQ0 ,
  eHybridDGLamToQ1 , eHybridDGLamToQ2 , eHybridDGLamToU , eFwdTrans ,
  ePreconR , ePreconRMass , ePreconLinearSpace , ePreconLinearSpaceMass ,
  eInterpGauss , eGaussDG , ePhysInterpToEquiSpaced , eEquiSpacedToCoeffs ,
  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 , SIZE_VarCoeffType
}
 
enum  ConstFactorType {
  eFactorLambda , eFactorCoeffD00 , eFactorCoeffD11 , eFactorCoeffD22 ,
  eFactorCoeffD01 , eFactorCoeffD02 , eFactorCoeffD12 , eFactorTau ,
  eFactorTime , eFactorSVVCutoffRatio , eFactorSVVDiffCoeff , eFactorSVVPowerKerDiffCoeff ,
  eFactorSVVDGKerDiffCoeff , eFactorGaussVertex , eFactorGaussEdge , 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)
 
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 314 of file StdRegions.hpp.

◆ FactorMap

typedef ConstFactorMap Nektar::StdRegions::FactorMap

Definition at line 318 of file StdRegions.hpp.

◆ Mode

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

Definition at line 48 of file StdPyrExp.h.

◆ StdExpansion0DSharedPtr

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

Definition at line 88 of file StdExpansion0D.h.

◆ StdExpansion1DSharedPtr

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

Definition at line 93 of file StdExpansion1D.h.

◆ StdExpansion2DSharedPtr

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

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

◆ StdExpansionVector

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

Definition at line 1715 of file StdExpansion.h.

◆ StdHexExpSharedPtr

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

Definition at line 293 of file StdHexExp.h.

◆ StdMatrixKeySharedPtr

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

Definition at line 189 of file StdMatrixKey.h.

◆ StdNodalPrismExpSharedPtr

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

Definition at line 148 of file StdNodalPrismExp.h.

◆ StdNodalTetExpSharedPtr

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

Definition at line 148 of file StdNodalTetExp.h.

◆ StdNodalTriExpSharedPtr

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

Definition at line 196 of file StdNodalTriExp.h.

◆ StdPointExpSharedPtr

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

Definition at line 138 of file StdPointExp.h.

◆ StdPrismExpSharedPtr

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

Definition at line 263 of file StdPrismExp.h.

◆ StdPyrExpSharedPtr

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

Definition at line 278 of file StdPyrExp.h.

◆ StdQuadExpSharedPtr

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

Definition at line 273 of file StdQuadExp.h.

◆ StdSegExpSharedPtr

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

Definition at line 47 of file StdSegExp.h.

◆ StdTetExpSharedPtr

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

Definition at line 279 of file StdTetExp.h.

◆ StdTriExpSharedPtr

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

Definition at line 272 of file StdTriExp.h.

◆ VarCoeffMap

typedef std::map<StdRegions::VarCoeffType, Array<OneD, NekDouble> > Nektar::StdRegions::VarCoeffMap

Definition at line 272 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 
eFactorConst 
SIZE_ConstFactorType 

Definition at line 275 of file StdRegions.hpp.

276  {
277  eFactorLambda,
278  eFactorCoeffD00,
279  eFactorCoeffD11,
280  eFactorCoeffD22,
281  eFactorCoeffD01,
282  eFactorCoeffD02,
283  eFactorCoeffD12,
284  eFactorTau,
285  eFactorTime,
286  eFactorSVVCutoffRatio,
287  eFactorSVVDiffCoeff,
288  eFactorSVVPowerKerDiffCoeff,
289  eFactorSVVDGKerDiffCoeff,
290  eFactorGaussVertex,
291  eFactorGaussEdge,
292  eFactorConst,
293  SIZE_ConstFactorType
294  };

◆ 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
eMass 
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 
eHybridDGHelmholtz 
eInvHybridDGHelmholtz 
eHybridDGHelmBndLam 
eHybridDGLamToQ0 
eHybridDGLamToQ1 
eHybridDGLamToQ2 
eHybridDGLamToU 
eFwdTrans 
ePreconR 
ePreconRMass 
ePreconLinearSpace 
ePreconLinearSpaceMass 
eInterpGauss 
eGaussDG 
ePhysInterpToEquiSpaced 
eEquiSpacedToCoeffs 
SIZE_MatrixType 

Definition at line 100 of file StdRegions.hpp.

101  {
102  eMass,
103  eInvMass,
104  eLaplacian,
105  eLaplacian00,
106  eLaplacian01,
107  eLaplacian02,
108  eLaplacian10,
109  eLaplacian11,
110  eLaplacian12,
111  eLaplacian20,
112  eLaplacian21,
113  eLaplacian22,
114  eInvLaplacianWithUnityMean,
115  eWeakDeriv0,
116  eWeakDeriv1,
117  eWeakDeriv2,
118  eWeakDirectionalDeriv,
119  eMassLevelCurvature,
120  eLinearAdvectionReaction,
121  eLinearAdvectionDiffusionReaction,
122  eNBasisTrans,
123  eInvNBasisTrans,
124  eBwdTrans,
125  eBwdMat,
126  eIProductWRTBase,
127  eIProductWRTDerivBase0,
128  eIProductWRTDerivBase1,
129  eIProductWRTDerivBase2,
130  eDerivBase0,
131  eDerivBase1,
132  eDerivBase2,
133  eHelmholtz,
134  eHybridDGHelmholtz,
135  eInvHybridDGHelmholtz,
136  eHybridDGHelmBndLam,
137  eHybridDGLamToQ0,
138  eHybridDGLamToQ1,
139  eHybridDGLamToQ2,
140  eHybridDGLamToU,
141  eFwdTrans,
142  ePreconR,
143  ePreconRMass,
144  ePreconLinearSpace,
145  ePreconLinearSpaceMass,
146  eInterpGauss,
147  eGaussDG,
148  ePhysInterpToEquiSpaced,
149  eEquiSpacedToCoeffs,
150  SIZE_MatrixType
151  };

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

322  {
323  eNoOrientation,
324  eFwd,
325  eBwd,
326  eForwards,
327  eBackwards,
328  eDir1FwdDir1_Dir2FwdDir2, // These flags are interpreted as
329  eDir1FwdDir1_Dir2BwdDir2, // taking the second direction to the
330  eDir1BwdDir1_Dir2FwdDir2, // first direction. So Dir1FwdDir2 takes
331  eDir1BwdDir1_Dir2BwdDir2, // direction 2 and makes it backward
332  eDir1FwdDir2_Dir2FwdDir1, // to direction 1 in the mapped face.
333  eDir1FwdDir2_Dir2BwdDir1, // Note be careful not to flip this
334  eDir1BwdDir2_Dir2FwdDir1, // convention especially when using
335  eDir1BwdDir2_Dir2BwdDir1, // transposed mappings.
336  SIZE_Orientation
337  };

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

Definition at line 205 of file StdRegions.hpp.

206  {
207  eVarCoeffMass,
208  eVarCoeffLaplacian,
209  eVarCoeffWeakDeriv,
210  eVarCoeffD00,
211  eVarCoeffD11,
212  eVarCoeffD22,
213  eVarCoeffD01,
214  eVarCoeffD02,
215  eVarCoeffD12,
216  eVarCoeffVelX,
217  eVarCoeffVelY,
218  eVarCoeffVelZ,
219  eVarCoeffMF1x,
220  eVarCoeffMF1y,
221  eVarCoeffMF1z,
222  eVarCoeffMF1Div,
223  eVarCoeffMF1Mag,
224  eVarCoeffMF2x,
225  eVarCoeffMF2y,
226  eVarCoeffMF2z,
227  eVarCoeffMF2Div,
228  eVarCoeffMF2Mag,
229  eVarCoeffMF3x,
230  eVarCoeffMF3y,
231  eVarCoeffMF3z,
232  eVarCoeffMF3Div,
233  eVarCoeffMF3Mag,
234  eVarCoeffMF,
235  eVarCoeffMFDiv,
236  eVarCoeffGmat,
237  SIZE_VarCoeffType
238  };

Function Documentation

◆ EvaluateQuadFaceBasisKey()

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

Definition at line 441 of file StdExpansion3D.cpp.

446  {
447  boost::ignore_unused(facedir);
448 
449  switch(faceDirBasisType)
450  {
451  case LibUtilities::eModified_A:
452  {
453  const LibUtilities::PointsKey pkey(
454  numpoints, LibUtilities::eGaussLobattoLegendre);
455  return LibUtilities::BasisKey(
456  LibUtilities::eModified_A, nummodes, pkey);
457  }
458  case LibUtilities::eModified_B:
459  case LibUtilities::eModified_C:
460  {
461  const LibUtilities::PointsKey pkey(
462  numpoints+1, LibUtilities::eGaussLobattoLegendre);
463  return LibUtilities::BasisKey(
464  LibUtilities::eModified_A, nummodes, pkey);
465  }
466  case LibUtilities::eGLL_Lagrange:
467  {
468  const LibUtilities::PointsKey pkey(
469  numpoints, LibUtilities::eGaussLobattoLegendre);
470  return LibUtilities::BasisKey(
471  LibUtilities::eGLL_Lagrange, nummodes, pkey);
472  }
473  case LibUtilities::eOrtho_A:
474  {
475  const LibUtilities::PointsKey pkey(
476  numpoints, LibUtilities::eGaussLobattoLegendre);
477  return LibUtilities::BasisKey(
478  LibUtilities::eOrtho_A, nummodes, pkey);
479  }
480  case LibUtilities::eOrtho_B:
481  case LibUtilities::eOrtho_C:
482  {
483  const LibUtilities::PointsKey pkey(
484  numpoints+1, LibUtilities::eGaussLobattoLegendre);
485  return LibUtilities::BasisKey(
486  LibUtilities::eOrtho_A, nummodes, pkey);
487  }
488  default:
489  {
490  NEKERROR(ErrorUtil::efatal, "expansion type unknown");
491  break;
492  }
493  }
494 
495  // Keep things happy by returning a value.
496  return LibUtilities::NullBasisKey;
497  }
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:51
Nektar::LibUtilities::eModified_B
@ eModified_B
Principle Modified Functions .
Definition: BasisType.h:49
Nektar::LibUtilities::eOrtho_A
@ eOrtho_A
Principle Orthogonal Functions .
Definition: BasisType.h:45
Nektar::LibUtilities::eModified_C
@ eModified_C
Principle Modified Functions .
Definition: BasisType.h:50
Nektar::LibUtilities::eGLL_Lagrange
@ eGLL_Lagrange
Lagrange for SEM basis .
Definition: BasisType.h:54
Nektar::LibUtilities::eOrtho_C
@ eOrtho_C
Principle Orthogonal Functions .
Definition: BasisType.h:47
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:48

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 499 of file StdExpansion3D.cpp.

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

References Nektar::ErrorUtil::efatal, Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eGaussRadauMAlpha1Beta0, 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 362 of file StdRegions.hpp.

365  {
366  InputIterator val;
367 
368  if(startingpoint == first)
369  {
370  val = find(first,last,value);
371  }
372  else
373  {
374  val = find(startingpoint,last,value);
375  if(val == last)
376  {
377  val = find(first,startingpoint,value);
378  if(val == startingpoint)
379  {
380  val = last;
381  }
382  }
383  }
384  return val;
385  }
Nektar::StdRegions::find
InputIterator find(InputIterator first, InputIterator last, InputIterator startingpoint, const EqualityComparable &value)
Definition: StdRegions.hpp:362

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::SpatialDomains::MeshGraph::GetCompositeList(), Nektar::LibUtilities::Interpreter::ExpressionEvaluator::GetConstant(), Nektar::FieldUtils::ProcessMapping::GetMapping(), Nektar::MultiRegions::AssemblyCommDG::InitialiseStructure(), Nektar::FieldUtils::ProcessCreateExp::LoadFieldData(), Nektar::FieldUtils::InputFld::Process(), Nektar::FieldUtils::ProcessAddCompositeID::Process(), Nektar::FieldUtils::ProcessAddFld::Process(), Nektar::FieldUtils::ProcessFieldFromString::Process(), Nektar::FieldUtils::ProcessRemoveField::Process(), Nektar::SpatialDomains::Domain::Read(), Nektar::SpatialDomains::BoundaryConditions::ReadBoundaryConditions(), Nektar::SpatialDomains::MeshGraphXml::ReadCurves(), 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(), and Nektar::Dummy::v_PostIntegrate().

◆ operator<()

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

Definition at line 101 of file StdMatrixKey.cpp.

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

◆ operator<<()

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

Definition at line 281 of file StdMatrixKey.cpp.

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

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

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

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

Definition at line 296 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 391 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 389 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 388 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 153 of file StdRegions.hpp.

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

◆ NullConstFactorMap

ConstFactorMap Nektar::StdRegions::NullConstFactorMap
static

Definition at line 315 of file StdRegions.hpp.

Referenced by Nektar::LocalRegions::Expansion2D::AddHDGHelmholtzEdgeTerms(), Nektar::LocalRegions::Expansion3D::AddHDGHelmholtzFaceTerms(), Nektar::StdRegions::StdExpansion::CreateGeneralMatrix(), Nektar::LocalRegions::TriExp::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 319 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 273 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 339 of file StdRegions.hpp.

◆ VarCoeffTypeMap

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

Definition at line 240 of file StdRegions.hpp.

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

Generated on Wed Nov 24 2021 10:33:37 for Nektar++ by doxygen 1.9.1