Nektar::StdRegions Namespace Reference

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

Namespaces
namespace	StdPrismData
namespace	StdPyrData
namespace	StdTetData
namespace	StdTriData
Classes
struct	IndexValue
class	IndexMapKey
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::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,   ePreconditioner, SIZE_MatrixType }
enum	VarCoeffType {   eVarCoeffMass, eVarCoeffLaplacian, eVarCoeffWeakDeriv, eVarCoeffD00,   eVarCoeffD11, eVarCoeffD22, eVarCoeffD01, eVarCoeffD02,   eVarCoeffD12, eVarCoeffPrimative, eVarCoeffVelX, eVarCoeffVelY }
enum	ConstFactorType { eFactorLambda, eFactorTau, eFactorTime }
enum	ExpansionType {   eNoExpansionType, eSegment, eTriangle, eQuadrilateral,   eTetrahedron, ePyramid, ePrism, eHexahedron,   ePoint, SIZE_ExpansionType }
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)
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, double expSigFigs)
std::string	VectorToString (const NekVector< NekDouble > &v, int precision, double 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 int	g_shapenverts [SIZE_ExpansionType] = {0,2,3,4,4,5,6,8}
const int	g_shapenedges [SIZE_ExpansionType] = {0,1,3,4,6,8,9,12}
const int	g_shapenfaces [SIZE_ExpansionType] = {0,0,0,0,4,5,5,6}
static int	s_matrixcnt = 99
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	ExpansionTypeMap []
const unsigned int	ExpansionTypeDimMap [SIZE_ExpansionType]
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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

---

Enumeration Type Documentation

enum Nektar::StdRegions::ConstFactorType

Enumerator:

eFactorLambda
eFactorTau
eFactorTime

        {
            eFactorLambda,
            eFactorTau,
            eFactorTime
        };

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

        {
            //eStdPointExp,
            eStdSegExp,
            eSegExp,
            eStdQuadExp,
            eStdTriExp,
            eStdNodalTriExp,
            eQuadExp,
            eTriExp,
            eNodalTriExp,
            eStdHexExp,
            eStdPrismExp,
            eStdPyrExp,
            eStdTetExp,
            eStdNodalTetExp,
            eHexExp,
            ePrismExp,
            ePyrExp,
            eTetExp,
            eNodalTetExp,
            SIZE_ElementType
        };

enum Nektar::StdRegions::ExpansionType

enum list of StdExpansion regions

Enumerator:

eNoExpansionType
eSegment
eTriangle
eQuadrilateral
eTetrahedron
ePyramid
ePrism
eHexahedron
ePoint
SIZE_ExpansionType

        {
            eNoExpansionType,
            eSegment,
            eTriangle,
            eQuadrilateral,
            eTetrahedron,
            ePyramid,
            ePrism,
            eHexahedron,
            ePoint,
            SIZE_ExpansionType
        };

enum Nektar::StdRegions::IndexMapType

Enumerator:

eEdgeToElement
eFaceToElement
eEdgeInterior
eFaceInterior
eBoundary
eVertex

        {
            eEdgeToElement,
            eFaceToElement,
            eEdgeInterior,
            eFaceInterior,
            eBoundary,
            eVertex
        };

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
ePreconditioner
SIZE_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,
            ePreconditioner,
            SIZE_MatrixType
        };

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

        {
            eNoOrientation,
            eFwd,
            eBwd,
            eForwards,
            eBackwards,
            eDir1FwdDir1_Dir2FwdDir2,
            eDir1FwdDir1_Dir2BwdDir2,
            eDir1BwdDir1_Dir2FwdDir2,
            eDir1BwdDir1_Dir2BwdDir2,
            eDir1FwdDir2_Dir2FwdDir1,
            eDir1FwdDir2_Dir2BwdDir1,
            eDir1BwdDir2_Dir2FwdDir1,
            eDir1BwdDir2_Dir2BwdDir1,
            SIZE_Orientation
        };

enum Nektar::StdRegions::VarCoeffType

Enumerator:

eVarCoeffMass
eVarCoeffLaplacian
eVarCoeffWeakDeriv
eVarCoeffD00
eVarCoeffD11
eVarCoeffD22
eVarCoeffD01
eVarCoeffD02
eVarCoeffD12
eVarCoeffPrimative
eVarCoeffVelX
eVarCoeffVelY

        {
            eVarCoeffMass,
            eVarCoeffLaplacian,
            eVarCoeffWeakDeriv,
            eVarCoeffD00,
            eVarCoeffD11,
            eVarCoeffD22,
            eVarCoeffD01,
            eVarCoeffD02,
            eVarCoeffD12,
            eVarCoeffPrimative,
            eVarCoeffVelX,
            eVarCoeffVelY
        };

---

Function Documentation

template<class InputIterator , class EqualityComparable >

InputIterator Nektar::StdRegions::find	(	InputIterator	first,
		InputIterator	last,
		InputIterator	startingpoint,
		const EqualityComparable &	value
	)

Referenced by Nektar::LibUtilities::ExpressionEvaluator::AddConstant(), Nektar::LibUtilities::ExpressionEvaluator::AddConstants(), Nektar::SpatialDomains::MeshGraph::GetCompositeList(), Nektar::LibUtilities::ExpressionEvaluator::GetConstant(), Nektar::LibUtilities::AnalyticExpressionEvaluator::GetConstant(), Nektar::SpatialDomains::VertexComponent::IsElmtConnected(), Nektar::Utilities::Face::operator==(), Nektar::SpatialDomains::Domain::Read(), Nektar::SpatialDomains::BoundaryConditions::ReadBoundaryConditions(), Nektar::SpatialDomains::MeshGraph::ReadCurves(), Nektar::SpatialDomains::MeshGraph::ReadExpansions(), Nektar::LibUtilities::SessionReader::ReadVariables(), Nektar::SpatialDomains::TriGeom::v_IsElmtConnected(), Nektar::SpatialDomains::SegGeom::v_IsElmtConnected(), Nektar::SpatialDomains::QuadGeom::v_IsElmtConnected(), and Nektar::SpatialDomains::Geometry3D::v_IsElmtConnected().

        {
            InputIterator val;

            if(startingpoint == first)
            {
                val = find(first,last,value);
            }
            else
            {
                val = find(startingpoint,last,value);
                if(val == last)
                {
                    val = find(first,startingpoint,value);
                    if(val == startingpoint)
                    {
                        val = last;
                    }
                }
            }
            return val;
        }

template<typename T >

NekVector< T > Nektar::StdRegions::GetColumn	(	const NekMatrix< T > &	matA,
		int	n
	)

int Nektar::StdRegions::GetDegree

(

int

nBasisFunctions

)

NekVector< NekDouble > Nektar::StdRegions::GetE	(	int	rows,
		int	n
	)

NekVector< NekDouble > Nektar::StdRegions::GetIntegralOfMonomialVandermonde

(

int

degree

)

NekMatrix< NekDouble > Nektar::StdRegions::GetMonomialVandermonde	(	const NekVector< NekDouble > &	x,
		const NekVector< NekDouble > &	y,
		int	degree
	)

NekMatrix< NekDouble > Nektar::StdRegions::GetMonomialVandermonde	(	const NekVector< NekDouble > &	x,
		const NekVector< NekDouble > &	y,
		const NekVector< NekDouble > &	z,
		int	degree
	)

NekMatrix< NekDouble > Nektar::StdRegions::GetMonomialVandermonde	(	const NekVector< NekDouble > &	x,
		const NekVector< NekDouble > &	y,
		const NekVector< NekDouble > &	z
	)

NekMatrix< NekDouble > Nektar::StdRegions::GetMonomialVandermonde	(	const NekVector< NekDouble > &	x,
		const NekVector< NekDouble > &	y
	)

int Nektar::StdRegions::GetSize

(

const ConstArray< OneD, NekDouble > &

x

)

Referenced by ToVector().

        {
            return x.num_elements();
        }

int Nektar::StdRegions::GetSize

(

const Array< OneD, const NekDouble > &

x

)

Referenced by Nektar::NekMatrix< DataType, StandardMatrixTag >::CalculateIndex().

int Nektar::StdRegions::GetSize

(

const NekVector< NekDouble > &

x

)

int Nektar::StdRegions::GetTetDegree

(

int

nBasisFunc

)

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

        {
            double eq = pow( 81.0 * nBasisFunc + 3.0 * sqrt(-3.0 + 729.0 * nBasisFunc * nBasisFunc), 1.0/3.0);
            int degree = int(MakeRound(eq/3.0 + 1.0/eq - 1.0)) - 1;

            ASSERTL1( GetTetNumPoints(degree) == nBasisFunc, "The number of points defines an expansion of fractional degree, which is not supported." );
            return degree;
        }

int Nektar::StdRegions::GetTetNumPoints

(

int

degree

)

Referenced by GetTetDegree().

        {
            return (degree+1) * (degree+2) * (degree+3) / 6;
        }

NekMatrix< NekDouble > Nektar::StdRegions::GetTetXDerivativeOfMonomialVandermonde	(	const NekVector< NekDouble > &	x,
		const NekVector< NekDouble > &	y,
		const NekVector< NekDouble > &	z,
		int	degree
	)

NekMatrix< NekDouble > Nektar::StdRegions::GetTetXDerivativeOfMonomialVandermonde	(	const NekVector< NekDouble > &	x,
		const NekVector< NekDouble > &	y,
		const NekVector< NekDouble > &	z
	)

NekMatrix< NekDouble > Nektar::StdRegions::GetTetYDerivativeOfMonomialVandermonde	(	const NekVector< NekDouble > &	x,
		const NekVector< NekDouble > &	y,
		const NekVector< NekDouble > &	z
	)

NekMatrix< NekDouble > Nektar::StdRegions::GetTetYDerivativeOfMonomialVandermonde	(	const NekVector< NekDouble > &	x,
		const NekVector< NekDouble > &	y,
		const NekVector< NekDouble > &	z,
		int	degree
	)

NekMatrix< NekDouble > Nektar::StdRegions::GetTetZDerivativeOfMonomialVandermonde	(	const NekVector< NekDouble > &	x,
		const NekVector< NekDouble > &	y,
		const NekVector< NekDouble > &	z,
		int	degree
	)

NekMatrix< NekDouble > Nektar::StdRegions::GetTetZDerivativeOfMonomialVandermonde	(	const NekVector< NekDouble > &	x,
		const NekVector< NekDouble > &	y,
		const NekVector< NekDouble > &	z
	)

NekMatrix< NekDouble > Nektar::StdRegions::GetTranspose

(

const NekMatrix< NekDouble > &

matA

)

int Nektar::StdRegions::GetTriNumPoints

(

int

degree

)

        {
            return (degree+1) * (degree+2) / 2;
        }

NekMatrix< NekDouble > Nektar::StdRegions::GetXDerivativeOfMonomialVandermonde	(	const NekVector< NekDouble > &	x,
		const NekVector< NekDouble > &	y,
		int	degree
	)

NekMatrix< NekDouble > Nektar::StdRegions::GetXDerivativeOfMonomialVandermonde	(	const NekVector< NekDouble > &	x,
		const NekVector< NekDouble > &	y
	)

NekMatrix< NekDouble > Nektar::StdRegions::GetYDerivativeOfMonomialVandermonde	(	const NekVector< NekDouble > &	x,
		const NekVector< NekDouble > &	y,
		int	degree
	)

NekMatrix< NekDouble > Nektar::StdRegions::GetYDerivativeOfMonomialVandermonde	(	const NekVector< NekDouble > &	x,
		const NekVector< NekDouble > &	y
	)

NekVector< NekDouble > Nektar::StdRegions::Hadamard	(	const NekVector< NekDouble > &	x,
		const NekVector< NekDouble > &	y
	)

NekMatrix< NekDouble > Nektar::StdRegions::Invert

(

const NekMatrix< NekDouble > &

matA

)

NekDouble Nektar::StdRegions::MakeRound

(

NekDouble

x

)

Referenced by GetTetDegree().

std::string Nektar::StdRegions::MatrixToString	(	const NekMatrix< NekDouble > &	A,
		int	precision,
		double	expSigFigs
	)

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

References Nektar::StdRegions::IndexMapKey::m_indexMapType.

        {   
            if(lhs.m_indexMapType < rhs.m_indexMapType)
            {
                return true;
            }
            
            if(lhs.m_indexMapType > rhs.m_indexMapType)
            {
                return false;
            }
        }

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

References ExpansionTypeDimMap, Nektar::StdRegions::StdMatrixKey::m_base, Nektar::StdRegions::StdMatrixKey::m_expansionType, Nektar::StdRegions::StdMatrixKey::m_factors, Nektar::StdRegions::StdMatrixKey::m_matrixType, Nektar::StdRegions::StdMatrixKey::m_ncoeffs, Nektar::StdRegions::StdMatrixKey::m_nodalPointsType, Nektar::StdRegions::StdMatrixKey::m_varcoeff_hashes, and Nektar::StdRegions::StdMatrixKey::m_varcoeffs.

        {   
            if(lhs.m_matrixType < rhs.m_matrixType)
            {
                return true;
            }
            
            if(lhs.m_matrixType > rhs.m_matrixType)
            {
                return false;
            }
            
            if(lhs.m_ncoeffs < rhs.m_ncoeffs)
            {
                return true;
            }
            
            if(lhs.m_ncoeffs > rhs.m_ncoeffs)
            {
                return false;
            }
            
            for(unsigned int i = 0; i < ExpansionTypeDimMap[lhs.m_expansionType]; ++i)
            {
                if(lhs.m_base[i].get() < rhs.m_base[i].get())
                {
                    return true;
                }
                
                if(lhs.m_base[i].get() > rhs.m_base[i].get())
                {
                    return false;
                }
            }

            if(lhs.m_factors.size() < rhs.m_factors.size())
            {
                return true;
            }
            else if(lhs.m_factors.size() > rhs.m_factors.size())
            {
                return false;
            }
            else 
            {
                ConstFactorMap::const_iterator x, y;
                for(x = lhs.m_factors.begin(), y = rhs.m_factors.begin();
                        x != lhs.m_factors.end(); ++x, ++y)
                {
                    if (x->second < y->second)
                    {
                        return true;
                    }
                    if (x->second > y->second)
                    {
                        return false;
                    }
                }
            }

            if(lhs.m_varcoeffs.size() < rhs.m_varcoeffs.size())
            {
                return true;
            }

            if(lhs.m_varcoeffs.size() > rhs.m_varcoeffs.size())
            {
                return false;
            }

            for (unsigned int i = 0; i < lhs.m_varcoeff_hashes.size(); ++i)
            {
                if(lhs.m_varcoeff_hashes[i] < rhs.m_varcoeff_hashes[i])
                {
                    return true;
                }
                if(lhs.m_varcoeff_hashes[i] > rhs.m_varcoeff_hashes[i])
                {
                    return false;
                }
            }
            
            if(lhs.m_nodalPointsType < rhs.m_nodalPointsType)
            {
                return true;
            }
            
            if(lhs.m_nodalPointsType > rhs.m_nodalPointsType)
            {
                return false;
            }
            
            return false;
        }

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

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

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

References ExpansionTypeDimMap, Nektar::StdRegions::StdMatrixKey::m_base, Nektar::StdRegions::StdMatrixKey::m_expansionType, Nektar::StdRegions::StdMatrixKey::m_factors, Nektar::StdRegions::StdMatrixKey::m_matrixType, Nektar::StdRegions::StdMatrixKey::m_ncoeffs, Nektar::StdRegions::StdMatrixKey::m_nodalPointsType, Nektar::StdRegions::StdMatrixKey::m_varcoeff_hashes, and Nektar::StdRegions::StdMatrixKey::m_varcoeffs.

        {
            if(lhs.m_matrixType != rhs.m_matrixType)
            {
                return false;
            }

            if(lhs.m_ncoeffs != rhs.m_ncoeffs)
            {
                return false;
            }

            for(unsigned int i = 0; i < ExpansionTypeDimMap[lhs.m_expansionType]; ++i)
            {
                if(lhs.m_base[i].get() != rhs.m_base[i].get())
                {
                    return false;
                }
            }

            if(lhs.m_factors.size() != rhs.m_factors.size())
            {
                return false;
            }
            else
            {
                ConstFactorMap::const_iterator x, y;
                for(x = lhs.m_factors.begin(), y = rhs.m_factors.begin();
                        x != lhs.m_factors.end(); ++x, ++y)
                {
                    if (x->second != y->second)
                    {
                        return false;
                    }
                }
            }

            if(lhs.m_nodalPointsType != rhs.m_nodalPointsType)
            {
                return false;
            }

            if(lhs.m_varcoeffs.size() != rhs.m_varcoeffs.size())
            {
                return false;
            }

            for (unsigned int i = 0; i < lhs.m_varcoeff_hashes.size(); ++i)
            {
                if(lhs.m_varcoeff_hashes[i] != rhs.m_varcoeff_hashes[i])
                {
                    return false;
                }
            }

            VarCoeffMap::const_iterator x;
            for (x = lhs.m_varcoeffs.begin(); x != lhs.m_varcoeffs.end(); ++x)
            {
                VarCoeffMap::const_iterator y;
                // Check var coeff is found
                if ((y = rhs.m_varcoeffs.find(x->first)) == rhs.m_varcoeffs.end())
                {
                    return false;
                }

                if (x->second != y->second)
                {
                    return false;
                }
            }
            for (unsigned int i = 0; i < lhs.m_varcoeffs.size(); ++i)
            {
                if(lhs.m_varcoeff_hashes[i] != rhs.m_varcoeff_hashes[i])
                {
                    return false;
                }
            }

            return true;
        }

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

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

        {
            if(lhs.m_indexMapType != rhs.m_indexMapType)
            {
                return false;
            }
            if(lhs.m_expansionType != rhs.m_expansionType)
            {
                return false;
            }
            if(lhs.m_p != rhs.m_p)
            {
                return false;
            }
            if(lhs.m_q != rhs.m_q)
            {
                return false;
            }
            if(lhs.m_r != rhs.m_r)
            {
                return false;
            }
            if(lhs.m_entityID != rhs.m_entityID)
            {
                return false;
            }
            
            if(lhs.m_orientation != rhs.m_orientation)
            {
                return false;
            }

            return true;
        }

NekMatrix< NekDouble > & Nektar::StdRegions::SetColumn	(	NekMatrix< NekDouble > &	matA,
		int	n,
		const NekVector< NekDouble > &	x
	)

Array< OneD, NekDouble > Nektar::StdRegions::ToArray

(

const NekVector< NekDouble > &

x

)

NekVector<NekDouble> Nektar::StdRegions::ToVector

(

const Array< OneD, const NekDouble > &

x

)

NekVector<NekDouble> Nektar::StdRegions::ToVector

(

const ConstArray< OneD, NekDouble > &

x

)

References GetSize().

        {
            return NekVector<NekDouble>( GetSize(x), x.data() );
        }

NekVector< NekDouble > Nektar::StdRegions::VectorPower	(	const NekVector< NekDouble > &	x,
		NekDouble	p
	)

std::string Nektar::StdRegions::VectorToString	(	const NekVector< NekDouble > &	v,
		int	precision,
		double	expSigFigs
	)

---

Variable Documentation

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

Initial value:

 {
            "FactorLambda",
            "FactorTau",
            "FactorTime"
        }

Referenced by Nektar::StdRegions::StdMatrixKey::GetConstFactor().

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

const unsigned int Nektar::StdRegions::ExpansionTypeDimMap[SIZE_ExpansionType]

Initial value:

        {
            0,  
            1,  
            2,  
            2,  
            3,  
            3,  
            3,  
            3,  
        }

Referenced by operator<(), and operator==().

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

Initial value:

        {
            "NoExpansionType",
            "Segment",
            "Triangle",
            "Quadrilateral",
            "Tetrahedron",
            "Pyramid",
            "Prism",
            "Hexahedron",
            "Point"
        }

const int Nektar::StdRegions::g_shapenedges[SIZE_ExpansionType] = {0,1,3,4,6,8,9,12}

define list of number of edges corresponding to each ShapeType

const int Nektar::StdRegions::g_shapenfaces[SIZE_ExpansionType] = {0,0,0,0,4,5,5,6}

define list of number of faces corresponding to each ShapeType

const int Nektar::StdRegions::g_shapenverts[SIZE_ExpansionType] = {0,2,3,4,4,5,6,8}

define list of number of vertices corresponding to each ShapeType

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

Initial value:

        {
            "EdgeToElement",
            "FaceToElement",
            "EdgeInterior",
            "FaceInterior",
            "Boundary",
            "Vertex"
        }

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

ConstFactorMap Nektar::StdRegions::NullConstFactorMap [static]

Referenced by Nektar::StdRegions::StdExpansion::CreateGeneralMatrix(), Nektar::LocalRegions::NodalTriExp::FwdTrans(), Nektar::StdRegions::StdNodalTriExp::ModalToNodal(), Nektar::StdRegions::StdNodalTetExp::ModalToNodal(), Nektar::StdRegions::StdNodalPrismExp::ModalToNodal(), Nektar::StdRegions::StdNodalTriExp::NodalToModal(), Nektar::StdRegions::StdNodalTetExp::NodalToModal(), Nektar::StdRegions::StdNodalPrismExp::NodalToModal(), Nektar::StdRegions::StdNodalTriExp::NodalToModalTranspose(), Nektar::StdRegions::StdNodalTetExp::NodalToModalTranspose(), Nektar::StdRegions::StdNodalPrismExp::NodalToModalTranspose(), Nektar::ADR2DManifold::ODErhs(), Nektar::LocalRegions::Expansion2D::v_AddHDGHelmholtzEdgeTerms(), Nektar::LocalRegions::Expansion2D::v_AddRobinEdgeContribution(), Nektar::LocalRegions::Expansion3D::v_AddRobinMassMatrix(), Nektar::LocalRegions::Expansion2D::v_AddRobinMassMatrix(), Nektar::StdRegions::StdNodalTriExp::v_FwdTrans(), Nektar::StdRegions::StdNodalTetExp::v_FwdTrans(), Nektar::StdRegions::StdNodalPrismExp::v_FwdTrans(), and Nektar::LocalRegions::Expansion2D::v_GenMatrix().

VarCoeffMap Nektar::StdRegions::NullVarCoeffMap [static]

Referenced by Nektar::StdRegions::StdExpansion::CreateGeneralMatrix(), Nektar::LocalRegions::NodalTriExp::FwdTrans(), Nektar::StdRegions::StdNodalTriExp::ModalToNodal(), Nektar::StdRegions::StdNodalTetExp::ModalToNodal(), Nektar::StdRegions::StdNodalPrismExp::ModalToNodal(), Nektar::StdRegions::StdNodalTriExp::NodalToModal(), Nektar::StdRegions::StdNodalTetExp::NodalToModal(), Nektar::StdRegions::StdNodalPrismExp::NodalToModal(), Nektar::StdRegions::StdNodalTriExp::NodalToModalTranspose(), Nektar::StdRegions::StdNodalTetExp::NodalToModalTranspose(), Nektar::StdRegions::StdNodalPrismExp::NodalToModalTranspose(), Nektar::ADR2DManifold::SolveHelmholtz(), Nektar::StdRegions::StdNodalTriExp::v_FwdTrans(), Nektar::StdRegions::StdNodalTetExp::v_FwdTrans(), and Nektar::StdRegions::StdNodalPrismExp::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"
        }

int Nektar::StdRegions::s_matrixcnt = 99 [static]

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

Initial value:

 {
            "VarCoeffMass",
            "VarCoeffLaplacian",
            "VarCoeffWeakDeriv",
            "VarCoeffD00",
            "VarCoeffD11",
            "VarCoeffD22",
            "VarCoeffD01",
            "VarCoeffD02",
            "VarCoeffD12",
            "VarCoeffPrimative",
            "VarCoeffVelX",
            "VarCoeffVelY"
        }

Referenced by Nektar::StdRegions::StdMatrixKey::GetVarCoeff().