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

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

Classes

struct  cmpop
 
class  IndexMapKey
 
struct  IndexValue
 
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...
 
class  StdPyrExp
 
class  StdQuadExp
 
class  StdSegExp
 Class representing a segment element in reference space. More...
 
class  StdTetExp
 
class  StdTriExp
 

Typedefs

typedef Array< OneD, IndexValue > IndexMapValues
 
typedef std::shared_ptr< IndexMapKey > IndexMapKeySharedPtr
 
typedef std::shared_ptr< IndexMapValues > IndexMapValuesSharedPtr
 
typedef Array< OneD, Array< OneD, NekDouble > > NormalVector
 
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 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, eIProductWRTBase,
  eIProductWRTDerivBase0, eIProductWRTDerivBase1, eIProductWRTDerivBase2, 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, eFactorTau, eFactorTime, eFactorSVVCutoffRatio,
  eFactorSVVDiffCoeff, eFactorSVVPowerKerDiffCoeff, eFactorSVVDGKerDiffCoeff, eFactorGaussVertex,
  eFactorGaussEdge, eFactorConst, SIZE_ConstFactorType
}
 
enum  IndexMapType {
  eEdgeToElement, eFaceToElement, eEdgeInterior, eFaceInterior,
  eBoundary, eVertex
}
 
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

bool operator< (const IndexMapKey &lhs, const IndexMapKey &rhs)
 
bool operator== (const IndexMapKey &lhs, const IndexMapKey &rhs)
 
std::ostream & operator<< (std::ostream &os, const IndexMapKey &rhs)
 
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
 
const char *const IndexMapTypeMap []
 
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 294 of file StdRegions.hpp.

◆ IndexMapKeySharedPtr

typedef std::shared_ptr<IndexMapKey> Nektar::StdRegions::IndexMapKeySharedPtr

Definition at line 123 of file IndexMapKey.h.

◆ IndexMapValues

typedef Array<OneD, IndexValue> Nektar::StdRegions::IndexMapValues

Definition at line 53 of file IndexMapKey.h.

◆ IndexMapValuesSharedPtr

typedef std::shared_ptr<IndexMapValues> Nektar::StdRegions::IndexMapValuesSharedPtr

Definition at line 124 of file IndexMapKey.h.

◆ Mode

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

Definition at line 48 of file StdPyrExp.h.

◆ NormalVector

typedef Array<OneD, Array<OneD, NekDouble> > Nektar::StdRegions::NormalVector

Definition at line 58 of file StdExpansion.h.

◆ StdExpansion0DSharedPtr

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

Definition at line 95 of file StdExpansion0D.h.

◆ StdExpansion1DSharedPtr

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

Definition at line 111 of file StdExpansion1D.h.

◆ StdExpansion2DSharedPtr

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

Definition at line 202 of file StdExpansion2D.h.

◆ StdExpansion3DSharedPtr

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

Definition at line 48 of file StdExpansion3D.h.

◆ StdExpansionSharedPtr

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

Definition at line 1926 of file StdExpansion.h.

◆ StdExpansionVector

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

Definition at line 1927 of file StdExpansion.h.

◆ StdHexExpSharedPtr

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

Definition at line 288 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 192 of file StdNodalTriExp.h.

◆ StdPointExpSharedPtr

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

Definition at line 133 of file StdPointExp.h.

◆ StdPrismExpSharedPtr

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

Definition at line 257 of file StdPrismExp.h.

◆ StdPyrExpSharedPtr

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

Definition at line 270 of file StdPyrExp.h.

◆ StdQuadExpSharedPtr

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

Definition at line 266 of file StdQuadExp.h.

◆ StdSegExpSharedPtr

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

Definition at line 46 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 266 of file StdTriExp.h.

◆ VarCoeffMap

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

Definition at line 264 of file StdRegions.hpp.

Enumeration Type Documentation

◆ ConstFactorType

enum Nektar::StdRegions::ConstFactorType
Enumerator
eFactorLambda 
eFactorTau 
eFactorTime 
eFactorSVVCutoffRatio 
eFactorSVVDiffCoeff 
eFactorSVVPowerKerDiffCoeff 
eFactorSVVDGKerDiffCoeff 
eFactorGaussVertex 
eFactorGaussEdge 
eFactorConst 
SIZE_ConstFactorType 

Definition at line 267 of file StdRegions.hpp.

268  {
269  eFactorLambda,
270  eFactorTau,
271  eFactorTime,
272  eFactorSVVCutoffRatio,
273  eFactorSVVDiffCoeff,
274  eFactorSVVPowerKerDiffCoeff,
275  eFactorSVVDGKerDiffCoeff,
276  eFactorGaussVertex,
277  eFactorGaussEdge,
278  eFactorConst,
279  SIZE_ConstFactorType
280  };

◆ 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  };

◆ IndexMapType

enum Nektar::StdRegions::IndexMapType
Enumerator
eEdgeToElement 
eFaceToElement 
eEdgeInterior 
eFaceInterior 
eBoundary 
eVertex 

Definition at line 297 of file StdRegions.hpp.

298  {
299  eEdgeToElement,
300  eFaceToElement,
301  eEdgeInterior,
302  eFaceInterior,
303  eBoundary,
304  eVertex
305  };

◆ 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 
eIProductWRTBase 
eIProductWRTDerivBase0 
eIProductWRTDerivBase1 
eIProductWRTDerivBase2 
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  eIProductWRTBase,
126  eIProductWRTDerivBase0,
127  eIProductWRTDerivBase1,
128  eIProductWRTDerivBase2,
129  eHelmholtz,
130  eHybridDGHelmholtz,
131  eInvHybridDGHelmholtz,
132  eHybridDGHelmBndLam,
133  eHybridDGLamToQ0,
134  eHybridDGLamToQ1,
135  eHybridDGLamToQ2,
136  eHybridDGLamToU,
137  eFwdTrans,
138  ePreconR,
139  ePreconRMass,
140  ePreconLinearSpace,
141  ePreconLinearSpaceMass,
142  eInterpGauss,
143  eGaussDG,
144  ePhysInterpToEquiSpaced,
145  eEquiSpacedToCoeffs,
146  SIZE_MatrixType
147  };

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

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

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

198  {
199  eVarCoeffMass,
200  eVarCoeffLaplacian,
201  eVarCoeffWeakDeriv,
202  eVarCoeffD00,
203  eVarCoeffD11,
204  eVarCoeffD22,
205  eVarCoeffD01,
206  eVarCoeffD02,
207  eVarCoeffD12,
208  eVarCoeffVelX,
209  eVarCoeffVelY,
210  eVarCoeffVelZ,
211  eVarCoeffMF1x,
212  eVarCoeffMF1y,
213  eVarCoeffMF1z,
214  eVarCoeffMF1Div,
215  eVarCoeffMF1Mag,
216  eVarCoeffMF2x,
217  eVarCoeffMF2y,
218  eVarCoeffMF2z,
219  eVarCoeffMF2Div,
220  eVarCoeffMF2Mag,
221  eVarCoeffMF3x,
222  eVarCoeffMF3y,
223  eVarCoeffMF3z,
224  eVarCoeffMF3Div,
225  eVarCoeffMF3Mag,
226  eVarCoeffMF,
227  eVarCoeffMFDiv,
228  eVarCoeffGmat,
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 351 of file StdExpansion3D.cpp.

References ASSERTL0, 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, and Nektar::LibUtilities::NullBasisKey().

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

356  {
357  boost::ignore_unused(facedir);
358 
359  switch(faceDirBasisType)
360  {
361  case LibUtilities::eModified_A:
362  {
363  const LibUtilities::PointsKey pkey(
364  numpoints, LibUtilities::eGaussLobattoLegendre);
365  return LibUtilities::BasisKey(
366  LibUtilities::eModified_A, nummodes, pkey);
367  }
368  case LibUtilities::eModified_B:
369  case LibUtilities::eModified_C:
370  {
371  const LibUtilities::PointsKey pkey(
372  numpoints+1, LibUtilities::eGaussLobattoLegendre);
373  return LibUtilities::BasisKey(
374  LibUtilities::eModified_A, nummodes, pkey);
375  }
376  case LibUtilities::eGLL_Lagrange:
377  {
378  const LibUtilities::PointsKey pkey(
379  numpoints, LibUtilities::eGaussLobattoLegendre);
380  return LibUtilities::BasisKey(
381  LibUtilities::eGLL_Lagrange, nummodes, pkey);
382  }
383  case LibUtilities::eOrtho_A:
384  {
385  const LibUtilities::PointsKey pkey(
386  numpoints, LibUtilities::eGaussLobattoLegendre);
387  return LibUtilities::BasisKey(
388  LibUtilities::eOrtho_A, nummodes, pkey);
389  }
390  case LibUtilities::eOrtho_B:
391  case LibUtilities::eOrtho_C:
392  {
393  const LibUtilities::PointsKey pkey(
394  numpoints+1, LibUtilities::eGaussLobattoLegendre);
395  return LibUtilities::BasisKey(
396  LibUtilities::eOrtho_A, nummodes, pkey);
397  }
398  default:
399  {
400  ASSERTL0(false, "expansion type unknown");
401  break;
402  }
403  }
404 
405  // Keep things happy by returning a value.
406  return LibUtilities::NullBasisKey;
407  }
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:216
Nektar::LibUtilities::eModified_C
Principle Modified Functions .
Definition: BasisType.h:50
Nektar::LibUtilities::eModified_A
Principle Modified Functions .
Definition: BasisType.h:48
Nektar::LibUtilities::eOrtho_B
Principle Orthogonal Functions .
Definition: BasisType.h:46
Nektar::LibUtilities::eModified_B
Principle Modified Functions .
Definition: BasisType.h:49
Nektar::LibUtilities::eOrtho_C
Principle Orthogonal Functions .
Definition: BasisType.h:47
Nektar::LibUtilities::eOrtho_A
Principle Orthogonal Functions .
Definition: BasisType.h:45
Nektar::LibUtilities::NullBasisKey
static const BasisKey NullBasisKey(eNoBasisType, 0, NullPointsKey)
Defines a null basis with no type or points.
Nektar::LibUtilities::eGLL_Lagrange
Lagrange for SEM basis .
Definition: BasisType.h:54
Nektar::LibUtilities::eGaussLobattoLegendre
1D Gauss-Lobatto-Legendre quadrature points
Definition: PointsType.h:51

◆ EvaluateTriFaceBasisKey()

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

Definition at line 409 of file StdExpansion3D.cpp.

References ASSERTL0, 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, and Nektar::LibUtilities::NullBasisKey().

Referenced by Nektar::SpatialDomains::MeshGraph::GetFaceBasisKey(), Nektar::StdRegions::StdPrismExp::v_DetFaceBasisKey(), Nektar::StdRegions::StdTetExp::v_DetFaceBasisKey(), Nektar::StdRegions::StdPyrExp::v_DetFaceBasisKey(), and Nektar::StdRegions::StdExpansion3D::v_GetCoordim().

414  {
415  switch(faceDirBasisType)
416  {
417  case LibUtilities::eModified_A:
418  {
419  const LibUtilities::PointsKey pkey(
420  numpoints, LibUtilities::eGaussLobattoLegendre);
421  return LibUtilities::BasisKey(
422  LibUtilities::eModified_A, nummodes, pkey);
423  }
424  case LibUtilities::eModified_B:
425  case LibUtilities::eModified_C:
426  case LibUtilities::eModifiedPyr_C:
427  {
428  switch (facedir)
429  {
430  case 0:
431  {
432  const LibUtilities::PointsKey pkey(
433  numpoints+1,
434  LibUtilities::eGaussLobattoLegendre);
435  return LibUtilities::BasisKey(
436  LibUtilities::eModified_A, nummodes, pkey);
437  }
438  case 1:
439  {
440 // const LibUtilities::PointsKey pkey(
441 // numpoints+1,
442 // LibUtilities::eGaussLobattoLegendre);
443  const LibUtilities::PointsKey pkey(
444  numpoints,
445  LibUtilities::eGaussRadauMAlpha1Beta0);
446  return LibUtilities::BasisKey(
447  LibUtilities::eModified_B, nummodes, pkey);
448  }
449  default:
450  {
451 
452  ASSERTL0(false,"invalid value to flag");
453  break;
454  }
455  }
456  break;
457  }
458 
459  case LibUtilities::eGLL_Lagrange:
460  {
461  switch (facedir)
462  {
463  case 0:
464  {
465  const LibUtilities::PointsKey pkey(
466  numpoints,
467  LibUtilities::eGaussLobattoLegendre);
468  return LibUtilities::BasisKey(
469  LibUtilities::eOrtho_A, nummodes, pkey);
470  }
471  case 1:
472  {
473  const LibUtilities::PointsKey pkey(
474  numpoints,
475  LibUtilities::eGaussRadauMAlpha1Beta0);
476  return LibUtilities::BasisKey(
477  LibUtilities::eOrtho_B, nummodes, pkey);
478  }
479  default:
480  {
481  ASSERTL0(false,"invalid value to flag");
482  break;
483  }
484  }
485  break;
486  }
487 
488  case LibUtilities::eOrtho_A:
489  case LibUtilities::eOrtho_B:
490  case LibUtilities::eOrtho_C:
491  case LibUtilities::eOrthoPyr_C:
492  {
493  switch (facedir)
494  {
495  case 0:
496  {
497  const LibUtilities::PointsKey pkey(
498  numpoints,
499  LibUtilities::eGaussLobattoLegendre);
500  return LibUtilities::BasisKey(
501  LibUtilities::eOrtho_A, nummodes, pkey);
502  }
503  case 1:
504  {
505  const LibUtilities::PointsKey pkey(
506  numpoints,
507  LibUtilities::eGaussRadauMAlpha1Beta0);
508  return LibUtilities::BasisKey(
509  LibUtilities::eOrtho_B, nummodes, pkey);
510  }
511  default:
512  {
513  ASSERTL0(false,"invalid value to flag");
514  break;
515  }
516  }
517  break;
518  }
519  default:
520  {
521  ASSERTL0(false,"expansion type unknown");
522  break;
523  }
524  }
525 
526  // Keep things happy by returning a value.
527  return LibUtilities::NullBasisKey;
528  }
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:216
Nektar::LibUtilities::eModified_C
Principle Modified Functions .
Definition: BasisType.h:50
Nektar::LibUtilities::eModifiedPyr_C
Principle Modified Functions .
Definition: BasisType.h:52
Nektar::LibUtilities::eModified_A
Principle Modified Functions .
Definition: BasisType.h:48
Nektar::LibUtilities::eGaussRadauMAlpha1Beta0
Gauss Radau pinned at x=-1, .
Definition: PointsType.h:58
Nektar::LibUtilities::eOrtho_B
Principle Orthogonal Functions .
Definition: BasisType.h:46
Nektar::LibUtilities::eModified_B
Principle Modified Functions .
Definition: BasisType.h:49
Nektar::LibUtilities::eOrtho_C
Principle Orthogonal Functions .
Definition: BasisType.h:47
Nektar::LibUtilities::eOrtho_A
Principle Orthogonal Functions .
Definition: BasisType.h:45
Nektar::LibUtilities::eOrthoPyr_C
Principle Orthogonal Functions .
Definition: BasisType.h:51
Nektar::LibUtilities::NullBasisKey
static const BasisKey NullBasisKey(eNoBasisType, 0, NullPointsKey)
Defines a null basis with no type or points.
Nektar::LibUtilities::eGLL_Lagrange
Lagrange for SEM basis .
Definition: BasisType.h:54
Nektar::LibUtilities::eGaussLobattoLegendre
1D Gauss-Lobatto-Legendre quadrature points
Definition: PointsType.h:51

◆ find()

template<class InputIterator , class EqualityComparable >
InputIterator Nektar::StdRegions::find ( InputIterator  first,
InputIterator  last,
InputIterator  startingpoint,
const EqualityComparable &  value 
)

Definition at line 358 of file StdRegions.hpp.

Referenced by Nektar::NekMeshUtils::BLMesh::BuildElements(), Nektar::SolverUtils::ForcingAbsorption::CalcAbsorption(), Nektar::FieldUtils::Iso::Condense(), Nektar::SolverUtils::FilterThresholdMax::FilterThresholdMax(), Nektar::SolverUtils::FilterThresholdMin::FilterThresholdMin(), Nektar::NekMeshUtils::Generator2D::FindBLEnds(), Nektar::SolverUtils::Coupling::GenerateVariableMapping(), Nektar::SpatialDomains::MeshGraph::GetCompositeList(), Nektar::LibUtilities::Interpreter::ExpressionEvaluator::GetConstant(), Nektar::FieldUtils::ProcessMapping::GetMapping(), Nektar::NekMeshUtils::BLMesh::GrowLayers(), Nektar::NekMeshUtils::Generator2D::MakeBL(), Nektar::NekMeshUtils::Face::operator==(), Nektar::NekMeshUtils::operator==(), Nektar::Utilities::ProcessCurvedEdges::Process(), Nektar::FieldUtils::InputFld::Process(), Nektar::NekMeshUtils::VolumeMesh::Process(), Nektar::FieldUtils::ProcessRemoveField::Process(), Nektar::FieldUtils::ProcessFieldFromString::Process(), Nektar::NekMeshUtils::CFIMesh::Process(), Nektar::FieldUtils::ProcessCreateExp::Process(), Nektar::FieldUtils::ProcessAddCompositeID::Process(), Nektar::FieldUtils::ProcessAddFld::Process(), Nektar::NekMeshUtils::Generator2D::Process(), Nektar::SpatialDomains::Domain::Read(), Nektar::SpatialDomains::BoundaryConditions::ReadBoundaryConditions(), Nektar::SpatialDomains::MeshGraphXml::ReadCurves(), Nektar::SpatialDomains::MeshGraph::ReadExpansions(), Nektar::LibUtilities::SessionReader::ReadVariables(), Nektar::NekMeshUtils::BLMesh::Setup(), Nektar::LibUtilities::CsvIO::v_ImportFieldData(), Nektar::FilterMovingBody::v_Initialise(), Nektar::SolverUtils::FilterAeroForces::v_Initialise(), Nektar::Dummy::v_InitObject(), and Nektar::Dummy::v_PostIntegrate().

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

◆ operator<() [1/2]

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

Definition at line 89 of file IndexMapKey.cpp.

References Nektar::StdRegions::IndexMapKey::m_entityID, Nektar::StdRegions::IndexMapKey::m_indexMapType, Nektar::StdRegions::IndexMapKey::m_orientation, Nektar::StdRegions::IndexMapKey::m_p, Nektar::StdRegions::IndexMapKey::m_q, Nektar::StdRegions::IndexMapKey::m_r, and Nektar::StdRegions::IndexMapKey::m_shapeType.

90  {
91  if(lhs.m_indexMapType < rhs.m_indexMapType)
92  {
93  return true;
94  }
95 
96  if(lhs.m_indexMapType > rhs.m_indexMapType)
97  {
98  return false;
99  }
100 
101  if(lhs.m_shapeType < rhs.m_shapeType)
102  {
103  return true;
104  }
105  if(lhs.m_shapeType > rhs.m_shapeType)
106  {
107  return false;
108  }
109 
110  if(lhs.m_p < rhs.m_p)
111  {
112  return true;
113  }
114  if(lhs.m_p > rhs.m_p)
115  {
116  return false;
117  }
118 
119  if(lhs.m_q < rhs.m_q)
120  {
121  return true;
122  }
123  if(lhs.m_q > rhs.m_q)
124  {
125  return false;
126  }
127 
128  if(lhs.m_r < rhs.m_r)
129  {
130  return true;
131  }
132  if(lhs.m_r > rhs.m_r)
133  {
134  return false;
135  }
136 
137  if(lhs.m_entityID < rhs.m_entityID)
138  {
139  return true;
140  }
141  if(lhs.m_entityID > rhs.m_entityID)
142  {
143  return false;
144  }
145 
146  if(lhs.m_orientation < rhs.m_orientation)
147  {
148  return true;
149  }
150  if(lhs.m_orientation > rhs.m_orientation)
151  {
152  return false;
153  }
154 
155  return false;
156  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ operator<() [2/2]

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

Definition at line 101 of file StdMatrixKey.cpp.

References Nektar::StdRegions::StdMatrixKey::m_base, Nektar::StdRegions::StdMatrixKey::m_factors, Nektar::StdRegions::StdMatrixKey::m_matrixType, Nektar::StdRegions::StdMatrixKey::m_ncoeffs, Nektar::StdRegions::StdMatrixKey::m_nodalPointsType, Nektar::StdRegions::StdMatrixKey::m_shapeType, Nektar::StdRegions::StdMatrixKey::m_varcoeff_hashes, Nektar::StdRegions::StdMatrixKey::m_varcoeffs, and Nektar::LibUtilities::ShapeTypeDimMap.

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::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97
Nektar::LibUtilities::ShapeTypeDimMap
const unsigned int ShapeTypeDimMap[SIZE_ShapeType]
Definition: ShapeType.hpp:82

◆ operator<<() [1/2]

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

Definition at line 198 of file IndexMapKey.cpp.

References Nektar::StdRegions::IndexMapKey::GetIndexMapType(), and IndexMapTypeMap.

199  {
200  os << "IndexMapType: " << IndexMapTypeMap[rhs.GetIndexMapType()]
201  << std::endl;
202  return os;
203  }
Nektar::StdRegions::IndexMapTypeMap
const char *const IndexMapTypeMap[]
Definition: StdRegions.hpp:307
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ operator<<() [2/2]

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

Definition at line 281 of file StdMatrixKey.cpp.

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.

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::StdRegions::ConstFactorTypeMap
const char *const ConstFactorTypeMap[]
Definition: StdRegions.hpp:282
Nektar::LibUtilities::ShapeTypeMap
const char *const ShapeTypeMap[]
Definition: ShapeType.hpp:67
Nektar::StdRegions::MatrixTypeMap
const char *const MatrixTypeMap[]
Definition: StdRegions.hpp:149
Nektar::StdRegions::VarCoeffTypeMap
const char *const VarCoeffTypeMap[]
Definition: StdRegions.hpp:232
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97
Nektar::LibUtilities::ShapeTypeDimMap
const unsigned int ShapeTypeDimMap[SIZE_ShapeType]
Definition: ShapeType.hpp:82

◆ operator==() [1/2]

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

Definition at line 158 of file IndexMapKey.cpp.

References Nektar::StdRegions::IndexMapKey::m_entityID, Nektar::StdRegions::IndexMapKey::m_indexMapType, Nektar::StdRegions::IndexMapKey::m_orientation, Nektar::StdRegions::IndexMapKey::m_p, Nektar::StdRegions::IndexMapKey::m_q, Nektar::StdRegions::IndexMapKey::m_r, and Nektar::StdRegions::IndexMapKey::m_shapeType.

159  {
160  if(lhs.m_indexMapType != rhs.m_indexMapType)
161  {
162  return false;
163  }
164 
165  if(lhs.m_shapeType != rhs.m_shapeType)
166  {
167  return false;
168  }
169 
170  if(lhs.m_p != rhs.m_p)
171  {
172  return false;
173  }
174 
175  if(lhs.m_q != rhs.m_q)
176  {
177  return false;
178  }
179 
180  if(lhs.m_r != rhs.m_r)
181  {
182  return false;
183  }
184 
185  if(lhs.m_entityID != rhs.m_entityID)
186  {
187  return false;
188  }
189 
190  if(lhs.m_orientation != rhs.m_orientation)
191  {
192  return false;
193  }
194 
195  return true;
196  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97

◆ operator==() [2/2]

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

Definition at line 207 of file StdMatrixKey.cpp.

References Nektar::StdRegions::StdMatrixKey::m_base, Nektar::StdRegions::StdMatrixKey::m_factors, Nektar::StdRegions::StdMatrixKey::m_matrixType, Nektar::StdRegions::StdMatrixKey::m_ncoeffs, Nektar::StdRegions::StdMatrixKey::m_nodalPointsType, Nektar::StdRegions::StdMatrixKey::m_shapeType, Nektar::StdRegions::StdMatrixKey::m_varcoeff_hashes, Nektar::StdRegions::StdMatrixKey::m_varcoeffs, and Nektar::LibUtilities::ShapeTypeDimMap.

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  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:95
Nektar::rhs
StandardMatrixTag boost::call_traits< LhsDataType >::const_reference rhs
Definition: MatrixOperations.cpp:97
Nektar::LibUtilities::ShapeTypeDimMap
const unsigned int ShapeTypeDimMap[SIZE_ShapeType]
Definition: ShapeType.hpp:82

Variable Documentation

◆ ConstFactorTypeMap

const char* const Nektar::StdRegions::ConstFactorTypeMap[]
Initial value:
= {
"FactorLambda",
"FactorTau",
"FactorTime",
"FactorSVVCutoffRatio",
"FactorSVVDiffCoeff",
"FactorSVVPowerKerDiffCoeff",
"FactorSVVDGKerDiffCoeff",
"FactorGaussVertex",
"FactorGaussEdge",
"FactorConstant"
}

Definition at line 282 of file StdRegions.hpp.

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

◆ IndexMapTypeMap

const char* const Nektar::StdRegions::IndexMapTypeMap[]
Initial value:
=
{
"EdgeToElement",
"FaceToElement",
"EdgeInterior",
"FaceInterior",
"Boundary",
"Vertex"
}

Definition at line 307 of file StdRegions.hpp.

Referenced by operator<<().

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

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

◆ kSVVDGFiltermodesmax

const int Nektar::StdRegions::kSVVDGFiltermodesmax = 11

Definition at line 385 of file StdRegions.hpp.

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

◆ kSVVDGFiltermodesmin

const int Nektar::StdRegions::kSVVDGFiltermodesmin = 3

Definition at line 384 of file StdRegions.hpp.

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

◆ MatrixTypeMap

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

Definition at line 149 of file StdRegions.hpp.

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

◆ NullConstFactorMap

ConstFactorMap Nektar::StdRegions::NullConstFactorMap
static

Definition at line 295 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::StdNodalTetExp::ModalToNodal(), Nektar::StdRegions::StdNodalPrismExp::ModalToNodal(), Nektar::StdRegions::StdNodalTriExp::ModalToNodal(), Nektar::StdRegions::StdNodalTetExp::NodalToModal(), Nektar::StdRegions::StdNodalPrismExp::NodalToModal(), Nektar::StdRegions::StdNodalTriExp::NodalToModal(), Nektar::StdRegions::StdNodalTetExp::NodalToModalTranspose(), Nektar::StdRegions::StdNodalPrismExp::NodalToModalTranspose(), Nektar::StdRegions::StdNodalTriExp::NodalToModalTranspose(), StdMatrixKey_Init(), Nektar::LocalRegions::Expansion2D::v_AddRobinEdgeContribution(), Nektar::LocalRegions::Expansion3D::v_AddRobinMassMatrix(), Nektar::LocalRegions::Expansion2D::v_AddRobinMassMatrix(), Nektar::StdRegions::StdNodalTetExp::v_FwdTrans(), Nektar::StdRegions::StdNodalTriExp::v_FwdTrans(), Nektar::StdRegions::StdNodalPrismExp::v_FwdTrans(), Nektar::LocalRegions::Expansion3D::v_GenMatrix(), and Nektar::LocalRegions::Expansion2D::v_GenMatrix().

◆ NullVarCoeffMap

VarCoeffMap Nektar::StdRegions::NullVarCoeffMap
static

Definition at line 265 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::StdNodalTetExp::v_FwdTrans(), Nektar::StdRegions::StdNodalTriExp::v_FwdTrans(), Nektar::StdRegions::StdNodalPrismExp::v_FwdTrans(), Nektar::VCSWeakPressure::v_SolvePressure(), Nektar::VelocityCorrectionScheme::v_SolveViscous(), Nektar::LocalRegions::Expansion2D::~Expansion2D(), and Nektar::LocalRegions::Expansion3D::~Expansion3D().

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

◆ VarCoeffTypeMap

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

Definition at line 232 of file StdRegions.hpp.

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

Generated on Wed Jan 20 2021 03:34:16 for Nektar++ by   doxygen 1.8.13