Nektar++
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
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 boost::shared_ptr
< IndexMapKey > 		IndexMapKeySharedPtr
 
typedef boost::shared_ptr
< IndexMapValues > 		IndexMapValuesSharedPtr
 
typedef Array< OneD, Array
< OneD, NekDouble > > 		NormalVector
 
typedef boost::shared_ptr
< StdExpansion > 		StdExpansionSharedPtr
 
typedef std::vector
< StdExpansionSharedPtr > 		StdExpansionVector
 
typedef std::vector
< StdExpansionSharedPtr >
::iterator 		StdExpansionVectorIter
 
typedef boost::shared_ptr
< StdExpansion0D > 		StdExpansion0DSharedPtr
 
typedef boost::shared_ptr
< StdExpansion1D > 		StdExpansion1DSharedPtr
 
typedef boost::shared_ptr
< StdExpansion2D > 		StdExpansion2DSharedPtr
 
typedef boost::shared_ptr
< StdExpansion3D > 		StdExpansion3DSharedPtr
 
typedef boost::shared_ptr
< StdHexExp > 		StdHexExpSharedPtr
 
typedef boost::shared_ptr
< StdMatrixKey > 		StdMatrixKeySharedPtr
 
typedef boost::shared_ptr
< StdNodalPrismExp > 		StdNodalPrismExpSharedPtr
 
typedef boost::shared_ptr
< StdNodalTetExp > 		StdNodalTetExpSharedPtr
 
typedef boost::shared_ptr
< StdNodalTriExp > 		StdNodalTriExpSharedPtr
 
typedef boost::shared_ptr
< StdPointExp > 		StdPointExpSharedPtr
 
typedef boost::shared_ptr
< StdPrismExp > 		StdPrismExpSharedPtr
 
typedef boost::tuple< unsigned
int, unsigned int, unsigned
int, unsigned int > 		Mode
 
typedef boost::shared_ptr
< StdPyrExp > 		StdPyrExpSharedPtr
 
typedef boost::shared_ptr
< StdQuadExp > 		StdQuadExpSharedPtr
 
typedef std::map
< StdRegions::VarCoeffType,
Array< OneD, NekDouble > > 		VarCoeffMap
 
typedef std::map
< ConstFactorType, NekDouble > 		ConstFactorMap
 
typedef boost::shared_ptr
< StdSegExp > 		StdSegExpSharedPtr
 
typedef boost::shared_ptr
< StdTetExp > 		StdTetExpSharedPtr
 
typedef boost::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, ePreconRT, ePreconRMass, ePreconRTMass,
  ePreconLinearSpace, ePreconLinearSpaceMass, eInterpGauss, eGaussDG,
  ePhysInterpToEquiSpaced, eEquiSpacedToCoeffs, SIZE_MatrixType
}
 
enum  VarCoeffType {
  eVarCoeffMass, eVarCoeffLaplacian, eVarCoeffWeakDeriv, eVarCoeffD00,
  eVarCoeffD11, eVarCoeffD22, eVarCoeffD01, eVarCoeffD02,
  eVarCoeffD12, eVarCoeffVelX, eVarCoeffVelY
}
 
enum  ConstFactorType {
  eFactorLambda, eFactorTau, eFactorTime, eFactorSVVCutoffRatio,
  eFactorSVVDiffCoeff, eFactorGaussVertex, eFactorGaussEdge, eFactorConst
}
 
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)
 
template<typename T >
NekVector< T > GetColumn (const NekMatrix< T > &matA, int n)
 
NekMatrix< NekDouble > & SetColumn (NekMatrix< NekDouble > &matA, int n, const NekVector< NekDouble > &x)
 
NekVector< NekDouble > GetE (int rows, int n)
 
NekMatrix< NekDouble > Invert (const NekMatrix< NekDouble > &matA)
 
NekMatrix< NekDouble > GetTranspose (const NekMatrix< NekDouble > &matA)
 
int GetSize (const ConstArray< OneD, NekDouble > &x)
 
int GetSize (const NekVector< NekDouble > &x)
 
NekVector< NekDouble > ToVector (const ConstArray< OneD, NekDouble > &x)
 
Array< OneD, NekDouble > ToArray (const NekVector< NekDouble > &x)
 
NekVector< NekDouble > Hadamard (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y)
 
NekVector< NekDouble > VectorPower (const NekVector< NekDouble > &x, NekDouble p)
 
std::string MatrixToString (const NekMatrix< NekDouble > &A, int precision, NekDouble expSigFigs)
 
std::string VectorToString (const NekVector< NekDouble > &v, int precision, NekDouble expSigFigs)
 
int GetTriNumPoints (int degree)
 
int GetDegree (int nBasisFunctions)
 
int GetTetNumPoints (int degree)
 
int GetTetDegree (int nBasisFunc)
 
NekDouble MakeRound (NekDouble x)
 
NekMatrix< NekDouble > GetMonomialVandermonde (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, int degree)
 
NekMatrix< NekDouble > GetMonomialVandermonde (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z, int degree)
 
NekMatrix< NekDouble > GetMonomialVandermonde (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z)
 
NekMatrix< NekDouble > GetMonomialVandermonde (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y)
 
NekMatrix< NekDouble > GetXDerivativeOfMonomialVandermonde (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, int degree)
 
NekMatrix< NekDouble > GetXDerivativeOfMonomialVandermonde (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y)
 
NekMatrix< NekDouble > GetTetXDerivativeOfMonomialVandermonde (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z, int degree)
 
NekMatrix< NekDouble > GetTetXDerivativeOfMonomialVandermonde (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z)
 
NekMatrix< NekDouble > GetTetYDerivativeOfMonomialVandermonde (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z, int degree)
 
NekMatrix< NekDouble > GetTetYDerivativeOfMonomialVandermonde (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z)
 
NekMatrix< NekDouble > GetTetZDerivativeOfMonomialVandermonde (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z, int degree)
 
NekMatrix< NekDouble > GetTetZDerivativeOfMonomialVandermonde (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z)
 
NekMatrix< NekDouble > GetYDerivativeOfMonomialVandermonde (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, int degree)
 
NekMatrix< NekDouble > GetYDerivativeOfMonomialVandermonde (const NekVector< NekDouble > &x, const NekVector< NekDouble > &y)
 
NekVector< NekDouble > GetIntegralOfMonomialVandermonde (int degree)
 
int GetSize (const Array< OneD, const NekDouble > &x)
 
NekVector< NekDouble > ToVector (const Array< OneD, const NekDouble > &x)
 
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 []
 

Detailed Description

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

Typedef Documentation

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

Definition at line 251 of file StdRegions.hpp.

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

Definition at line 125 of file IndexMapKey.h.

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

Definition at line 55 of file IndexMapKey.h.

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

Definition at line 126 of file IndexMapKey.h.

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

Definition at line 49 of file StdPyrExp.h.

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

Definition at line 59 of file StdExpansion.h.

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

Definition at line 96 of file StdExpansion0D.h.

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

Definition at line 112 of file StdExpansion1D.h.

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

Definition at line 203 of file StdExpansion2D.h.

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

Definition at line 49 of file StdExpansion3D.h.

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

Definition at line 1873 of file StdExpansion.h.

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

Definition at line 1874 of file StdExpansion.h.

typedef std::vector< StdExpansionSharedPtr >::iterator Nektar::StdRegions::StdExpansionVectorIter

Definition at line 1875 of file StdExpansion.h.

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

Definition at line 286 of file StdHexExp.h.

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

Definition at line 196 of file StdMatrixKey.h.

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

Definition at line 149 of file StdNodalPrismExp.h.

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

Definition at line 149 of file StdNodalTetExp.h.

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

Definition at line 193 of file StdNodalTriExp.h.

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

Definition at line 131 of file StdPointExp.h.

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

Definition at line 253 of file StdPrismExp.h.

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

Definition at line 258 of file StdPyrExp.h.

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

Definition at line 262 of file StdQuadExp.h.

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

Definition at line 47 of file StdSegExp.h.

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

Definition at line 268 of file StdTetExp.h.

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

Definition at line 267 of file StdTriExp.h.

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

Definition at line 226 of file StdRegions.hpp.

Enumeration Type Documentation

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

Definition at line 229 of file StdRegions.hpp.

230  {
231  eFactorLambda,
232  eFactorTau,
233  eFactorTime,
234  eFactorSVVCutoffRatio,
235  eFactorSVVDiffCoeff,
236  eFactorGaussVertex,
237  eFactorGaussEdge,
238  eFactorConst
239  };
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 52 of file StdRegions.hpp.

53  {
54  //eStdPointExp,
55  eStdSegExp,
56  eSegExp,
57  eStdQuadExp,
58  eStdTriExp,
59  eStdNodalTriExp,
60  eQuadExp,
61  eTriExp,
62  eNodalTriExp,
63  eStdHexExp,
64  eStdPrismExp,
65  eStdPyrExp,
66  eStdTetExp,
67  eStdNodalTetExp,
68  eHexExp,
69  ePrismExp,
70  ePyrExp,
71  eTetExp,
72  eNodalTetExp,
73  SIZE_ElementType
74  };
enum Nektar::StdRegions::IndexMapType
Enumerator
eEdgeToElement 
eFaceToElement 
eEdgeInterior 
eFaceInterior 
eBoundary 
eVertex 

Definition at line 254 of file StdRegions.hpp.

255  {
256  eEdgeToElement,
257  eFaceToElement,
258  eEdgeInterior,
259  eFaceInterior,
260  eBoundary,
261  eVertex
262  };
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 
ePreconRT 
ePreconRMass 
ePreconRTMass 
ePreconLinearSpace 
ePreconLinearSpaceMass 
eInterpGauss 
eGaussDG 
ePhysInterpToEquiSpaced 
eEquiSpacedToCoeffs 
SIZE_MatrixType 

Definition at line 101 of file StdRegions.hpp.

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

275  {
276  eNoOrientation,
277  eFwd,
278  eBwd,
279  eForwards,
280  eBackwards,
281  eDir1FwdDir1_Dir2FwdDir2, // These flags are interpreted as
282  eDir1FwdDir1_Dir2BwdDir2, // taking the second direction to the
283  eDir1BwdDir1_Dir2FwdDir2, // first direction. So Dir1FwdDir2 takes
284  eDir1BwdDir1_Dir2BwdDir2, // direction 2 and makes it backward
285  eDir1FwdDir2_Dir2FwdDir1, // to direction 1 in the mapped face.
286  eDir1FwdDir2_Dir2BwdDir1, // Note be careful not to flip this
287  eDir1BwdDir2_Dir2FwdDir1, // convention especially when using
288  eDir1BwdDir2_Dir2BwdDir1, // transposed mappings.
289  SIZE_Orientation
290  };
enum Nektar::StdRegions::VarCoeffType
Enumerator
eVarCoeffMass 
eVarCoeffLaplacian 
eVarCoeffWeakDeriv 
eVarCoeffD00 
eVarCoeffD11 
eVarCoeffD22 
eVarCoeffD01 
eVarCoeffD02 
eVarCoeffD12 
eVarCoeffVelX 
eVarCoeffVelY 

Definition at line 198 of file StdRegions.hpp.

199  {
200  eVarCoeffMass,
201  eVarCoeffLaplacian,
202  eVarCoeffWeakDeriv,
203  eVarCoeffD00,
204  eVarCoeffD11,
205  eVarCoeffD22,
206  eVarCoeffD01,
207  eVarCoeffD02,
208  eVarCoeffD12,
209  eVarCoeffVelX,
210  eVarCoeffVelY
211  };

Function Documentation

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

Definition at line 349 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::MeshGraph3D::GetFaceBasisKey(), Nektar::StdRegions::StdPrismExp::v_DetFaceBasisKey(), Nektar::StdRegions::StdHexExp::v_DetFaceBasisKey(), and Nektar::StdRegions::StdPyrExp::v_DetFaceBasisKey().

354  {
355 
356  switch(faceDirBasisType)
357  {
358  case LibUtilities::eModified_A:
359  {
360  const LibUtilities::PointsKey pkey(
361  numpoints, LibUtilities::eGaussLobattoLegendre);
362  return LibUtilities::BasisKey(
363  LibUtilities::eModified_A, nummodes, pkey);
364  }
365  case LibUtilities::eModified_B:
366  case LibUtilities::eModified_C:
367  {
368  const LibUtilities::PointsKey pkey(
369  numpoints+1, LibUtilities::eGaussLobattoLegendre);
370  return LibUtilities::BasisKey(
371  LibUtilities::eModified_A, nummodes, pkey);
372  }
373  case LibUtilities::eGLL_Lagrange:
374  {
375  const LibUtilities::PointsKey pkey(
376  numpoints, LibUtilities::eGaussLobattoLegendre);
377  return LibUtilities::BasisKey(
378  LibUtilities::eGLL_Lagrange, nummodes, pkey);
379  }
380  case LibUtilities::eOrtho_A:
381  {
382  const LibUtilities::PointsKey pkey(
383  numpoints, LibUtilities::eGaussLobattoLegendre);
384  return LibUtilities::BasisKey(
385  LibUtilities::eOrtho_A, nummodes, pkey);
386  }
387  case LibUtilities::eOrtho_B:
388  case LibUtilities::eOrtho_C:
389  {
390  const LibUtilities::PointsKey pkey(
391  numpoints+1, LibUtilities::eGaussLobattoLegendre);
392  return LibUtilities::BasisKey(
393  LibUtilities::eOrtho_A, nummodes, pkey);
394  }
395  default:
396  {
397  ASSERTL0(false, "expansion type unknown");
398  break;
399  }
400  }
401 
402  // Keep things happy by returning a value.
403  return LibUtilities::NullBasisKey;
404  }
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:161
Nektar::LibUtilities::eModified_C
Principle Modified Functions .
Definition: BasisType.h:51
Nektar::LibUtilities::eModified_A
Principle Modified Functions .
Definition: BasisType.h:49
Nektar::LibUtilities::eOrtho_B
Principle Orthogonal Functions .
Definition: BasisType.h:47
Nektar::LibUtilities::eModified_B
Principle Modified Functions .
Definition: BasisType.h:50
Nektar::LibUtilities::eOrtho_C
Principle Orthogonal Functions .
Definition: BasisType.h:48
Nektar::LibUtilities::eOrtho_A
Principle Orthogonal Functions .
Definition: BasisType.h:46
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:53
Nektar::LibUtilities::eGaussLobattoLegendre
1D Gauss-Lobatto-Legendre quadrature points
Definition: PointsType.h:50
LibUtilities::BasisKey Nektar::StdRegions::EvaluateTriFaceBasisKey ( const int  facedir,
const LibUtilities::BasisType  faceDirBasisType,
const int  numpoints,
const int  nummodes 
)

Definition at line 406 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::eOrtho_A, Nektar::LibUtilities::eOrtho_B, Nektar::LibUtilities::eOrtho_C, and Nektar::LibUtilities::NullBasisKey().

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

411  {
412  switch(faceDirBasisType)
413  {
414  case LibUtilities::eModified_A:
415  {
416  const LibUtilities::PointsKey pkey(
417  numpoints, LibUtilities::eGaussLobattoLegendre);
418  return LibUtilities::BasisKey(
419  LibUtilities::eModified_A, nummodes, pkey);
420  }
421  case LibUtilities::eModified_B:
422  case LibUtilities::eModified_C:
423  {
424  switch (facedir)
425  {
426  case 0:
427  {
428  const LibUtilities::PointsKey pkey(
429  numpoints+1,
430  LibUtilities::eGaussLobattoLegendre);
431  return LibUtilities::BasisKey(
432  LibUtilities::eModified_A, nummodes, pkey);
433  }
434  case 1:
435  {
436 // const LibUtilities::PointsKey pkey(
437 // numpoints+1,
438 // LibUtilities::eGaussLobattoLegendre);
439  const LibUtilities::PointsKey pkey(
440  numpoints,
441  LibUtilities::eGaussRadauMAlpha1Beta0);
442  return LibUtilities::BasisKey(
443  LibUtilities::eModified_B, nummodes, pkey);
444  }
445  default:
446  {
447 
448  ASSERTL0(false,"invalid value to flag");
449  break;
450  }
451  }
452  }
453 
454  case LibUtilities::eGLL_Lagrange:
455  {
456  switch (facedir)
457  {
458  case 0:
459  {
460  const LibUtilities::PointsKey pkey(
461  numpoints,
462  LibUtilities::eGaussLobattoLegendre);
463  return LibUtilities::BasisKey(
464  LibUtilities::eOrtho_A, nummodes, pkey);
465  }
466  case 1:
467  {
468  const LibUtilities::PointsKey pkey(
469  numpoints,
470  LibUtilities::eGaussRadauMAlpha1Beta0);
471  return LibUtilities::BasisKey(
472  LibUtilities::eOrtho_B, nummodes, pkey);
473  }
474  default:
475  {
476  ASSERTL0(false,"invalid value to flag");
477  break;
478  }
479  }
480  }
481 
482  case LibUtilities::eOrtho_A:
483  case LibUtilities::eOrtho_B:
484  case LibUtilities::eOrtho_C:
485  {
486  switch (facedir)
487  {
488  case 0:
489  {
490  const LibUtilities::PointsKey pkey(
491  numpoints,
492  LibUtilities::eGaussLobattoLegendre);
493  return LibUtilities::BasisKey(
494  LibUtilities::eOrtho_A, nummodes, pkey);
495  }
496  case 1:
497  {
498  const LibUtilities::PointsKey pkey(
499  numpoints,
500  LibUtilities::eGaussRadauMAlpha1Beta0);
501  return LibUtilities::BasisKey(
502  LibUtilities::eOrtho_B, nummodes, pkey);
503  }
504  default:
505  {
506  ASSERTL0(false,"invalid value to flag");
507  break;
508  }
509  }
510  }
511  default:
512  {
513  ASSERTL0(false,"expansion type unknown");
514  break;
515  }
516  }
517 
518  // Keep things happy by returning a value.
519  return LibUtilities::NullBasisKey;
520  }
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:161
Nektar::LibUtilities::eModified_C
Principle Modified Functions .
Definition: BasisType.h:51
Nektar::LibUtilities::eModified_A
Principle Modified Functions .
Definition: BasisType.h:49
Nektar::LibUtilities::eGaussRadauMAlpha1Beta0
Gauss Radau pinned at x=-1, .
Definition: PointsType.h:57
Nektar::LibUtilities::eOrtho_B
Principle Orthogonal Functions .
Definition: BasisType.h:47
Nektar::LibUtilities::eModified_B
Principle Modified Functions .
Definition: BasisType.h:50
Nektar::LibUtilities::eOrtho_C
Principle Orthogonal Functions .
Definition: BasisType.h:48
Nektar::LibUtilities::eOrtho_A
Principle Orthogonal Functions .
Definition: BasisType.h:46
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:53
Nektar::LibUtilities::eGaussLobattoLegendre
1D Gauss-Lobatto-Legendre quadrature points
Definition: PointsType.h:50
template<class InputIterator , class EqualityComparable >
InputIterator Nektar::StdRegions::find ( InputIterator  first,
InputIterator  last,
InputIterator  startingpoint,
const EqualityComparable &  value 
)

Definition at line 315 of file StdRegions.hpp.

Referenced by Nektar::Utilities::Iso::condense(), Nektar::SolverUtils::FilterThresholdMax::FilterThresholdMax(), Nektar::SolverUtils::FilterThresholdMin::FilterThresholdMin(), Nektar::SpatialDomains::MeshGraph::GetCompositeList(), Nektar::LibUtilities::AnalyticExpressionEvaluator::GetConstant(), Nektar::LibUtilities::SessionReader::GetGlobalSysSolnInfo(), Nektar::Utilities::ProcessMapping::GetMapping(), Nektar::LibUtilities::SessionReader::GetSolverInfoAsEnum(), Nektar::LibUtilities::SessionReader::GetValueAsEnum(), Nektar::SpatialDomains::PointGeom::IsElmtConnected(), Nektar::NekMeshUtils::SurfaceMesh::Mesh(), Nektar::NekMeshUtils::Face::operator==(), Nektar::NekMeshUtils::operator==(), Nektar::Utilities::InputCAD::Process(), Nektar::Utilities::ProcessCyl::Process(), Nektar::SpatialDomains::Domain::Read(), Nektar::SpatialDomains::BoundaryConditions::ReadBoundaryConditions(), Nektar::SpatialDomains::MeshGraph::ReadCurves(), Nektar::SpatialDomains::MeshGraph::ReadExpansions(), Nektar::LibUtilities::SessionReader::ReadGlobalSysSolnInfo(), Nektar::LibUtilities::SessionReader::ReadVariables(), Nektar::LibUtilities::SessionReader::RegisterEnumValue(), Nektar::StdRegions::StdPyrExp::StdPyrExp(), Nektar::FilterMovingBody::v_Initialise(), Nektar::SolverUtils::FilterAeroForces::v_Initialise(), Nektar::SpatialDomains::QuadGeom::v_IsElmtConnected(), Nektar::SpatialDomains::TriGeom::v_IsElmtConnected(), Nektar::SpatialDomains::SegGeom::v_IsElmtConnected(), Nektar::SpatialDomains::Geometry3D::v_IsElmtConnected(), and Nektar::Utilities::OutputNekpp::WriteXmlComposites().

318  {
319  InputIterator val;
320 
321  if(startingpoint == first)
322  {
323  val = find(first,last,value);
324  }
325  else
326  {
327  val = find(startingpoint,last,value);
328  if(val == last)
329  {
330  val = find(first,startingpoint,value);
331  if(val == startingpoint)
332  {
333  val = last;
334  }
335  }
336  }
337  return val;
338  }
Nektar::StdRegions::find
InputIterator find(InputIterator first, InputIterator last, InputIterator startingpoint, const EqualityComparable &value)
Definition: StdRegions.hpp:315
template<typename T >
NekVector< T > Nektar::StdRegions::GetColumn ( const NekMatrix< T > &  matA,
int  n 
)

Definition at line 52 of file StdExpUtil.cpp.

53  {
54  NekVector<T> v(matA.GetRows());
55  for( int i=0; i<matA.GetRows(); ++i )
56  {
57  v[i] = matA(i,n);
58  }
59  return v;
60  }
int Nektar::StdRegions::GetDegree ( int  nBasisFunctions)

Definition at line 207 of file StdExpUtil.cpp.

References ASSERTL1, GetTriNumPoints(), and MakeRound().

Referenced by GetMonomialVandermonde(), GetXDerivativeOfMonomialVandermonde(), and GetYDerivativeOfMonomialVandermonde().

208  {
209  int degree = int(MakeRound((-3.0 + sqrt(1.0 + 8.0*nBasisFunctions))/2.0));
210 
211  // TODO: Find out why ASSERTL0 and ASSERTL1 don't work
212  ASSERTL1( GetTriNumPoints(degree) == nBasisFunctions, "The number of points defines an expansion of fractional degree, which is not supported." );
213  return degree;
214  }
Nektar::StdRegions::MakeRound
NekDouble MakeRound(NekDouble x)
Definition: StdExpUtil.cpp:231
Nektar::StdRegions::GetTriNumPoints
int GetTriNumPoints(int degree)
Definition: StdExpUtil.cpp:202
ASSERTL1
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:191
NekVector< NekDouble > Nektar::StdRegions::GetE ( int  rows,
int  n 
)

Definition at line 72 of file StdExpUtil.cpp.

Referenced by Invert().

73  {
74  NekVector<NekDouble> e(rows, 0.0);
75  e(n) = 1;
76  return e;
77  }
NekVector< NekDouble > Nektar::StdRegions::GetIntegralOfMonomialVandermonde ( int  degree)

Definition at line 497 of file StdExpUtil.cpp.

498  {
499  int cols = (degree + 1) * (degree + 2) / 2;
500  NekVector<NekDouble>integralMVandermonde(cols, 0.0);
501 
502  for(int d=0, n=0; d <= degree; ++d)
503  {
504  for(int p=0; p <= d; ++p, ++n)
505  {
506  int q = d - p;
507  int sp = 1 - 2 * (p % 2);
508  int sq = 1 - 2 * (q % 2);
509 
510  integralMVandermonde(n) = NekDouble(sp * (p+1) + sq * (q+1) + sp * sq * (p+q+2)) / ((p+1) * (q+1) * (p+q+2));
511  }
512  }
513  return integralMVandermonde;
514  }
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:44
NekMatrix< NekDouble > Nektar::StdRegions::GetMonomialVandermonde ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y,
int  degree 
)

Definition at line 236 of file StdExpUtil.cpp.

References GetSize().

Referenced by GetMonomialVandermonde().

237  {
238  int rows = GetSize(x);
239  int cols = (degree + 1)*(degree + 2)/2;
240  NekMatrix<NekDouble>matV(rows,cols, 0.0);
241 
242  for(int d=0, n=0; d <= degree; ++d)
243  {
244  for(int p=0; p <= d; ++p, ++n)
245  {
246  int q = d - p;
247 
248  for(int i=0; i<rows; ++i)
249  {
250  matV(i, n) = pow(x[i], p) * pow(y[i], q);
251  }
252  }
253  }
254  return matV;
255  }
Nektar::StdRegions::GetSize
int GetSize(const NekVector< NekDouble > &x)
Definition: StdExpUtil.cpp:116
NekMatrix< NekDouble > Nektar::StdRegions::GetMonomialVandermonde ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y,
const NekVector< NekDouble > &  z,
int  degree 
)

Definition at line 257 of file StdExpUtil.cpp.

References GetSize().

259  {
260  int rows = GetSize(x);
261  int cols = (degree + 1) * (degree + 2) * (degree + 3)/6;
262 
263  NekMatrix<NekDouble> matV(rows, cols, 0.0);
264 
265  for(int d=0, n=0; d<=degree; ++d)
266  {
267  for(int p=0; p <= d; ++p)
268  {
269  for(int q=0; q <= d - p; ++q, ++n)
270  {
271  int r = d - p - q;
272 
273  // Set n-th column of V to the monomial vector
274  for(int i=0; i<rows; ++i)
275  {
276  matV(i,n) = pow(x[i],p) * pow(y[i],q) * pow(z[i],r);
277  }
278  }
279  }
280  }
281  return matV;
282  }
Nektar::StdRegions::GetSize
int GetSize(const NekVector< NekDouble > &x)
Definition: StdExpUtil.cpp:116
NekMatrix< NekDouble > Nektar::StdRegions::GetMonomialVandermonde ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y,
const NekVector< NekDouble > &  z 
)

Definition at line 284 of file StdExpUtil.cpp.

References GetMonomialVandermonde(), GetSize(), and GetTetDegree().

285  {
286  int rows = GetSize(x);
287  int degree = GetTetDegree(rows);
288  return GetMonomialVandermonde(x, y, z, degree);
289  }
Nektar::StdRegions::GetSize
int GetSize(const NekVector< NekDouble > &x)
Definition: StdExpUtil.cpp:116
Nektar::StdRegions::GetTetDegree
int GetTetDegree(int nBasisFunc)
Definition: StdExpUtil.cpp:222
Nektar::StdRegions::GetMonomialVandermonde
NekMatrix< NekDouble > GetMonomialVandermonde(const NekVector< NekDouble > &x, const NekVector< NekDouble > &y)
Definition: StdExpUtil.cpp:291
NekMatrix< NekDouble > Nektar::StdRegions::GetMonomialVandermonde ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y 
)

Definition at line 291 of file StdExpUtil.cpp.

References GetDegree(), GetMonomialVandermonde(), and GetSize().

292  {
293  int rows = GetSize(x);
294  int degree = GetDegree(rows);
295  return GetMonomialVandermonde(x, y, degree);
296  }
Nektar::StdRegions::GetDegree
int GetDegree(int nBasisFunctions)
Definition: StdExpUtil.cpp:207
Nektar::StdRegions::GetSize
int GetSize(const NekVector< NekDouble > &x)
Definition: StdExpUtil.cpp:116
Nektar::StdRegions::GetMonomialVandermonde
NekMatrix< NekDouble > GetMonomialVandermonde(const NekVector< NekDouble > &x, const NekVector< NekDouble > &y)
Definition: StdExpUtil.cpp:291
int Nektar::StdRegions::GetSize ( const Array< OneD, const NekDouble > &  x)

Definition at line 111 of file NodalUtil.cpp.

Referenced by Nektar::NekMatrix< DataType, StandardMatrixTag >::CalculateIndex(), Nektar::LibUtilities::DubinerPoly(), Nektar::LibUtilities::DubinerPolyXDerivative(), Nektar::LibUtilities::DubinerPolyYDerivative(), Nektar::LibUtilities::GetInterpolationMatrix(), Nektar::LibUtilities::GetMonomialVandermonde(), Nektar::LibUtilities::GetTetInterpolationMatrix(), Nektar::LibUtilities::GetTetVandermonde(), Nektar::LibUtilities::GetTetXDerivativeMatrix(), Nektar::LibUtilities::GetTetXDerivativeOfMonomialVandermonde(), Nektar::LibUtilities::GetTetYDerivativeOfMonomialVandermonde(), Nektar::LibUtilities::GetTetZDerivativeMatrix(), Nektar::LibUtilities::GetTetZDerivativeOfMonomialVandermonde(), Nektar::LibUtilities::GetVandermonde(), Nektar::LibUtilities::GetVandermondeForTetXDerivative(), Nektar::LibUtilities::GetVandermondeForTetYDerivative(), Nektar::LibUtilities::GetVandermondeForTetZDerivative(), Nektar::LibUtilities::GetVandermondeForXDerivative(), Nektar::LibUtilities::GetVandermondeForYDerivative(), Nektar::LibUtilities::GetXDerivativeMatrix(), Nektar::LibUtilities::GetXDerivativeOfMonomialVandermonde(), Nektar::LibUtilities::GetYDerivativeMatrix(), Nektar::LibUtilities::GetYDerivativeOfMonomialVandermonde(), Nektar::LibUtilities::Hadamard(), Nektar::LibUtilities::JacobiPoly(), Nektar::LibUtilities::JacobiPolyDerivative(), Nektar::LibUtilities::LegendrePoly(), Nektar::LibUtilities::LegendrePolyDerivative(), Nektar::LibUtilities::SessionReader::PartitionMesh(), Nektar::LibUtilities::TetrahedralBasis(), Nektar::LibUtilities::TetXDerivative(), Nektar::LibUtilities::TetYDerivative(), Nektar::LibUtilities::TetZDerivative(), Nektar::LibUtilities::ToArray(), ToVector(), and Nektar::LibUtilities::VectorPower().

112  {
113  return x.num_elements();
114  }
int Nektar::StdRegions::GetSize ( const ConstArray< OneD, NekDouble > &  x)

Definition at line 111 of file StdExpUtil.cpp.

Referenced by GetMonomialVandermonde(), GetTetXDerivativeOfMonomialVandermonde(), GetTetYDerivativeOfMonomialVandermonde(), GetTetZDerivativeOfMonomialVandermonde(), GetXDerivativeOfMonomialVandermonde(), GetYDerivativeOfMonomialVandermonde(), Hadamard(), ToArray(), ToVector(), and VectorPower().

112  {
113  return x.num_elements();
114  }
int Nektar::StdRegions::GetSize ( const NekVector< NekDouble > &  x)

Definition at line 116 of file StdExpUtil.cpp.

References Nektar::NekVector< DataType >::GetRows().

117  {
118  return x.GetRows();
119  }
int Nektar::StdRegions::GetTetDegree ( int  nBasisFunc)

Definition at line 222 of file StdExpUtil.cpp.

References ASSERTL1, GetTetNumPoints(), and MakeRound().

Referenced by GetMonomialVandermonde(), GetTetXDerivativeOfMonomialVandermonde(), GetTetYDerivativeOfMonomialVandermonde(), and GetTetZDerivativeOfMonomialVandermonde().

223  {
224  NekDouble eq = pow( 81.0 * nBasisFunc + 3.0 * sqrt(-3.0 + 729.0 * nBasisFunc * nBasisFunc), 1.0/3.0);
225  int degree = int(MakeRound(eq/3.0 + 1.0/eq - 1.0)) - 1;
226 
227  ASSERTL1( GetTetNumPoints(degree) == nBasisFunc, "The number of points defines an expansion of fractional degree, which is not supported." );
228  return degree;
229  }
Nektar::StdRegions::MakeRound
NekDouble MakeRound(NekDouble x)
Definition: StdExpUtil.cpp:231
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:44
Nektar::StdRegions::GetTetNumPoints
int GetTetNumPoints(int degree)
Definition: StdExpUtil.cpp:216
ASSERTL1
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:191
int Nektar::StdRegions::GetTetNumPoints ( int  degree)

Definition at line 216 of file StdExpUtil.cpp.

Referenced by GetTetDegree().

217  {
218  return (degree+1) * (degree+2) * (degree+3) / 6;
219  }
NekMatrix< NekDouble > Nektar::StdRegions::GetTetXDerivativeOfMonomialVandermonde ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y,
const NekVector< NekDouble > &  z,
int  degree 
)

Definition at line 336 of file StdExpUtil.cpp.

References GetSize().

Referenced by GetTetXDerivativeOfMonomialVandermonde().

338  {
339  int rows = GetSize(x);
340  int cols = (degree + 1) * (degree + 2) * (degree + 3) / 6;
341  NekMatrix<NekDouble> matVx(rows, cols, 0.0);
342  for(int d=0, n=0; d<=degree; ++d)
343  {
344  for(int p=0; p <= d; ++p)
345  {
346  for(int q=0; q <= d - p; ++q, ++n)
347  {
348  int r = d - p - q;
349  if(p > 0)
350  {
351  // Set n-th column of V to the monomial vector
352  for(int i=0; i<rows; ++i)
353  {
354  matVx(i,n) = p * pow(x[i],p-1.0) * pow(y[i],q) * pow(z[i],r);
355  }
356  }
357  else{
358  for(int j=0; j<rows; ++j)
359  {
360  matVx(j, n) = 0.0;
361  }
362  }
363  }
364  }
365  }
366  return matVx;
367  }
Nektar::StdRegions::GetSize
int GetSize(const NekVector< NekDouble > &x)
Definition: StdExpUtil.cpp:116
NekMatrix< NekDouble > Nektar::StdRegions::GetTetXDerivativeOfMonomialVandermonde ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y,
const NekVector< NekDouble > &  z 
)

Definition at line 369 of file StdExpUtil.cpp.

References GetSize(), GetTetDegree(), and GetTetXDerivativeOfMonomialVandermonde().

371  {
372  int rows = GetSize(x);
373  int degree = GetTetDegree(rows);
374  return GetTetXDerivativeOfMonomialVandermonde(x, y, z, degree);
375  }
Nektar::StdRegions::GetSize
int GetSize(const NekVector< NekDouble > &x)
Definition: StdExpUtil.cpp:116
Nektar::StdRegions::GetTetDegree
int GetTetDegree(int nBasisFunc)
Definition: StdExpUtil.cpp:222
Nektar::StdRegions::GetTetXDerivativeOfMonomialVandermonde
NekMatrix< NekDouble > GetTetXDerivativeOfMonomialVandermonde(const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z)
Definition: StdExpUtil.cpp:369
NekMatrix< NekDouble > Nektar::StdRegions::GetTetYDerivativeOfMonomialVandermonde ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y,
const NekVector< NekDouble > &  z,
int  degree 
)

Definition at line 377 of file StdExpUtil.cpp.

References GetSize().

Referenced by GetTetYDerivativeOfMonomialVandermonde().

379  {
380  int rows = GetSize(x);
381  int cols = (degree + 1) * (degree + 2) * (degree + 3) / 6;
382  NekMatrix<NekDouble> matVy(rows, cols, 0.0);
383  for(int d=0, n=0; d<=degree; ++d)
384  {
385  for(int p=0; p <= d; ++p)
386  {
387  for(int q=0; q <= d - p; ++q, ++n)
388  {
389  int r = d - p - q;
390  if(q > 0)
391  {
392  // Set n-th column of V to the monomial vector
393  for(int i=0; i<rows; ++i)
394  {
395  matVy(i,n) = q * pow(x[i],p) * pow(y[i],q-1.0) * pow(z[i],r);
396  }
397  }
398  else
399  {
400  for(int j=0; j<rows; ++j)
401  {
402  matVy(j, n) = 0.0;
403  }
404  }
405  }
406  }
407  }
408  return matVy;
409  }
Nektar::StdRegions::GetSize
int GetSize(const NekVector< NekDouble > &x)
Definition: StdExpUtil.cpp:116
NekMatrix< NekDouble > Nektar::StdRegions::GetTetYDerivativeOfMonomialVandermonde ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y,
const NekVector< NekDouble > &  z 
)

Definition at line 411 of file StdExpUtil.cpp.

References GetSize(), GetTetDegree(), and GetTetYDerivativeOfMonomialVandermonde().

413  {
414  int rows = GetSize(x);
415  int degree = GetTetDegree(rows);
416  return GetTetYDerivativeOfMonomialVandermonde(x, y, z, degree);
417  }
Nektar::StdRegions::GetSize
int GetSize(const NekVector< NekDouble > &x)
Definition: StdExpUtil.cpp:116
Nektar::StdRegions::GetTetDegree
int GetTetDegree(int nBasisFunc)
Definition: StdExpUtil.cpp:222
Nektar::StdRegions::GetTetYDerivativeOfMonomialVandermonde
NekMatrix< NekDouble > GetTetYDerivativeOfMonomialVandermonde(const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z)
Definition: StdExpUtil.cpp:411
NekMatrix< NekDouble > Nektar::StdRegions::GetTetZDerivativeOfMonomialVandermonde ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y,
const NekVector< NekDouble > &  z,
int  degree 
)

Definition at line 419 of file StdExpUtil.cpp.

References GetSize().

Referenced by GetTetZDerivativeOfMonomialVandermonde().

421  {
422  int rows = GetSize(x);
423  int cols = (degree + 1) * (degree + 2) * (degree + 3) / 6;
424  NekMatrix<NekDouble> matVz(rows, cols, 0.0);
425  for(int d=0, n=0; d<=degree; ++d)
426  {
427  for(int p=0; p <= d; ++p)
428  {
429  for(int q=0; q <= d - p; ++q, ++n)
430  {
431  int r = d - p - q;
432  if(r > 0)
433  {
434  // Set n-th column of V to the monomial vector
435  for(int i=0; i<rows; ++i)
436  {
437  matVz(i,n) = r * pow(x[i],p) * pow(y[i],q) * pow(z[i],r-1.0);
438  }
439  }
440  else{
441  for(int j=0; j<rows; ++j)
442  {
443  matVz(j, n) = 0.0;
444  }
445  }
446  }
447  }
448  }
449  return matVz;
450  }
Nektar::StdRegions::GetSize
int GetSize(const NekVector< NekDouble > &x)
Definition: StdExpUtil.cpp:116
NekMatrix< NekDouble > Nektar::StdRegions::GetTetZDerivativeOfMonomialVandermonde ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y,
const NekVector< NekDouble > &  z 
)

Definition at line 452 of file StdExpUtil.cpp.

References GetSize(), GetTetDegree(), and GetTetZDerivativeOfMonomialVandermonde().

454  {
455  int rows = GetSize(x);
456  int degree = GetTetDegree(rows);
457  return GetTetZDerivativeOfMonomialVandermonde(x, y, z, degree);
458  }
Nektar::StdRegions::GetSize
int GetSize(const NekVector< NekDouble > &x)
Definition: StdExpUtil.cpp:116
Nektar::StdRegions::GetTetDegree
int GetTetDegree(int nBasisFunc)
Definition: StdExpUtil.cpp:222
Nektar::StdRegions::GetTetZDerivativeOfMonomialVandermonde
NekMatrix< NekDouble > GetTetZDerivativeOfMonomialVandermonde(const NekVector< NekDouble > &x, const NekVector< NekDouble > &y, const NekVector< NekDouble > &z)
Definition: StdExpUtil.cpp:452
NekMatrix< NekDouble > Nektar::StdRegions::GetTranspose ( const NekMatrix< NekDouble > &  matA)

Definition at line 96 of file StdExpUtil.cpp.

97  {
98  int rows = matA.GetRows(), columns = matA.GetColumns();
99  NekMatrix<NekDouble> matX(rows,columns);
100 
101  for( int i=0; i<rows; ++i )
102  {
103  for( int j=0; j<columns; ++j )
104  {
105  matX(j,i) = matA(i,j);
106  }
107  }
108  return matX;
109  }
int Nektar::StdRegions::GetTriNumPoints ( int  degree)

Definition at line 202 of file StdExpUtil.cpp.

Referenced by GetDegree().

203  {
204  return (degree+1) * (degree+2) / 2;
205  }
NekMatrix< NekDouble > Nektar::StdRegions::GetXDerivativeOfMonomialVandermonde ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y,
int  degree 
)

Definition at line 298 of file StdExpUtil.cpp.

References GetSize().

Referenced by GetXDerivativeOfMonomialVandermonde().

299  {
300  int rows = GetSize(x);
301  int cols = (degree + 1) * (degree + 2) / 2;
302  NekMatrix<NekDouble> matVx(rows, cols, 0.0);
303 
304  for(int d=0, n=0; d <= degree; ++d)
305  {
306  for(int p=0; p <= d; ++p, ++n)
307  {
308  int q = d - p;
309 
310  if(p > 0)
311  {
312  for(int i=0; i<rows; ++i)
313  {
314  matVx(i, n) = p * pow(x[i], p-1.0) * pow(y[i],q);
315  }
316  }
317  else
318  {
319  for(int j=0; j<rows; ++j)
320  {
321  matVx(j, n) = 0.0;
322  }
323  }
324  }
325  }
326  return matVx;
327  }
Nektar::StdRegions::GetSize
int GetSize(const NekVector< NekDouble > &x)
Definition: StdExpUtil.cpp:116
NekMatrix< NekDouble > Nektar::StdRegions::GetXDerivativeOfMonomialVandermonde ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y 
)

Definition at line 329 of file StdExpUtil.cpp.

References GetDegree(), GetSize(), and GetXDerivativeOfMonomialVandermonde().

330  {
331  int rows = GetSize(x);
332  int degree = GetDegree(rows);
333  return GetXDerivativeOfMonomialVandermonde(x, y, degree);
334  }
Nektar::StdRegions::GetDegree
int GetDegree(int nBasisFunctions)
Definition: StdExpUtil.cpp:207
Nektar::StdRegions::GetSize
int GetSize(const NekVector< NekDouble > &x)
Definition: StdExpUtil.cpp:116
Nektar::StdRegions::GetXDerivativeOfMonomialVandermonde
NekMatrix< NekDouble > GetXDerivativeOfMonomialVandermonde(const NekVector< NekDouble > &x, const NekVector< NekDouble > &y)
Definition: StdExpUtil.cpp:329
NekMatrix< NekDouble > Nektar::StdRegions::GetYDerivativeOfMonomialVandermonde ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y,
int  degree 
)

Definition at line 460 of file StdExpUtil.cpp.

References GetSize().

Referenced by GetYDerivativeOfMonomialVandermonde().

461  {
462  int rows = GetSize(x);
463  int cols = (degree + 1) * (degree + 2) / 2;
464  NekMatrix<NekDouble> matVy(rows, cols, 0.0);
465 
466  for(int d=0, n=0; d <= degree; ++d)
467  {
468  for(int p=0; p <= d; ++p, ++n)
469  {
470  int q = d - p;
471  if(q > 0)
472  {
473  for(int i=0; i<rows; ++i)
474  {
475  matVy(i, n) = q * pow(x[i], p) * pow(y[i], q-1.0);
476  }
477  }
478  else
479  {
480  for(int j=0; j<rows; ++j)
481  {
482  matVy(j, n) = 0.0;
483  }
484  }
485  }
486  }
487  return matVy;
488  }
Nektar::StdRegions::GetSize
int GetSize(const NekVector< NekDouble > &x)
Definition: StdExpUtil.cpp:116
NekMatrix< NekDouble > Nektar::StdRegions::GetYDerivativeOfMonomialVandermonde ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y 
)

Definition at line 490 of file StdExpUtil.cpp.

References GetDegree(), GetSize(), and GetYDerivativeOfMonomialVandermonde().

491  {
492  int rows = GetSize(x);
493  int degree = GetDegree(rows);
494  return GetYDerivativeOfMonomialVandermonde(x, y, degree);
495  }
Nektar::StdRegions::GetDegree
int GetDegree(int nBasisFunctions)
Definition: StdExpUtil.cpp:207
Nektar::StdRegions::GetSize
int GetSize(const NekVector< NekDouble > &x)
Definition: StdExpUtil.cpp:116
Nektar::StdRegions::GetYDerivativeOfMonomialVandermonde
NekMatrix< NekDouble > GetYDerivativeOfMonomialVandermonde(const NekVector< NekDouble > &x, const NekVector< NekDouble > &y)
Definition: StdExpUtil.cpp:490
NekVector< NekDouble > Nektar::StdRegions::Hadamard ( const NekVector< NekDouble > &  x,
const NekVector< NekDouble > &  y 
)

Definition at line 131 of file StdExpUtil.cpp.

References GetSize().

132  {
133  int size = GetSize(x);
134  NekVector<NekDouble> z(size);
135 
136  for( int i=0; i<size; ++i )
137  {
138  z[i] = x[i] * y[i];
139  }
140  return z;
141  }
Nektar::StdRegions::GetSize
int GetSize(const NekVector< NekDouble > &x)
Definition: StdExpUtil.cpp:116
NekMatrix< NekDouble > Nektar::StdRegions::Invert ( const NekMatrix< NekDouble > &  matA)

Definition at line 79 of file StdExpUtil.cpp.

References GetE(), SetColumn(), and Nektar::LinearSystem::Solve().

80  {
81  int rows = matA.GetRows(), columns = matA.GetColumns();
82  NekMatrix<NekDouble> matX(rows,columns);
83 
84  // The linear system solver
85  LinearSystem<NekMatrix<NekDouble> > matL( SharedNekMatrixPtr(new NekMatrix<NekDouble>(matA)) );
86 
87  // Solve each column for the identity matrix
88  for( int j=0; j<columns; ++j )
89  {
90  SetColumn( matX, j, matL.Solve( GetE(rows,j) ) );
91  }
92 
93  return matX;
94  }
Nektar::StdRegions::SetColumn
NekMatrix< NekDouble > & SetColumn(NekMatrix< NekDouble > &matA, int n, const NekVector< NekDouble > &x)
Definition: StdExpUtil.cpp:62
Nektar::StdRegions::GetE
NekVector< NekDouble > GetE(int rows, int n)
Definition: StdExpUtil.cpp:72
Nektar::SharedNekMatrixPtr
boost::shared_ptr< NekMatrix< NekDouble, StandardMatrixTag > > SharedNekMatrixPtr
Definition: NekMatrixFwd.hpp:71
NekDouble Nektar::StdRegions::MakeRound ( NekDouble  x)

Definition at line 231 of file StdExpUtil.cpp.

Referenced by GetDegree(), GetTetDegree(), MatrixToString(), and VectorToString().

232  {
233  return floor(x + 0.5);
234  }
std::string Nektar::StdRegions::MatrixToString ( const NekMatrix< NekDouble > &  A,
int  precision,
NekDouble  expSigFigs 
)

Definition at line 157 of file StdExpUtil.cpp.

References MakeRound().

158  {
159  stringstream s;
160  s << setprecision(precision);
161  int M = int(A.GetRows()), N = int(A.GetColumns());
162 
163  for(int i=0; i<M; ++i )
164  {
165  for(int j=0; j<N; ++j)
166  {
167  NekDouble a = MakeRound(expSigFigs * A(i, j)) / expSigFigs;
168  s << setw(7) << right << a;
169  if( j < N-1 )
170  {
171  s << ", ";
172  }
173  }
174  if( i < M-1 )
175  {
176  s << "\n";
177  }
178  }
179  return s.str();
180  }
Nektar::StdRegions::MakeRound
NekDouble MakeRound(NekDouble x)
Definition: StdExpUtil.cpp:231
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:44
bool Nektar::StdRegions::operator< ( const IndexMapKey &  lhs,
const IndexMapKey &  rhs 
)

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

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

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

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

Definition at line 199 of file IndexMapKey.cpp.

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

200  {
201  os << "IndexMapType: " << IndexMapTypeMap[rhs.GetIndexMapType()]
202  << std::endl;
203  return os;
204  }
Nektar::StdRegions::IndexMapTypeMap
const char *const IndexMapTypeMap[]
Definition: StdRegions.hpp:264
std::ostream & Nektar::StdRegions::operator<< ( std::ostream &  os,
const StdMatrixKey &  rhs 
)

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

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

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

160  {
161  if(lhs.m_indexMapType != rhs.m_indexMapType)
162  {
163  return false;
164  }
165 
166  if(lhs.m_shapeType != rhs.m_shapeType)
167  {
168  return false;
169  }
170 
171  if(lhs.m_p != rhs.m_p)
172  {
173  return false;
174  }
175 
176  if(lhs.m_q != rhs.m_q)
177  {
178  return false;
179  }
180 
181  if(lhs.m_r != rhs.m_r)
182  {
183  return false;
184  }
185 
186  if(lhs.m_entityID != rhs.m_entityID)
187  {
188  return false;
189  }
190 
191  if(lhs.m_orientation != rhs.m_orientation)
192  {
193  return false;
194  }
195 
196  return true;
197  }
Nektar::lhs
StandardMatrixTag & lhs
Definition: MatrixOperations.cpp:96
bool Nektar::StdRegions::operator== ( const StdMatrixKey &  lhs,
const StdMatrixKey &  rhs 
)

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

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

Definition at line 62 of file StdExpUtil.cpp.

Referenced by Invert().

63  {
64  for( int i=0; i<int(matA.GetRows()); ++i )
65  {
66  matA(i,n) = x[i];
67  }
68  return matA;
69  }
Array< OneD, NekDouble > Nektar::StdRegions::ToArray ( const NekVector< NekDouble > &  x)

Definition at line 126 of file StdExpUtil.cpp.

References Nektar::NekVector< DataType >::GetPtr(), and GetSize().

127  {
128  return Array<OneD, NekDouble>( GetSize(x), x.GetPtr() );
129  }
Nektar::StdRegions::GetSize
int GetSize(const NekVector< NekDouble > &x)
Definition: StdExpUtil.cpp:116
NekVector<NekDouble> Nektar::StdRegions::ToVector ( const Array< OneD, const NekDouble > &  x)

Definition at line 121 of file NodalUtil.cpp.

References Nektar::LibUtilities::GetSize().

122  {
123  return NekVector<NekDouble>( GetSize(x), x.data() );
124  }
Nektar::LibUtilities::GetSize
int GetSize(const NekVector< NekDouble > &x)
Definition: NodalUtil.cpp:116
NekVector<NekDouble> Nektar::StdRegions::ToVector ( const ConstArray< OneD, NekDouble > &  x)

Definition at line 121 of file StdExpUtil.cpp.

References GetSize().

122  {
123  return NekVector<NekDouble>( GetSize(x), x.data() );
124  }
Nektar::StdRegions::GetSize
int GetSize(const NekVector< NekDouble > &x)
Definition: StdExpUtil.cpp:116
NekVector< NekDouble > Nektar::StdRegions::VectorPower ( const NekVector< NekDouble > &  x,
NekDouble  p 
)

Definition at line 143 of file StdExpUtil.cpp.

References GetSize().

144  {
145  int size = GetSize(x);
146  NekVector<NekDouble> z(size);
147 
148  for( int i=0; i<size; ++i )
149  {
150  z[i] = pow( x[i], p );
151  }
152 
153  return z;
154  }
Nektar::StdRegions::GetSize
int GetSize(const NekVector< NekDouble > &x)
Definition: StdExpUtil.cpp:116
std::string Nektar::StdRegions::VectorToString ( const NekVector< NekDouble > &  v,
int  precision,
NekDouble  expSigFigs 
)

Definition at line 183 of file StdExpUtil.cpp.

References Nektar::NekVector< DataType >::GetRows(), and MakeRound().

184  {
185  stringstream s;
186  s << setprecision(precision) << "[ ";
187  int N = int(v.GetRows());
188  for(int j=0; j<N; ++j )
189  {
190  NekDouble x = MakeRound(expSigFigs * v(j)) / expSigFigs;
191  s << setw(7) << right << x;
192  if( j < N-1 )
193  {
194  s << ", ";
195  }
196  }
197  s << " ]";
198  return s.str();
199  }
Nektar::StdRegions::MakeRound
NekDouble MakeRound(NekDouble x)
Definition: StdExpUtil.cpp:231
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:44

Variable Documentation

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

Definition at line 241 of file StdRegions.hpp.

Referenced by Nektar::StdRegions::StdMatrixKey::GetConstFactor(), Nektar::MultiRegions::operator<<(), and operator<<().

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

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

Definition at line 264 of file StdRegions.hpp.

Referenced by operator<<().

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

Definition at line 152 of file StdRegions.hpp.

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

ConstFactorMap Nektar::StdRegions::NullConstFactorMap
static

Definition at line 252 of file StdRegions.hpp.

Referenced by Nektar::LocalRegions::Expansion2D::AddHDGHelmholtzEdgeTerms(), Nektar::StdRegions::StdExpansion::CreateGeneralMatrix(), Nektar::LocalRegions::NodalTriExp::FwdTrans(), 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(), Nektar::LocalRegions::Expansion2D::v_AddRobinEdgeContribution(), Nektar::LocalRegions::Expansion3D::v_AddRobinMassMatrix(), Nektar::LocalRegions::Expansion2D::v_AddRobinMassMatrix(), Nektar::StdRegions::StdNodalTetExp::v_FwdTrans(), Nektar::StdRegions::StdNodalPrismExp::v_FwdTrans(), Nektar::StdRegions::StdNodalTriExp::v_FwdTrans(), and Nektar::LocalRegions::Expansion2D::v_GenMatrix().

VarCoeffMap Nektar::StdRegions::NullVarCoeffMap
static

Definition at line 227 of file StdRegions.hpp.

Referenced by Nektar::StdRegions::StdExpansion::CreateGeneralMatrix(), Nektar::LocalRegions::NodalTriExp::FwdTrans(), Nektar::StdRegions::StdNodalTetExp::ModalToNodal(), Nektar::StdRegions::StdNodalPrismExp::ModalToNodal(), Nektar::StdRegions::StdNodalTriExp::ModalToNodal(), Nektar::StdRegions::StdNodalPrismExp::NodalToModal(), Nektar::StdRegions::StdNodalTetExp::NodalToModal(), Nektar::StdRegions::StdNodalTriExp::NodalToModal(), Nektar::StdRegions::StdNodalTetExp::NodalToModalTranspose(), Nektar::StdRegions::StdNodalPrismExp::NodalToModalTranspose(), Nektar::StdRegions::StdNodalTriExp::NodalToModalTranspose(), Nektar::StdRegions::StdNodalTetExp::v_FwdTrans(), Nektar::StdRegions::StdNodalPrismExp::v_FwdTrans(), and Nektar::StdRegions::StdNodalTriExp::v_FwdTrans().

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

const char* const Nektar::StdRegions::VarCoeffTypeMap[]
Initial value:
= {
"VarCoeffMass",
"VarCoeffLaplacian",
"VarCoeffWeakDeriv",
"VarCoeffD00",
"VarCoeffD11",
"VarCoeffD22",
"VarCoeffD01",
"VarCoeffD02",
"VarCoeffD12",
"VarCoeffVelX",
"VarCoeffVelY"
}

Definition at line 213 of file StdRegions.hpp.

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

Generated on Wed Mar 23 2016 20:14:37 for Nektar++ by   doxygen 1.8.8