Nektar++
Public Member Functions | Protected Member Functions | Private Member Functions | List of all members
Nektar::StdRegions::StdTetExp Class Reference

#include <StdTetExp.h>

Inheritance diagram for Nektar::StdRegions::StdTetExp:
[legend]

Public Member Functions

 StdTetExp ()
 
 StdTetExp (const LibUtilities::BasisKey &Ba, const LibUtilities::BasisKey &Bb, const LibUtilities::BasisKey &Bc)
 
 StdTetExp (const LibUtilities::BasisKey &Ba, const LibUtilities::BasisKey &Bb, const LibUtilities::BasisKey &Bc, NekDouble *coeffs, NekDouble *phys)
 
 StdTetExp (const StdTetExp &T)
 
 ~StdTetExp ()
 
LibUtilities::ShapeType DetShapeType () const
 
NekDouble PhysEvaluate3D (const Array< OneD, const NekDouble > &coords, const Array< OneD, const NekDouble > &physvals)
 Single Point Evaluation. More...
 
- Public Member Functions inherited from Nektar::StdRegions::StdExpansion3D
 StdExpansion3D ()
 
 StdExpansion3D (int numcoeffs, const LibUtilities::BasisKey &Ba, const LibUtilities::BasisKey &Bb, const LibUtilities::BasisKey &Bc)
 
 StdExpansion3D (const StdExpansion3D &T)
 
virtual ~StdExpansion3D ()
 
void PhysTensorDeriv (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray_d1, Array< OneD, NekDouble > &outarray_d2, Array< OneD, NekDouble > &outarray_d3)
 Calculate the 3D derivative in the local tensor/collapsed coordinate at the physical points. More...
 
void BwdTrans_SumFacKernel (const Array< OneD, const NekDouble > &base0, const Array< OneD, const NekDouble > &base1, const Array< OneD, const NekDouble > &base2, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, Array< OneD, NekDouble > &wsp, bool doCheckCollDir0, bool doCheckCollDir1, bool doCheckCollDir2)
 
void IProductWRTBase_SumFacKernel (const Array< OneD, const NekDouble > &base0, const Array< OneD, const NekDouble > &base1, const Array< OneD, const NekDouble > &base2, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, Array< OneD, NekDouble > &wsp, bool doCheckCollDir0, bool doCheckCollDir1, bool doCheckCollDir2)
 
- Public Member Functions inherited from Nektar::StdRegions::StdExpansion
 StdExpansion ()
 Default Constructor. More...
 
 StdExpansion (const int numcoeffs, const int numbases, const LibUtilities::BasisKey &Ba=LibUtilities::NullBasisKey, const LibUtilities::BasisKey &Bb=LibUtilities::NullBasisKey, const LibUtilities::BasisKey &Bc=LibUtilities::NullBasisKey)
 Constructor. More...
 
 StdExpansion (const StdExpansion &T)
 Copy Constructor. More...
 
virtual ~StdExpansion ()
 Destructor. More...
 
int GetNumBases () const
 This function returns the number of 1D bases used in the expansion. More...
 
const Array< OneD, const LibUtilities::BasisSharedPtr > & GetBase () const
 This function gets the shared point to basis. More...
 
const LibUtilities::BasisSharedPtr & GetBasis (int dir) const
 This function gets the shared point to basis in the dir direction. More...
 
int GetNcoeffs (void) const
 This function returns the total number of coefficients used in the expansion. More...
 
int GetTotPoints () const
 This function returns the total number of quadrature points used in the element. More...
 
LibUtilities::BasisType GetBasisType (const int dir) const
 This function returns the type of basis used in the dir direction. More...
 
int GetBasisNumModes (const int dir) const
 This function returns the number of expansion modes in the dir direction. More...
 
int EvalBasisNumModesMax (void) const
 This function returns the maximum number of expansion modes over all local directions. More...
 
LibUtilities::PointsType GetPointsType (const int dir) const
 This function returns the type of quadrature points used in the dir direction. More...
 
int GetNumPoints (const int dir) const
 This function returns the number of quadrature points in the dir direction. More...
 
const Array< OneD, const NekDouble > & GetPoints (const int dir) const
 This function returns a pointer to the array containing the quadrature points in dir direction. More...
 
int GetNverts () const
 This function returns the number of vertices of the expansion domain. More...
 
int GetNedges () const
 This function returns the number of edges of the expansion domain. More...
 
int GetEdgeNcoeffs (const int i) const
 This function returns the number of expansion coefficients belonging to the i-th edge. More...
 
int GetTotalEdgeIntNcoeffs () const
 
int GetEdgeNumPoints (const int i) const
 This function returns the number of quadrature points belonging to the i-th edge. More...
 
int DetCartesianDirOfEdge (const int edge)
 
const LibUtilities::BasisKey DetEdgeBasisKey (const int i) const
 
const LibUtilities::BasisKey DetFaceBasisKey (const int i, const int k) const
 
int GetFaceNumPoints (const int i) const
 This function returns the number of quadrature points belonging to the i-th face. More...
 
int GetFaceNcoeffs (const int i) const
 This function returns the number of expansion coefficients belonging to the i-th face. More...
 
int GetFaceIntNcoeffs (const int i) const
 
int GetTotalFaceIntNcoeffs () const
 
int GetTraceNcoeffs (const int i) const
 This function returns the number of expansion coefficients belonging to the i-th edge/face. More...
 
LibUtilities::PointsKey GetFacePointsKey (const int i, const int j) const
 
int NumBndryCoeffs (void) const
 
int NumDGBndryCoeffs (void) const
 
LibUtilities::BasisType GetEdgeBasisType (const int i) const
 This function returns the type of expansion basis on the i-th edge. More...
 
const LibUtilities::PointsKey GetNodalPointsKey () const
 This function returns the type of expansion Nodal point type if defined. More...
 
int GetNfaces () const
 This function returns the number of faces of the expansion domain. More...
 
int GetNtrace () const
 Returns the number of trace elements connected to this element. More...
 
LibUtilities::ShapeType DetShapeType () const
 This function returns the shape of the expansion domain. More...
 
std::shared_ptr< StdExpansion > GetStdExp (void) const
 
std::shared_ptr< StdExpansion > GetLinStdExp (void) const
 
int GetShapeDimension () const
 
bool IsBoundaryInteriorExpansion ()
 
bool IsNodalNonTensorialExp ()
 
void BwdTrans (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 This function performs the Backward transformation from coefficient space to physical space. More...
 
void FwdTrans (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 This function performs the Forward transformation from physical space to coefficient space. More...
 
void FwdTrans_BndConstrained (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
NekDouble Integral (const Array< OneD, const NekDouble > &inarray)
 This function integrates the specified function over the domain. More...
 
void FillMode (const int mode, Array< OneD, NekDouble > &outarray)
 This function fills the array outarray with the mode-th mode of the expansion. More...
 
void IProductWRTBase (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 this function calculates the inner product of a given function f with the different modes of the expansion More...
 
void IProductWRTBase (const Array< OneD, const NekDouble > &base, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, int coll_check)
 
void IProductWRTDerivBase (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
void IProductWRTDirectionalDerivBase (const Array< OneD, const NekDouble > &direction, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
int GetElmtId ()
 Get the element id of this expansion when used in a list by returning value of m_elmt_id. More...
 
void SetElmtId (const int id)
 Set the element id of this expansion when used in a list by returning value of m_elmt_id. More...
 
void GetCoords (Array< OneD, NekDouble > &coords_1, Array< OneD, NekDouble > &coords_2=NullNekDouble1DArray, Array< OneD, NekDouble > &coords_3=NullNekDouble1DArray)
 this function returns the physical coordinates of the quadrature points of the expansion More...
 
void GetCoord (const Array< OneD, const NekDouble > &Lcoord, Array< OneD, NekDouble > &coord)
 given the coordinates of a point of the element in the local collapsed coordinate system, this function calculates the physical coordinates of the point More...
 
DNekMatSharedPtr GetStdMatrix (const StdMatrixKey &mkey)
 
DNekBlkMatSharedPtr GetStdStaticCondMatrix (const StdMatrixKey &mkey)
 
IndexMapValuesSharedPtr GetIndexMap (const IndexMapKey &ikey)
 
const Array< OneD, const NekDouble > & GetPhysNormals (void)
 
void SetPhysNormals (Array< OneD, const NekDouble > &normal)
 
virtual void SetUpPhysNormals (const int edge)
 
void NormVectorIProductWRTBase (const Array< OneD, const NekDouble > &Fx, Array< OneD, NekDouble > &outarray)
 
void NormVectorIProductWRTBase (const Array< OneD, const NekDouble > &Fx, const Array< OneD, NekDouble > &Fy, Array< OneD, NekDouble > &outarray)
 
void NormVectorIProductWRTBase (const Array< OneD, const NekDouble > &Fx, const Array< OneD, const NekDouble > &Fy, const Array< OneD, const NekDouble > &Fz, Array< OneD, NekDouble > &outarray)
 
void NormVectorIProductWRTBase (const Array< OneD, const Array< OneD, NekDouble > > &Fvec, Array< OneD, NekDouble > &outarray)
 
DNekScalBlkMatSharedPtr GetLocStaticCondMatrix (const LocalRegions::MatrixKey &mkey)
 
void DropLocStaticCondMatrix (const LocalRegions::MatrixKey &mkey)
 
StdRegions::Orientation GetForient (int face)
 
StdRegions::Orientation GetEorient (int edge)
 
void SetCoeffsToOrientation (Array< OneD, NekDouble > &coeffs, StdRegions::Orientation dir)
 
void SetCoeffsToOrientation (StdRegions::Orientation dir, Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
int CalcNumberOfCoefficients (const std::vector< unsigned int > &nummodes, int &modes_offset)
 
NekDouble StdPhysEvaluate (const Array< OneD, const NekDouble > &Lcoord, const Array< OneD, const NekDouble > &physvals)
 
int GetCoordim ()
 
void GetBoundaryMap (Array< OneD, unsigned int > &outarray)
 
void GetInteriorMap (Array< OneD, unsigned int > &outarray)
 
int GetVertexMap (const int localVertexId, bool useCoeffPacking=false)
 
void GetEdgeInteriorMap (const int eid, const Orientation edgeOrient, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray)
 
void GetFaceNumModes (const int fid, const Orientation faceOrient, int &numModes0, int &numModes1)
 
void GetFaceInteriorMap (const int fid, const Orientation faceOrient, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray)
 
void GetEdgeToElementMap (const int eid, const Orientation edgeOrient, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray, int P=-1)
 
void GetFaceToElementMap (const int fid, const Orientation faceOrient, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray, int nummodesA=-1, int nummodesB=-1)
 
void GetEdgePhysVals (const int edge, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 Extract the physical values along edge edge from inarray into outarray following the local edge orientation and point distribution defined by defined in EdgeExp. More...
 
void GetEdgePhysVals (const int edge, const std::shared_ptr< StdExpansion > &EdgeExp, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
void GetTracePhysVals (const int edge, const std::shared_ptr< StdExpansion > &EdgeExp, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
void GetVertexPhysVals (const int vertex, const Array< OneD, const NekDouble > &inarray, NekDouble &outarray)
 
void GetEdgeInterpVals (const int edge, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
void GetEdgeQFactors (const int edge, Array< OneD, NekDouble > &outarray)
 Extract the metric factors to compute the contravariant fluxes along edge edge and stores them into outarray following the local edge orientation (i.e. anticlockwise convention). More...
 
void GetFacePhysVals (const int face, const std::shared_ptr< StdExpansion > &FaceExp, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, StdRegions::Orientation orient=eNoOrientation)
 
void GetEdgePhysMap (const int edge, Array< OneD, int > &outarray)
 
void GetFacePhysMap (const int face, Array< OneD, int > &outarray)
 
void MultiplyByQuadratureMetric (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
void MultiplyByStdQuadratureMetric (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
DNekMatSharedPtr CreateGeneralMatrix (const StdMatrixKey &mkey)
 this function generates the mass matrix \(\mathbf{M}[i][j] = \int \phi_i(\mathbf{x}) \phi_j(\mathbf{x}) d\mathbf{x}\) More...
 
void GeneralMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void MassMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void LaplacianMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void ReduceOrderCoeffs (int numMin, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
void SVVLaplacianFilter (Array< OneD, NekDouble > &array, const StdMatrixKey &mkey)
 
void ExponentialFilter (Array< OneD, NekDouble > &array, const NekDouble alpha, const NekDouble exponent, const NekDouble cutoff)
 
void LaplacianMatrixOp (const int k1, const int k2, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void WeakDerivMatrixOp (const int i, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void WeakDirectionalDerivMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void MassLevelCurvatureMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void LinearAdvectionDiffusionReactionMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey, bool addDiffusionTerm=true)
 
void HelmholtzMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
DNekMatSharedPtr GenMatrix (const StdMatrixKey &mkey)
 
void PhysDeriv (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_d0, Array< OneD, NekDouble > &out_d1=NullNekDouble1DArray, Array< OneD, NekDouble > &out_d2=NullNekDouble1DArray)
 
void PhysDeriv (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
void PhysDeriv_s (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_ds)
 
void PhysDeriv_n (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_dn)
 
void PhysDirectionalDeriv (const Array< OneD, const NekDouble > &inarray, const Array< OneD, const NekDouble > &direction, Array< OneD, NekDouble > &outarray)
 
void StdPhysDeriv (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_d0, Array< OneD, NekDouble > &out_d1=NullNekDouble1DArray, Array< OneD, NekDouble > &out_d2=NullNekDouble1DArray)
 
void StdPhysDeriv (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
void AddRobinMassMatrix (const int edgeid, const Array< OneD, const NekDouble > &primCoeffs, DNekMatSharedPtr &inoutmat)
 
void AddRobinEdgeContribution (const int edgeid, const Array< OneD, const NekDouble > &primCoeffs, Array< OneD, NekDouble > &coeffs)
 
NekDouble PhysEvaluate (const Array< OneD, const NekDouble > &coords, const Array< OneD, const NekDouble > &physvals)
 This function evaluates the expansion at a single (arbitrary) point of the domain. More...
 
NekDouble PhysEvaluate (const Array< OneD, DNekMatSharedPtr > &I, const Array< OneD, const NekDouble > &physvals)
 This function evaluates the expansion at a single (arbitrary) point of the domain. More...
 
void LocCoordToLocCollapsed (const Array< OneD, const NekDouble > &xi, Array< OneD, NekDouble > &eta)
 Convert local cartesian coordinate xi into local collapsed coordinates eta. More...
 
virtual int v_GetElmtId ()
 Get the element id of this expansion when used in a list by returning value of m_elmt_id. More...
 
virtual const Array< OneD, const NekDouble > & v_GetPhysNormals (void)
 
virtual void v_SetPhysNormals (Array< OneD, const NekDouble > &normal)
 
virtual void v_SetUpPhysNormals (const int edge)
 
virtual void v_NormVectorIProductWRTBase (const Array< OneD, const NekDouble > &Fx, Array< OneD, NekDouble > &outarray)
 
virtual void v_NormVectorIProductWRTBase (const Array< OneD, const NekDouble > &Fx, const Array< OneD, const NekDouble > &Fy, Array< OneD, NekDouble > &outarray)
 
virtual void v_NormVectorIProductWRTBase (const Array< OneD, const NekDouble > &Fx, const Array< OneD, const NekDouble > &Fy, const Array< OneD, const NekDouble > &Fz, Array< OneD, NekDouble > &outarray)
 
virtual void v_NormVectorIProductWRTBase (const Array< OneD, const Array< OneD, NekDouble > > &Fvec, Array< OneD, NekDouble > &outarray)
 
virtual DNekScalBlkMatSharedPtr v_GetLocStaticCondMatrix (const LocalRegions::MatrixKey &mkey)
 
virtual void v_DropLocStaticCondMatrix (const LocalRegions::MatrixKey &mkey)
 
virtual StdRegions::Orientation v_GetForient (int face)
 
virtual StdRegions::Orientation v_GetEorient (int edge)
 
NekDouble Linf (const Array< OneD, const NekDouble > &phys, const Array< OneD, const NekDouble > &sol=NullNekDouble1DArray)
 Function to evaluate the discrete \( L_\infty\) error \( |\epsilon|_\infty = \max |u - u_{exact}|\) where \( u_{exact}\) is given by the array sol. More...
 
NekDouble L2 (const Array< OneD, const NekDouble > &phys, const Array< OneD, const NekDouble > &sol=NullNekDouble1DArray)
 Function to evaluate the discrete \( L_2\) error, \( | \epsilon |_{2} = \left [ \int^1_{-1} [u - u_{exact}]^2 dx \right]^{1/2} d\xi_1 \) where \( u_{exact}\) is given by the array sol. More...
 
NekDouble H1 (const Array< OneD, const NekDouble > &phys, const Array< OneD, const NekDouble > &sol=NullNekDouble1DArray)
 Function to evaluate the discrete \( H^1\) error, \( | \epsilon |^1_{2} = \left [ \int^1_{-1} [u - u_{exact}]^2 + \nabla(u - u_{exact})\cdot\nabla(u - u_{exact})\cdot dx \right]^{1/2} d\xi_1 \) where \( u_{exact}\) is given by the array sol. More...
 
const NormalVector & GetEdgeNormal (const int edge) const
 
void ComputeEdgeNormal (const int edge)
 
void NegateEdgeNormal (const int edge)
 
bool EdgeNormalNegated (const int edge)
 
void ComputeFaceNormal (const int face)
 
void NegateFaceNormal (const int face)
 
bool FaceNormalNegated (const int face)
 
void ComputeVertexNormal (const int vertex)
 
void NegateVertexNormal (const int vertex)
 
bool VertexNormalNegated (const int vertex)
 
const NormalVector & GetFaceNormal (const int face) const
 
const NormalVector & GetVertexNormal (const int vertex) const
 
const NormalVector & GetSurfaceNormal (const int id) const
 
const LibUtilities::PointsKeyVector GetPointsKeys () const
 
Array< OneD, unsigned int > GetEdgeInverseBoundaryMap (int eid)
 
Array< OneD, unsigned int > GetFaceInverseBoundaryMap (int fid, StdRegions::Orientation faceOrient=eNoOrientation, int P1=-1, int P2=-1)
 
void GetInverseBoundaryMaps (Array< OneD, unsigned int > &vmap, Array< OneD, Array< OneD, unsigned int > > &emap, Array< OneD, Array< OneD, unsigned int > > &fmap)
 
DNekMatSharedPtr BuildInverseTransformationMatrix (const DNekScalMatSharedPtr &m_transformationmatrix)
 
void PhysInterpToSimplexEquiSpaced (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, int npset=-1)
 This function performs an interpolation from the physical space points provided at input into an array of equispaced points which are not the collapsed coordinate. So for a tetrahedron you will only get a tetrahedral number of values. More...
 
void GetSimplexEquiSpacedConnectivity (Array< OneD, int > &conn, bool standard=true)
 This function provides the connectivity of local simplices (triangles or tets) to connect the equispaced data points provided by PhysInterpToSimplexEquiSpaced. More...
 
void EquiSpacedToCoeffs (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 This function performs a projection/interpolation from the equispaced points sometimes used in post-processing onto the coefficient space. More...
 
template<class T >
std::shared_ptr< T > as ()
 
void IProductWRTBase_SumFac (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, bool multiplybyweights=true)
 

Protected Member Functions

virtual void v_PhysDeriv (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_dx, Array< OneD, NekDouble > &out_dy, Array< OneD, NekDouble > &out_dz)
 Calculate the derivative of the physical points. More...
 
virtual void v_PhysDeriv (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
virtual void v_StdPhysDeriv (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_d0, Array< OneD, NekDouble > &out_d1, Array< OneD, NekDouble > &out_d2)
 
virtual void v_StdPhysDeriv (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
virtual void v_BwdTrans (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
virtual void v_BwdTrans_SumFac (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
virtual void v_BwdTrans_SumFacKernel (const Array< OneD, const NekDouble > &base0, const Array< OneD, const NekDouble > &base1, const Array< OneD, const NekDouble > &base2, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, Array< OneD, NekDouble > &wsp, bool doCheckCollDir0, bool doCheckCollDir1, bool doCheckCollDir2)
 
virtual void v_FwdTrans (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
virtual void v_IProductWRTBase (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
virtual void v_IProductWRTBase_MatOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
virtual void v_IProductWRTBase_SumFac (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, bool multiplybyweights=true)
 
virtual void v_IProductWRTBase_SumFacKernel (const Array< OneD, const NekDouble > &base0, const Array< OneD, const NekDouble > &base1, const Array< OneD, const NekDouble > &base2, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, Array< OneD, NekDouble > &wsp, bool doCheckCollDir0, bool doCheckCollDir1, bool doCheckCollDir2)
 
virtual void v_IProductWRTDerivBase (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
virtual void v_IProductWRTDerivBase_MatOp (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
virtual void v_IProductWRTDerivBase_SumFac (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
virtual void v_LocCoordToLocCollapsed (const Array< OneD, const NekDouble > &xi, Array< OneD, NekDouble > &eta)
 
virtual void v_GetCoords (Array< OneD, NekDouble > &coords_x, Array< OneD, NekDouble > &coords_y, Array< OneD, NekDouble > &coords_z)
 
virtual void v_FillMode (const int mode, Array< OneD, NekDouble > &outarray)
 
virtual void v_GetFaceNumModes (const int fid, const Orientation faceOrient, int &numModes0, int &numModes1)
 
virtual int v_GetNverts () const
 
virtual int v_GetNedges () const
 
virtual int v_GetNfaces () const
 
virtual LibUtilities::ShapeType v_DetShapeType () const
 
virtual int v_NumBndryCoeffs () const
 
virtual int v_NumDGBndryCoeffs () const
 
virtual int v_GetEdgeNcoeffs (const int i) const
 
virtual int v_GetTotalEdgeIntNcoeffs () const
 
virtual int v_GetFaceNcoeffs (const int i) const
 
virtual int v_GetFaceIntNcoeffs (const int i) const
 
virtual int v_GetTotalFaceIntNcoeffs () const
 
virtual int v_GetFaceNumPoints (const int i) const
 
virtual LibUtilities::PointsKey v_GetFacePointsKey (const int i, const int j) const
 
virtual int v_CalcNumberOfCoefficients (const std::vector< unsigned int > &nummodes, int &modes_offset)
 
virtual const LibUtilities::BasisKey v_DetFaceBasisKey (const int i, const int k) const
 
virtual LibUtilities::BasisType v_GetEdgeBasisType (const int i) const
 
virtual bool v_IsBoundaryInteriorExpansion ()
 
virtual void v_GetEdgeToElementMap (const int eid, const Orientation edgeOrient, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray, int P)
 
virtual void v_GetFaceToElementMap (const int fid, const Orientation faceOrient, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray, int P=-1, int Q=-1)
 
virtual int v_GetVertexMap (int localVertexId, bool useCoeffPacking=false)
 
virtual void v_GetEdgeInteriorMap (const int eid, const Orientation edgeOrient, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray)
 
virtual void v_GetFaceInteriorMap (const int fid, const Orientation faceOrient, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray)
 
virtual void v_GetInteriorMap (Array< OneD, unsigned int > &outarray)
 
virtual void v_GetBoundaryMap (Array< OneD, unsigned int > &outarray)
 
virtual DNekMatSharedPtr v_GenMatrix (const StdMatrixKey &mkey)
 
virtual DNekMatSharedPtr v_CreateStdMatrix (const StdMatrixKey &mkey)
 
virtual void v_MultiplyByStdQuadratureMetric (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
virtual void v_SVVLaplacianFilter (Array< OneD, NekDouble > &array, const StdMatrixKey &mkey)
 
virtual void v_ReduceOrderCoeffs (int numMin, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
virtual void v_GetSimplexEquiSpacedConnectivity (Array< OneD, int > &conn, bool standard=true)
 
- Protected Member Functions inherited from Nektar::StdRegions::StdExpansion3D
virtual NekDouble v_PhysEvaluate (const Array< OneD, const NekDouble > &coords, const Array< OneD, const NekDouble > &physvals)
 This function evaluates the expansion at a single (arbitrary) point of the domain. More...
 
virtual NekDouble v_PhysEvaluate (const Array< OneD, DNekMatSharedPtr > &I, const Array< OneD, const NekDouble > &physvals)
 
virtual void v_LaplacianMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey)
 
virtual void v_HelmholtzMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey)
 
virtual NekDouble v_Integral (const Array< OneD, const NekDouble > &inarray)
 Integrates the specified function over the domain. More...
 
virtual void v_NegateFaceNormal (const int face)
 
virtual bool v_FaceNormalNegated (const int face)
 
virtual int v_GetTraceNcoeffs (const int i) const
 
- Protected Member Functions inherited from Nektar::StdRegions::StdExpansion
DNekMatSharedPtr CreateStdMatrix (const StdMatrixKey &mkey)
 
DNekBlkMatSharedPtr CreateStdStaticCondMatrix (const StdMatrixKey &mkey)
 Create the static condensation of a matrix when using a boundary interior decomposition. More...
 
IndexMapValuesSharedPtr CreateIndexMap (const IndexMapKey &ikey)
 Create an IndexMap which contains mapping information linking any specific element shape with either its boundaries, edges, faces, verteces, etc. More...
 
void BwdTrans_MatOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
void BwdTrans_SumFac (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
void IProductWRTDerivBase_SumFac (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
void IProductWRTDirectionalDerivBase_SumFac (const Array< OneD, const NekDouble > &direction, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
void GeneralMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void MassMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void LaplacianMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void LaplacianMatrixOp_MatFree_Kernel (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, Array< OneD, NekDouble > &wsp)
 
void LaplacianMatrixOp_MatFree_GenericImpl (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void LaplacianMatrixOp_MatFree (const int k1, const int k2, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void WeakDerivMatrixOp_MatFree (const int i, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void WeakDirectionalDerivMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void MassLevelCurvatureMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void LinearAdvectionDiffusionReactionMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey, bool addDiffusionTerm=true)
 
void HelmholtzMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void HelmholtzMatrixOp_MatFree_GenericImpl (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
virtual void v_SetCoeffsToOrientation (StdRegions::Orientation dir, Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
virtual void v_SetCoeffsToOrientation (Array< OneD, NekDouble > &coeffs, StdRegions::Orientation dir)
 
virtual NekDouble v_StdPhysEvaluate (const Array< OneD, const NekDouble > &Lcoord, const Array< OneD, const NekDouble > &physvals)
 

Private Member Functions

int GetMode (const int i, const int j, const int k)
 Compute the mode number in the expansion for a particular tensorial combination. More...
 

Additional Inherited Members

- Protected Attributes inherited from Nektar::StdRegions::StdExpansion3D
std::map< int, NormalVector > m_faceNormals
 
std::map< int, bool > m_negatedNormals
 
- Protected Attributes inherited from Nektar::StdRegions::StdExpansion
Array< OneD, LibUtilities::BasisSharedPtr > m_base
 
int m_elmt_id
 
int m_ncoeffs
 
LibUtilities::NekManager< StdMatrixKey, DNekMat, StdMatrixKey::opLess > m_stdMatrixManager
 
LibUtilities::NekManager< StdMatrixKey, DNekBlkMat, StdMatrixKey::opLess > m_stdStaticCondMatrixManager
 
LibUtilities::NekManager< IndexMapKey, IndexMapValues, IndexMapKey::opLess > m_IndexMapManager
 

Detailed Description

Definition at line 50 of file StdTetExp.h.

Constructor & Destructor Documentation

◆ StdTetExp() [1/4]

Nektar::StdRegions::StdTetExp::StdTetExp ( )

Definition at line 46 of file StdTetExp.cpp.

47  {
48  }

◆ StdTetExp() [2/4]

Nektar::StdRegions::StdTetExp::StdTetExp ( const LibUtilities::BasisKey &  Ba,
const LibUtilities::BasisKey &  Bb,
const LibUtilities::BasisKey &  Bc 
)

Definition at line 51 of file StdTetExp.cpp.

References ASSERTL0, and Nektar::LibUtilities::BasisKey::GetNumModes().

53  :
54  StdExpansion(LibUtilities::StdTetData::getNumberOfCoefficients(
55  Ba.GetNumModes(),
56  Bb.GetNumModes(),
57  Bc.GetNumModes()),
58  3, Ba, Bb, Bc),
59  StdExpansion3D(LibUtilities::StdTetData::getNumberOfCoefficients(
60  Ba.GetNumModes(),
61  Bb.GetNumModes(),
62  Bc.GetNumModes()),
63  Ba, Bb, Bc)
64  {
65  ASSERTL0(Ba.GetNumModes() <= Bb.GetNumModes(),
66  "order in 'a' direction is higher than order "
67  "in 'b' direction");
68  ASSERTL0(Ba.GetNumModes() <= Bc.GetNumModes(),
69  "order in 'a' direction is higher than order "
70  "in 'c' direction");
71  ASSERTL0(Bb.GetNumModes() <= Bc.GetNumModes(),
72  "order in 'b' direction is higher than order "
73  "in 'c' direction");
74  }
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:216
Nektar::LibUtilities::StdTetData::getNumberOfCoefficients
int getNumberOfCoefficients(int Na, int Nb, int Nc)
Definition: ShapeType.hpp:194
Nektar::StdRegions::StdExpansion::StdExpansion
StdExpansion()
Default Constructor.
Definition: StdExpansion.cpp:45

◆ StdTetExp() [3/4]

Nektar::StdRegions::StdTetExp::StdTetExp ( const LibUtilities::BasisKey &  Ba,
const LibUtilities::BasisKey &  Bb,
const LibUtilities::BasisKey &  Bc,
NekDouble *  coeffs,
NekDouble *  phys 
)

◆ StdTetExp() [4/4]

Nektar::StdRegions::StdTetExp::StdTetExp ( const StdTetExp &  T)

Definition at line 76 of file StdTetExp.cpp.

76  :
77  StdExpansion(T),
78  StdExpansion3D(T)
79  {
80  }
Nektar::StdRegions::StdExpansion::StdExpansion
StdExpansion()
Default Constructor.
Definition: StdExpansion.cpp:45

◆ ~StdTetExp()

Nektar::StdRegions::StdTetExp::~StdTetExp ( )

Definition at line 83 of file StdTetExp.cpp.

84  {
85  }

Member Function Documentation

◆ DetShapeType()

LibUtilities::ShapeType Nektar::StdRegions::StdTetExp::DetShapeType ( ) const
inline

Definition at line 69 of file StdTetExp.h.

References Nektar::LibUtilities::eTetrahedron, GetMode(), class_topology::P, PhysEvaluate3D(), STD_REGIONS_EXPORT, v_BwdTrans(), v_BwdTrans_SumFac(), v_BwdTrans_SumFacKernel(), v_CalcNumberOfCoefficients(), v_CreateStdMatrix(), v_DetFaceBasisKey(), v_DetShapeType(), v_FillMode(), v_FwdTrans(), v_GenMatrix(), v_GetBoundaryMap(), v_GetCoords(), v_GetEdgeBasisType(), v_GetEdgeInteriorMap(), v_GetEdgeNcoeffs(), v_GetEdgeToElementMap(), v_GetFaceInteriorMap(), v_GetFaceIntNcoeffs(), v_GetFaceNcoeffs(), v_GetFaceNumModes(), v_GetFaceNumPoints(), v_GetFacePointsKey(), v_GetFaceToElementMap(), v_GetInteriorMap(), v_GetNedges(), v_GetNfaces(), v_GetNverts(), v_GetSimplexEquiSpacedConnectivity(), v_GetTotalEdgeIntNcoeffs(), v_GetTotalFaceIntNcoeffs(), v_GetVertexMap(), v_IProductWRTBase(), v_IProductWRTBase_MatOp(), v_IProductWRTBase_SumFac(), v_IProductWRTBase_SumFacKernel(), v_IProductWRTDerivBase(), v_IProductWRTDerivBase_MatOp(), v_IProductWRTDerivBase_SumFac(), v_IsBoundaryInteriorExpansion(), v_LocCoordToLocCollapsed(), v_MultiplyByStdQuadratureMetric(), v_NumBndryCoeffs(), v_NumDGBndryCoeffs(), v_PhysDeriv(), v_ReduceOrderCoeffs(), v_StdPhysDeriv(), and v_SVVLaplacianFilter().

Referenced by Nektar::LocalRegions::TetExp::CreateMatrix(), Nektar::StdRegions::StdNodalTetExp::ModalToNodal(), Nektar::StdRegions::StdNodalTetExp::NodalToModal(), Nektar::StdRegions::StdNodalTetExp::NodalToModalTranspose(), v_DetShapeType(), Nektar::LocalRegions::TetExp::v_FwdTrans(), Nektar::StdRegions::StdNodalTetExp::v_FwdTrans(), v_FwdTrans(), v_IProductWRTBase_MatOp(), and v_IProductWRTDerivBase_MatOp().

70  {
71  return LibUtilities::eTetrahedron;
72  }

◆ GetMode()

int Nektar::StdRegions::StdTetExp::GetMode ( const int  I,
const int  J,
const int  K 
)
private

Compute the mode number in the expansion for a particular tensorial combination.

Modes are numbered with the r index travelling fastest, followed by q and then p, and each q-r plane is of size (Q+1)*(Q+2)/2+max(0,R-Q-p)*Q. For example, when P=2, Q=3 and R=4 the indexing inside each q-r plane (with r increasing upwards and q to the right) is:

p = 0: p = 1: p = 2:

4 3 8 17 2 7 11 16 20 26 1 6 10 13 15 19 22 25 28 0 5 9 12 14 18 21 23 24 27 29

Note that in this element, we must have that \( P \leq Q \leq R\).

Definition at line 1981 of file StdTetExp.cpp.

References Nektar::StdRegions::StdExpansion::m_base.

Referenced by DetShapeType(), v_GetBoundaryMap(), v_GetEdgeInteriorMap(), v_GetFaceInteriorMap(), v_GetFaceToElementMap(), v_GetInteriorMap(), and v_GetVertexMap().

1982  {
1983  const int Q = m_base[1]->GetNumModes();
1984  const int R = m_base[2]->GetNumModes();
1985 
1986  int i,j,q_hat,k_hat;
1987  int cnt = 0;
1988 
1989  // Traverse to q-r plane number I
1990  for (i = 0; i < I; ++i)
1991  {
1992  // Size of triangle part
1993  q_hat = min(Q,R-i);
1994  // Size of rectangle part
1995  k_hat = max(R-Q-i,0);
1996  cnt += q_hat*(q_hat+1)/2 + k_hat*Q;
1997  }
1998 
1999  // Traverse to q column J
2000  q_hat = R-I;
2001  for (j = 0; j < J; ++j)
2002  {
2003  cnt += q_hat;
2004  q_hat--;
2005  }
2006 
2007  // Traverse up stacks to K
2008  cnt += K;
2009 
2010  return cnt;
2011  }
Nektar::StdRegions::StdExpansion::m_base
Array< OneD, LibUtilities::BasisSharedPtr > m_base
Definition: StdExpansion.h:1429

◆ PhysEvaluate3D()

NekDouble Nektar::StdRegions::StdTetExp::PhysEvaluate3D ( const Array< OneD, const NekDouble > &  coords,
const Array< OneD, const NekDouble > &  physvals 
)

Single Point Evaluation.

Referenced by DetShapeType().

◆ v_BwdTrans()

void Nektar::StdRegions::StdTetExp::v_BwdTrans ( const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray 
)
protectedvirtual
Note
'r' (base[2]) runs fastest in this element

\( u^{\delta} (\xi_{1i}, \xi_{2j}, \xi_{3k}) = \sum_{m(pqr)} \hat u_{pqr} \phi_{pqr} (\xi_{1i}, \xi_{2j}, \xi_{3k})\)

Backward transformation is three dimensional tensorial expansion \( u (\xi_{1i}, \xi_{2j}, \xi_{3k}) = \sum_{p=0}^{Q_x} \psi_p^a (\xi_{1i}) \lbrace { \sum_{q=0}^{Q_y} \psi_{pq}^b (\xi_{2j}) \lbrace { \sum_{r=0}^{Q_z} \hat u_{pqr} \psi_{pqr}^c (\xi_{3k}) \rbrace} \rbrace}. \) And sumfactorizing step of the form is as:\

\( f_{pq} (\xi_{3k}) = \sum_{r=0}^{Q_z} \hat u_{pqr} \psi_{pqr}^c (\xi_{3k}),\\ g_{p} (\xi_{2j}, \xi_{3k}) = \sum_{r=0}^{Q_y} \psi_{pq}^b (\xi_{2j}) f_{pq} (\xi_{3k}),\\ u(\xi_{1i}, \xi_{2j}, \xi_{3k}) = \sum_{p=0}^{Q_x} \psi_{p}^a (\xi_{1i}) g_{p} (\xi_{2j}, \xi_{3k}). \)

Implements Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::StdRegions::StdNodalTetExp.

Definition at line 294 of file StdTetExp.cpp.

References ASSERTL1, Nektar::LibUtilities::eModified_B, Nektar::LibUtilities::eModified_C, Nektar::LibUtilities::eOrtho_B, Nektar::LibUtilities::eOrtho_C, Nektar::StdRegions::StdExpansion::GetBasisType(), Nektar::StdRegions::StdExpansion::GetNumPoints(), Nektar::StdRegions::StdExpansion::m_base, v_BwdTrans_SumFac(), and Vmath::Vcopy().

Referenced by DetShapeType(), and v_FillMode().

297  {
298  ASSERTL1((m_base[1]->GetBasisType() != LibUtilities::eOrtho_B) ||
299  (m_base[1]->GetBasisType() != LibUtilities::eModified_B),
300  "Basis[1] is not a general tensor type");
301 
302  ASSERTL1((m_base[2]->GetBasisType() != LibUtilities::eOrtho_C) ||
303  (m_base[2]->GetBasisType() != LibUtilities::eModified_C),
304  "Basis[2] is not a general tensor type");
305 
306  if(m_base[0]->Collocation() && m_base[1]->Collocation()
307  && m_base[2]->Collocation())
308  {
309  Vmath::Vcopy(m_base[0]->GetNumPoints()
310  * m_base[1]->GetNumPoints()
311  * m_base[2]->GetNumPoints(),
312  inarray, 1, outarray, 1);
313  }
314  else
315  {
316  StdTetExp::v_BwdTrans_SumFac(inarray,outarray);
317  }
318  }
Nektar::LibUtilities::eModified_C
Principle Modified Functions .
Definition: BasisType.h:50
Nektar::StdRegions::StdExpansion::GetNumPoints
int GetNumPoints(const int dir) const
This function returns the number of quadrature points in the dir direction.
Definition: StdExpansion.h:228
Nektar::LibUtilities::eOrtho_B
Principle Orthogonal Functions .
Definition: BasisType.h:46
Nektar::StdRegions::StdTetExp::v_BwdTrans_SumFac
virtual void v_BwdTrans_SumFac(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
Definition: StdTetExp.cpp:324
Nektar::LibUtilities::eModified_B
Principle Modified Functions .
Definition: BasisType.h:49
Nektar::LibUtilities::eOrtho_C
Principle Orthogonal Functions .
Definition: BasisType.h:47
Nektar::StdRegions::StdExpansion::GetBasisType
LibUtilities::BasisType GetBasisType(const int dir) const
This function returns the type of basis used in the dir direction.
Definition: StdExpansion.h:164
ASSERTL1
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:250
Nektar::StdRegions::StdExpansion::m_base
Array< OneD, LibUtilities::BasisSharedPtr > m_base
Definition: StdExpansion.h:1429
Vmath::Vcopy
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1064

◆ v_BwdTrans_SumFac()

void Nektar::StdRegions::StdTetExp::v_BwdTrans_SumFac ( const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray 
)
protectedvirtual

Sum-factorisation implementation of the BwdTrans operation.

Reimplemented from Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::StdRegions::StdNodalTetExp.

Definition at line 324 of file StdTetExp.cpp.

References Nektar::StdRegions::StdExpansion3D::BwdTrans_SumFacKernel(), and Nektar::StdRegions::StdExpansion::m_base.

Referenced by DetShapeType(), v_BwdTrans(), and Nektar::StdRegions::StdNodalTetExp::v_BwdTrans_SumFac().

327  {
328  int nquad1 = m_base[1]->GetNumPoints();
329  int nquad2 = m_base[2]->GetNumPoints();
330  int order0 = m_base[0]->GetNumModes();
331  int order1 = m_base[1]->GetNumModes();
332 
333  Array<OneD, NekDouble> wsp(nquad2*order0*(2*order1-order0+1)/2+
334  nquad2*nquad1*order0);
335 
336  BwdTrans_SumFacKernel(m_base[0]->GetBdata(),
337  m_base[1]->GetBdata(),
338  m_base[2]->GetBdata(),
339  inarray,outarray,wsp,
340  true,true,true);
341  }
Nektar::StdRegions::StdExpansion3D::BwdTrans_SumFacKernel
void BwdTrans_SumFacKernel(const Array< OneD, const NekDouble > &base0, const Array< OneD, const NekDouble > &base1, const Array< OneD, const NekDouble > &base2, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, Array< OneD, NekDouble > &wsp, bool doCheckCollDir0, bool doCheckCollDir1, bool doCheckCollDir2)
Definition: StdExpansion3D.cpp:114
Nektar::StdRegions::StdExpansion::m_base
Array< OneD, LibUtilities::BasisSharedPtr > m_base
Definition: StdExpansion.h:1429

◆ v_BwdTrans_SumFacKernel()

void Nektar::StdRegions::StdTetExp::v_BwdTrans_SumFacKernel ( const Array< OneD, const NekDouble > &  base0,
const Array< OneD, const NekDouble > &  base1,
const Array< OneD, const NekDouble > &  base2,
const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray,
Array< OneD, NekDouble > &  wsp,
bool  doCheckCollDir0,
bool  doCheckCollDir1,
bool  doCheckCollDir2 
)
protectedvirtual
Parameters
base0x-dirn basis matrix
base1y-dirn basis matrix
base2z-dirn basis matrix
inarrayInput vector of modes.
outarrayOutput vector of physical space data.
wspWorkspace of size Q_x*P_z*(P_y+Q_y)
doCheckCollDir0Check for collocation of basis.
doCheckCollDir1Check for collocation of basis.
doCheckCollDir2Check for collocation of basis.
Todo:
Account for some directions being collocated. See StdQuadExp as an example.

Implements Nektar::StdRegions::StdExpansion3D.

Definition at line 357 of file StdTetExp.cpp.

References Blas::Daxpy(), Blas::Dgemm(), Blas::Dgemv(), Nektar::LibUtilities::eModified_A, Nektar::StdRegions::StdExpansion::GetBasisType(), and Nektar::StdRegions::StdExpansion::m_base.

Referenced by DetShapeType().

367  {
368  boost::ignore_unused(doCheckCollDir0, doCheckCollDir1,
369  doCheckCollDir2);
370 
371  int nquad0 = m_base[0]->GetNumPoints();
372  int nquad1 = m_base[1]->GetNumPoints();
373  int nquad2 = m_base[2]->GetNumPoints();
374 
375  int order0 = m_base[0]->GetNumModes();
376  int order1 = m_base[1]->GetNumModes();
377  int order2 = m_base[2]->GetNumModes();
378 
379  Array<OneD, NekDouble > tmp = wsp;
380  Array<OneD, NekDouble > tmp1 = tmp + nquad2*order0*(2*order1-order0+1)/2;
381 
382  int i, j, mode, mode1, cnt;
383 
384  // Perform summation over '2' direction
385  mode = mode1 = cnt = 0;
386  for(i = 0; i < order0; ++i)
387  {
388  for(j = 0; j < order1-i; ++j, ++cnt)
389  {
390  Blas::Dgemv('N', nquad2, order2-i-j,
391  1.0, base2.get()+mode*nquad2, nquad2,
392  inarray.get()+mode1, 1,
393  0.0, tmp.get()+cnt*nquad2, 1);
394  mode += order2-i-j;
395  mode1 += order2-i-j;
396  }
397  //increment mode in case order1!=order2
398  for(j = order1-i; j < order2-i; ++j)
399  {
400  mode += order2-i-j;
401  }
402  }
403 
404  // fix for modified basis by adding split of top singular
405  // vertex mode - currently (1+c)/2 x (1-b)/2 x (1-a)/2
406  // component is evaluated
407  if(m_base[0]->GetBasisType() == LibUtilities::eModified_A)
408  {
409  // top singular vertex - (1+c)/2 x (1+b)/2 x (1-a)/2 component
410  Blas::Daxpy(nquad2,inarray[1],base2.get()+nquad2,1,
411  &tmp[0]+nquad2,1);
412 
413  // top singular vertex - (1+c)/2 x (1-b)/2 x (1+a)/2 component
414  Blas::Daxpy(nquad2,inarray[1],base2.get()+nquad2,1,
415  &tmp[0]+order1*nquad2,1);
416  }
417 
418  // Perform summation over '1' direction
419  mode = 0;
420  for(i = 0; i < order0; ++i)
421  {
422  Blas::Dgemm('N', 'T', nquad1, nquad2, order1-i,
423  1.0, base1.get()+mode*nquad1, nquad1,
424  tmp.get()+mode*nquad2, nquad2,
425  0.0, tmp1.get()+i*nquad1*nquad2, nquad1);
426  mode += order1-i;
427  }
428 
429  // fix for modified basis by adding additional split of
430  // top and base singular vertex modes as well as singular
431  // edge
432  if(m_base[0]->GetBasisType() == LibUtilities::eModified_A)
433  {
434  // use tmp to sort out singular vertices and
435  // singular edge components with (1+b)/2 (1+a)/2 form
436  for(i = 0; i < nquad2; ++i)
437  {
438  Blas::Daxpy(nquad1,tmp[nquad2+i], base1.get()+nquad1,1,
439  &tmp1[nquad1*nquad2]+i*nquad1,1);
440  }
441  }
442 
443  // Perform summation over '0' direction
444  Blas::Dgemm('N', 'T', nquad0, nquad1*nquad2, order0,
445  1.0, base0.get(), nquad0,
446  tmp1.get(), nquad1*nquad2,
447  0.0, outarray.get(), nquad0);
448  }
Nektar::LibUtilities::eModified_A
Principle Modified Functions .
Definition: BasisType.h:48
Blas::Dgemm
static void Dgemm(const char &transa, const char &transb, const int &m, const int &n, const int &k, const double &alpha, const double *a, const int &lda, const double *b, const int &ldb, const double &beta, double *c, const int &ldc)
BLAS level 3: Matrix-matrix multiply C = A x B where A[m x n], B[n x k], C[m x k].
Definition: Blas.hpp:213
Blas::Dgemv
static void Dgemv(const char &trans, const int &m, const int &n, const double &alpha, const double *a, const int &lda, const double *x, const int &incx, const double &beta, double *y, const int &incy)
BLAS level 2: Matrix vector multiply y = A x where A[m x n].
Definition: Blas.hpp:168
Nektar::StdRegions::StdExpansion::GetBasisType
LibUtilities::BasisType GetBasisType(const int dir) const
This function returns the type of basis used in the dir direction.
Definition: StdExpansion.h:164
Nektar::StdRegions::StdExpansion::m_base
Array< OneD, LibUtilities::BasisSharedPtr > m_base
Definition: StdExpansion.h:1429
Blas::Daxpy
static void Daxpy(const int &n, const double &alpha, const double *x, const int &incx, const double *y, const int &incy)
BLAS level 1: y = alpha x plus y.
Definition: Blas.hpp:110

◆ v_CalcNumberOfCoefficients()

int Nektar::StdRegions::StdTetExp::v_CalcNumberOfCoefficients ( const std::vector< unsigned int > &  nummodes,
int &  modes_offset 
)
protectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 1144 of file StdTetExp.cpp.

References Nektar::LibUtilities::StdTetData::getNumberOfCoefficients().

Referenced by DetShapeType().

1147  {
1148  int nmodes = LibUtilities::StdTetData::getNumberOfCoefficients(
1149  nummodes[modes_offset],
1150  nummodes[modes_offset+1],
1151  nummodes[modes_offset+2]);
1152  modes_offset += 3;
1153 
1154  return nmodes;
1155  }
Nektar::LibUtilities::StdTetData::getNumberOfCoefficients
int getNumberOfCoefficients(int Na, int Nb, int Nc)
Definition: ShapeType.hpp:194

◆ v_CreateStdMatrix()

DNekMatSharedPtr Nektar::StdRegions::StdTetExp::v_CreateStdMatrix ( const StdMatrixKey &  mkey)
protectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::LocalRegions::TetExp, and Nektar::StdRegions::StdNodalTetExp.

Definition at line 1950 of file StdTetExp.cpp.

References v_GenMatrix().

Referenced by DetShapeType().

1951  {
1952  return v_GenMatrix(mkey);
1953  }
Nektar::StdRegions::StdTetExp::v_GenMatrix
virtual DNekMatSharedPtr v_GenMatrix(const StdMatrixKey &mkey)
Definition: StdTetExp.cpp:1862

◆ v_DetFaceBasisKey()

const LibUtilities::BasisKey Nektar::StdRegions::StdTetExp::v_DetFaceBasisKey ( const int  i,
const int  k 
) const
protectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 1157 of file StdTetExp.cpp.

References ASSERTL2, Nektar::StdRegions::EvaluateTriFaceBasisKey(), Nektar::StdRegions::StdExpansion::GetBasisType(), Nektar::StdRegions::StdExpansion::GetNumPoints(), Nektar::StdRegions::StdExpansion::m_base, and Nektar::LibUtilities::NullBasisKey().

Referenced by DetShapeType().

1159  {
1160  ASSERTL2(i >= 0 && i <= 4, "face id is out of range");
1161  ASSERTL2(k == 0 || k == 1, "face direction out of range");
1162 
1163  int dir = k;
1164  switch(i)
1165  {
1166  case 0:
1167  dir = k;
1168  break;
1169  case 1:
1170  dir = 2*k;
1171  break;
1172  case 2:
1173  case 3:
1174  dir = k+1;
1175  break;
1176  }
1177 
1178  return EvaluateTriFaceBasisKey(k,
1179  m_base[dir]->GetBasisType(),
1180  m_base[dir]->GetNumPoints(),
1181  m_base[dir]->GetNumModes());
1182 
1183  // Should not get here.
1184  return LibUtilities::NullBasisKey;
1185  }
Nektar::StdRegions::StdExpansion::GetNumPoints
int GetNumPoints(const int dir) const
This function returns the number of quadrature points in the dir direction.
Definition: StdExpansion.h:228
Nektar::StdRegions::EvaluateTriFaceBasisKey
LibUtilities::BasisKey EvaluateTriFaceBasisKey(const int facedir, const LibUtilities::BasisType faceDirBasisType, const int numpoints, const int nummodes)
Definition: StdExpansion3D.cpp:409
ASSERTL2
#define ASSERTL2(condition, msg)
Assert Level 2 – Debugging which is used FULLDEBUG compilation mode. This level assert is designed t...
Definition: ErrorUtil.hpp:274
Nektar::StdRegions::StdExpansion::GetBasisType
LibUtilities::BasisType GetBasisType(const int dir) const
This function returns the type of basis used in the dir direction.
Definition: StdExpansion.h:164
Nektar::LibUtilities::NullBasisKey
static const BasisKey NullBasisKey(eNoBasisType, 0, NullPointsKey)
Defines a null basis with no type or points.
Nektar::StdRegions::StdExpansion::m_base
Array< OneD, LibUtilities::BasisSharedPtr > m_base
Definition: StdExpansion.h:1429

◆ v_DetShapeType()

LibUtilities::ShapeType Nektar::StdRegions::StdTetExp::v_DetShapeType ( ) const
protectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::LocalRegions::TetExp.

Definition at line 968 of file StdTetExp.cpp.

References DetShapeType().

Referenced by DetShapeType().

969  {
970  return DetShapeType();
971  }
Nektar::StdRegions::StdTetExp::DetShapeType
LibUtilities::ShapeType DetShapeType() const
Definition: StdTetExp.h:69

◆ v_FillMode()

void Nektar::StdRegions::StdTetExp::v_FillMode ( const int  mode,
Array< OneD, NekDouble > &  outarray 
)
protectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::StdRegions::StdNodalTetExp.

Definition at line 905 of file StdTetExp.cpp.

References Nektar::StdRegions::StdExpansion::m_ncoeffs, and v_BwdTrans().

Referenced by DetShapeType(), and Nektar::StdRegions::StdNodalTetExp::GenNBasisTransMatrix().

908  {
909  Array<OneD, NekDouble> tmp(m_ncoeffs,0.0);
910  tmp[mode] = 1.0;
911  StdTetExp::v_BwdTrans(tmp, outarray);
912  }
Nektar::StdRegions::StdTetExp::v_BwdTrans
virtual void v_BwdTrans(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
Definition: StdTetExp.cpp:294

◆ v_FwdTrans()

void Nektar::StdRegions::StdTetExp::v_FwdTrans ( const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray 
)
protectedvirtual
Parameters
inarrayarray of physical quadrature points to be transformed.
outarrayupdated array of expansion coefficients.

Implements Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::StdRegions::StdNodalTetExp, and Nektar::LocalRegions::TetExp.

Definition at line 456 of file StdTetExp.cpp.

References DetShapeType(), Nektar::StdRegions::eInvMass, Nektar::eWrapper, Nektar::StdRegions::StdExpansion::GetStdMatrix(), Nektar::StdRegions::StdExpansion::m_ncoeffs, and v_IProductWRTBase().

Referenced by DetShapeType().

458  { //int numMax = nmodes0;
459  v_IProductWRTBase(inarray,outarray);
460 
461  // get Mass matrix inverse
462  StdMatrixKey masskey(eInvMass,DetShapeType(),*this);
463  DNekMatSharedPtr matsys = GetStdMatrix(masskey);
464 
465  // copy inarray in case inarray == outarray
466  DNekVec in (m_ncoeffs, outarray);
467  DNekVec out(m_ncoeffs, outarray, eWrapper);
468 
469  out = (*matsys)*in;
470  }
Nektar::StdRegions::StdTetExp::DetShapeType
LibUtilities::ShapeType DetShapeType() const
Definition: StdTetExp.h:69
Nektar::DNekMatSharedPtr
std::shared_ptr< DNekMat > DNekMatSharedPtr
Definition: NekTypeDefs.hpp:69
Nektar::StdRegions::StdExpansion::GetStdMatrix
DNekMatSharedPtr GetStdMatrix(const StdMatrixKey &mkey)
Definition: StdExpansion.h:714
Nektar::DNekVec
NekVector< NekDouble > DNekVec
Definition: NekTypeDefs.hpp:48
Nektar::StdRegions::StdTetExp::v_IProductWRTBase
virtual void v_IProductWRTBase(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
Definition: StdTetExp.cpp:507

◆ v_GenMatrix()

DNekMatSharedPtr Nektar::StdRegions::StdTetExp::v_GenMatrix ( const StdMatrixKey &  mkey)
protectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::LocalRegions::TetExp, and Nektar::StdRegions::StdNodalTetExp.

Definition at line 1862 of file StdTetExp.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::StdRegions::StdMatrixKey::ConstFactorExists(), Nektar::StdRegions::StdExpansion::CreateGeneralMatrix(), Nektar::StdRegions::eFactorConst, Nektar::StdRegions::ePhysInterpToEquiSpaced, Nektar::StdRegions::StdMatrixKey::GetConstFactor(), Nektar::StdRegions::StdMatrixKey::GetMatrixType(), Nektar::LibUtilities::StdTetData::getNumberOfCoefficients(), Nektar::StdRegions::StdExpansion::LocCoordToLocCollapsed(), Nektar::StdRegions::StdExpansion::m_base, Vmath::Smul(), and Vmath::Vcopy().

Referenced by DetShapeType(), and v_CreateStdMatrix().

1863  {
1864 
1865  MatrixType mtype = mkey.GetMatrixType();
1866 
1867  DNekMatSharedPtr Mat;
1868 
1869  switch(mtype)
1870  {
1871  case ePhysInterpToEquiSpaced:
1872  {
1873  int nq0 = m_base[0]->GetNumPoints();
1874  int nq1 = m_base[1]->GetNumPoints();
1875  int nq2 = m_base[2]->GetNumPoints();
1876  int nq;
1877 
1878  // take definition from key
1879  if(mkey.ConstFactorExists(eFactorConst))
1880  {
1881  nq = (int) mkey.GetConstFactor(eFactorConst);
1882  }
1883  else
1884  {
1885  nq = max(nq0,max(nq1,nq2));
1886  }
1887 
1888  int neq = LibUtilities::StdTetData::
1889  getNumberOfCoefficients(nq,nq,nq);
1890  Array<OneD, Array<OneD, NekDouble> > coords(neq);
1891  Array<OneD, NekDouble> coll(3);
1892  Array<OneD, DNekMatSharedPtr> I(3);
1893  Array<OneD, NekDouble> tmp(nq0);
1894 
1895  Mat = MemoryManager<DNekMat>::
1896  AllocateSharedPtr(neq, nq0 * nq1 * nq2);
1897  int cnt = 0;
1898 
1899  for(int i = 0; i < nq; ++i)
1900  {
1901  for(int j = 0; j < nq-i; ++j)
1902  {
1903  for(int k = 0; k < nq-i-j; ++k,++cnt)
1904  {
1905  coords[cnt] = Array<OneD, NekDouble>(3);
1906  coords[cnt][0] = -1.0 + 2*k/(NekDouble)(nq-1);
1907  coords[cnt][1] = -1.0 + 2*j/(NekDouble)(nq-1);
1908  coords[cnt][2] = -1.0 + 2*i/(NekDouble)(nq-1);
1909  }
1910  }
1911  }
1912 
1913  for(int i = 0; i < neq; ++i)
1914  {
1915  LocCoordToLocCollapsed(coords[i],coll);
1916 
1917  I[0] = m_base[0]->GetI(coll);
1918  I[1] = m_base[1]->GetI(coll+1);
1919  I[2] = m_base[2]->GetI(coll+2);
1920 
1921  // interpolate first coordinate direction
1922  NekDouble fac;
1923  for( int k = 0; k < nq2; ++k)
1924  {
1925  for (int j = 0; j < nq1; ++j)
1926  {
1927 
1928  fac = (I[1]->GetPtr())[j]*(I[2]->GetPtr())[k];
1929  Vmath::Smul(nq0,fac,I[0]->GetPtr(),1,tmp,1);
1930 
1931  Vmath::Vcopy(nq0, &tmp[0], 1,
1932  Mat->GetRawPtr()+
1933  k*nq0*nq1*neq+
1934  j*nq0*neq+i,neq);
1935  }
1936  }
1937  }
1938  }
1939  break;
1940  default:
1941  {
1942  Mat = StdExpansion::CreateGeneralMatrix(mkey);
1943  }
1944  break;
1945  }
1946 
1947  return Mat;
1948  }
Nektar::StdRegions::StdExpansion::LocCoordToLocCollapsed
void LocCoordToLocCollapsed(const Array< OneD, const NekDouble > &xi, Array< OneD, NekDouble > &eta)
Convert local cartesian coordinate xi into local collapsed coordinates eta.
Definition: StdExpansion.h:1184
Nektar::DNekMatSharedPtr
std::shared_ptr< DNekMat > DNekMatSharedPtr
Definition: NekTypeDefs.hpp:69
Nektar::LibUtilities::StdTetData::getNumberOfCoefficients
int getNumberOfCoefficients(int Na, int Nb, int Nc)
Definition: ShapeType.hpp:194
Vmath::Smul
void Smul(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Scalar multiply y = alpha*y.
Definition: Vmath.cpp:216
Nektar::MemoryManager::AllocateSharedPtr
static std::shared_ptr< DataType > AllocateSharedPtr(const Args &...args)
Allocate a shared pointer from the memory pool.
Definition: NekMemoryManager.hpp:161
Nektar::StdRegions::StdExpansion::CreateGeneralMatrix
DNekMatSharedPtr CreateGeneralMatrix(const StdMatrixKey &mkey)
this function generates the mass matrix
Definition: StdExpansion.cpp:324
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:43
Nektar::StdRegions::StdExpansion::m_base
Array< OneD, LibUtilities::BasisSharedPtr > m_base
Definition: StdExpansion.h:1429
Vmath::Vcopy
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1064

◆ v_GetBoundaryMap()

void Nektar::StdRegions::StdTetExp::v_GetBoundaryMap ( Array< OneD, unsigned int > &  outarray)
protectedvirtual

List of all boundary modes in the the expansion.

Reimplemented from Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::StdRegions::StdNodalTetExp.

Definition at line 1803 of file StdTetExp.cpp.

References ASSERTL1, Nektar::LibUtilities::eGLL_Lagrange, Nektar::LibUtilities::eModified_A, Nektar::LibUtilities::eModified_B, Nektar::LibUtilities::eModified_C, Nektar::StdRegions::StdExpansion::GetBasisType(), GetMode(), Nektar::StdRegions::StdExpansion::m_base, Nektar::StdRegions::StdExpansion::NumBndryCoeffs(), and class_topology::P.

Referenced by DetShapeType().

1804  {
1805  ASSERTL1(GetBasisType(0) == LibUtilities::eModified_A ||
1806  GetBasisType(0) == LibUtilities::eGLL_Lagrange,
1807  "BasisType is not a boundary interior form");
1808  ASSERTL1(GetBasisType(1) == LibUtilities::eModified_B ||
1809  GetBasisType(1) == LibUtilities::eGLL_Lagrange,
1810  "BasisType is not a boundary interior form");
1811  ASSERTL1(GetBasisType(2) == LibUtilities::eModified_C ||
1812  GetBasisType(2) == LibUtilities::eGLL_Lagrange,
1813  "BasisType is not a boundary interior form");
1814 
1815  int P = m_base[0]->GetNumModes();
1816  int Q = m_base[1]->GetNumModes();
1817  int R = m_base[2]->GetNumModes();
1818 
1819  int i,j,k;
1820  int idx = 0;
1821 
1822  int nBnd = NumBndryCoeffs();
1823 
1824  if (outarray.num_elements() != nBnd)
1825  {
1826  outarray = Array<OneD, unsigned int>(nBnd);
1827  }
1828 
1829  for (i = 0; i < P; ++i)
1830  {
1831  // First two Q-R planes are entirely boundary modes
1832  if (i < 2)
1833  {
1834  for (j = 0; j < Q-i; j++)
1835  {
1836  for (k = 0; k < R-i-j; ++k)
1837  {
1838  outarray[idx++] = GetMode(i,j,k);
1839  }
1840  }
1841  }
1842  // Remaining Q-R planes contain boundary modes on bottom and
1843  // left edge.
1844  else
1845  {
1846  for (k = 0; k < R-i; ++k)
1847  {
1848  outarray[idx++] = GetMode(i,0,k);
1849  }
1850  for (j = 1; j < Q-i; ++j)
1851  {
1852  outarray[idx++] = GetMode(i,j,0);
1853  }
1854  }
1855  }
1856  }
Nektar::StdRegions::StdTetExp::GetMode
int GetMode(const int i, const int j, const int k)
Compute the mode number in the expansion for a particular tensorial combination.
Definition: StdTetExp.cpp:1981
Nektar::LibUtilities::eModified_C
Principle Modified Functions .
Definition: BasisType.h:50
Nektar::LibUtilities::eModified_A
Principle Modified Functions .
Definition: BasisType.h:48
class_topology.P
P
Definition: class_topology.py:290
Nektar::LibUtilities::eModified_B
Principle Modified Functions .
Definition: BasisType.h:49
Nektar::StdRegions::StdExpansion::GetBasisType
LibUtilities::BasisType GetBasisType(const int dir) const
This function returns the type of basis used in the dir direction.
Definition: StdExpansion.h:164
Nektar::LibUtilities::eGLL_Lagrange
Lagrange for SEM basis .
Definition: BasisType.h:54
ASSERTL1
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:250
Nektar::StdRegions::StdExpansion::m_base
Array< OneD, LibUtilities::BasisSharedPtr > m_base
Definition: StdExpansion.h:1429

◆ v_GetCoords()

void Nektar::StdRegions::StdTetExp::v_GetCoords ( Array< OneD, NekDouble > &  coords_x,
Array< OneD, NekDouble > &  coords_y,
Array< OneD, NekDouble > &  coords_z 
)
protectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::LocalRegions::TetExp.

Definition at line 1205 of file StdTetExp.cpp.

References Nektar::StdRegions::StdExpansion::GetNumPoints(), and Nektar::StdRegions::StdExpansion::m_base.

Referenced by DetShapeType().

1209  {
1210  Array<OneD, const NekDouble> eta_x = m_base[0]->GetZ();
1211  Array<OneD, const NekDouble> eta_y = m_base[1]->GetZ();
1212  Array<OneD, const NekDouble> eta_z = m_base[2]->GetZ();
1213  int Qx = GetNumPoints(0);
1214  int Qy = GetNumPoints(1);
1215  int Qz = GetNumPoints(2);
1216 
1217  // Convert collapsed coordinates into cartesian coordinates: eta
1218  // --> xi
1219  for( int k = 0; k < Qz; ++k ) {
1220  for( int j = 0; j < Qy; ++j ) {
1221  for( int i = 0; i < Qx; ++i ) {
1222  int s = i + Qx*(j + Qy*k);
1223  xi_x[s] = (eta_x[i] + 1.0) * (1.0 - eta_y[j]) * (1.0 - eta_z[k]) / 4 - 1.0;
1224  xi_y[s] = (eta_y[j] + 1.0) * (1.0 - eta_z[k]) / 2 - 1.0;
1225  xi_z[s] = eta_z[k];
1226  }
1227  }
1228  }
1229  }
Nektar::StdRegions::StdExpansion::GetNumPoints
int GetNumPoints(const int dir) const
This function returns the number of quadrature points in the dir direction.
Definition: StdExpansion.h:228
Nektar::StdRegions::StdExpansion::m_base
Array< OneD, LibUtilities::BasisSharedPtr > m_base
Definition: StdExpansion.h:1429

◆ v_GetEdgeBasisType()

LibUtilities::BasisType Nektar::StdRegions::StdTetExp::v_GetEdgeBasisType ( const int  i) const
protectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 1187 of file StdTetExp.cpp.

References ASSERTL2, and Nektar::StdRegions::StdExpansion::GetBasisType().

Referenced by DetShapeType().

1188  {
1189  ASSERTL2(i >= 0 && i <= 5, "edge id is out of range");
1190 
1191  if (i == 0)
1192  {
1193  return GetBasisType(0);
1194  }
1195  else if (i == 1 || i == 2)
1196  {
1197  return GetBasisType(1);
1198  }
1199  else
1200  {
1201  return GetBasisType(2);
1202  }
1203  }
ASSERTL2
#define ASSERTL2(condition, msg)
Assert Level 2 – Debugging which is used FULLDEBUG compilation mode. This level assert is designed t...
Definition: ErrorUtil.hpp:274
Nektar::StdRegions::StdExpansion::GetBasisType
LibUtilities::BasisType GetBasisType(const int dir) const
This function returns the type of basis used in the dir direction.
Definition: StdExpansion.h:164

◆ v_GetEdgeInteriorMap()

void Nektar::StdRegions::StdTetExp::v_GetEdgeInteriorMap ( const int  eid,
const Orientation  edgeOrient,
Array< OneD, unsigned int > &  maparray,
Array< OneD, int > &  signarray 
)
protectedvirtual

Maps interior modes of an edge to the elemental modes.

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 1553 of file StdTetExp.cpp.

References ASSERTL0, Nektar::StdRegions::eBackwards, GetMode(), Nektar::StdRegions::StdExpansion::m_base, class_topology::P, and v_GetEdgeNcoeffs().

Referenced by DetShapeType(), and v_GetEdgeToElementMap().

1558  {
1559  int i;
1560  const int P = m_base[0]->GetNumModes();
1561  const int Q = m_base[1]->GetNumModes();
1562  const int R = m_base[2]->GetNumModes();
1563 
1564  const int nEdgeIntCoeffs = v_GetEdgeNcoeffs(eid)-2;
1565 
1566  if(maparray.num_elements() != nEdgeIntCoeffs)
1567  {
1568  maparray = Array<OneD, unsigned int>(nEdgeIntCoeffs);
1569  }
1570  else
1571  {
1572  fill( maparray.get(), maparray.get() + nEdgeIntCoeffs, 0);
1573  }
1574 
1575  if(signarray.num_elements() != nEdgeIntCoeffs)
1576  {
1577  signarray = Array<OneD, int>(nEdgeIntCoeffs,1);
1578  }
1579  else
1580  {
1581  fill( signarray.get() , signarray.get()+nEdgeIntCoeffs, 1 );
1582  }
1583 
1584  switch (eid)
1585  {
1586  case 0:
1587  for (i = 0; i < P-2; ++i)
1588  {
1589  maparray[i] = GetMode(i+2, 0, 0);
1590  }
1591  if(edgeOrient==eBackwards)
1592  {
1593  for(i = 1; i < nEdgeIntCoeffs; i+=2)
1594  {
1595  signarray[i] = -1;
1596  }
1597  }
1598  break;
1599  case 1:
1600  for (i = 0; i < Q-2; ++i)
1601  {
1602  maparray[i] = GetMode(1, i+1, 0);
1603  }
1604  if(edgeOrient==eBackwards)
1605  {
1606  for(i = 1; i < nEdgeIntCoeffs; i+=2)
1607  {
1608  signarray[i] = -1;
1609  }
1610  }
1611  break;
1612  case 2:
1613  for (i = 0; i < Q-2; ++i)
1614  {
1615  maparray[i] = GetMode(0, i+2, 0);
1616  }
1617  if(edgeOrient==eBackwards)
1618  {
1619  for(i = 1; i < nEdgeIntCoeffs; i+=2)
1620  {
1621  signarray[i] = -1;
1622  }
1623  }
1624  break;
1625  case 3:
1626  for (i = 0; i < R-2; ++i)
1627  {
1628  maparray[i] = GetMode(0, 0, i+2);
1629  }
1630  if(edgeOrient==eBackwards)
1631  {
1632  for(i = 1; i < nEdgeIntCoeffs; i+=2)
1633  {
1634  signarray[i] = -1;
1635  }
1636  }
1637  break;
1638  case 4:
1639  for (i = 0; i < R - 2; ++i)
1640  {
1641  maparray[i] = GetMode(1, 0, i+1);
1642  }
1643  if(edgeOrient==eBackwards)
1644  {
1645  for(i = 1; i < nEdgeIntCoeffs; i+=2)
1646  {
1647  signarray[i] = -1;
1648  }
1649  }
1650  break;
1651  case 5:
1652  for (i = 0; i < R-2; ++i)
1653  {
1654  maparray[i] = GetMode(0, 1, i+1);
1655  }
1656  if(edgeOrient==eBackwards)
1657  {
1658  for(i = 1; i < nEdgeIntCoeffs; i+=2)
1659  {
1660  signarray[i] = -1;
1661  }
1662  }
1663  break;
1664  default:
1665  ASSERTL0(false, "Edge not defined.");
1666  break;
1667  }
1668  }
Nektar::StdRegions::StdTetExp::GetMode
int GetMode(const int i, const int j, const int k)
Compute the mode number in the expansion for a particular tensorial combination.
Definition: StdTetExp.cpp:1981
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:216
Nektar::StdRegions::StdTetExp::v_GetEdgeNcoeffs
virtual int v_GetEdgeNcoeffs(const int i) const
Definition: StdTetExp.cpp:1015
class_topology.P
P
Definition: class_topology.py:290
Nektar::StdRegions::StdExpansion::m_base
Array< OneD, LibUtilities::BasisSharedPtr > m_base
Definition: StdExpansion.h:1429

◆ v_GetEdgeNcoeffs()

int Nektar::StdRegions::StdTetExp::v_GetEdgeNcoeffs ( const int  i) const
protectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 1015 of file StdTetExp.cpp.

References ASSERTL2, Nektar::StdRegions::StdExpansion::m_base, and class_topology::P.

Referenced by DetShapeType(), v_GetEdgeInteriorMap(), and v_GetEdgeToElementMap().

1016  {
1017  ASSERTL2((i >= 0) && (i <= 5), "edge id is out of range");
1018  int P = m_base[0]->GetNumModes();
1019  int Q = m_base[1]->GetNumModes();
1020  int R = m_base[2]->GetNumModes();
1021 
1022  if (i == 0)
1023  {
1024  return P;
1025  }
1026  else if (i == 1 || i == 2)
1027  {
1028  return Q;
1029  }
1030  else
1031  {
1032  return R;
1033  }
1034  }
class_topology.P
P
Definition: class_topology.py:290
ASSERTL2
#define ASSERTL2(condition, msg)
Assert Level 2 – Debugging which is used FULLDEBUG compilation mode. This level assert is designed t...
Definition: ErrorUtil.hpp:274
Nektar::StdRegions::StdExpansion::m_base
Array< OneD, LibUtilities::BasisSharedPtr > m_base
Definition: StdExpansion.h:1429

◆ v_GetEdgeToElementMap()

void Nektar::StdRegions::StdTetExp::v_GetEdgeToElementMap ( const int  eid,
const Orientation  edgeOrient,
Array< OneD, unsigned int > &  maparray,
Array< OneD, int > &  signarray,
int  P 
)
protectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 1243 of file StdTetExp.cpp.

References ASSERTL2, Nektar::StdRegions::eBackwards, Nektar::StdRegions::eForwards, v_GetEdgeInteriorMap(), v_GetEdgeNcoeffs(), v_GetVertexMap(), and v_IsBoundaryInteriorExpansion().

Referenced by DetShapeType().

1249  {
1250  boost::ignore_unused(P);
1251 
1252  ASSERTL2(eid >= 0 && eid < 6, "Invalid edge");
1253  ASSERTL2(v_IsBoundaryInteriorExpansion(),
1254  "Method only implemented for Modified_A BasisType (x "
1255  "direction), Modified_B BasisType (y direction), and "
1256  "Modified_C BasisType(z direction)");
1257 
1258  int edgeVerts[6][2] = {{0,1},{1,2},{0,2},{0,3},{1,3},{2,3}};
1259  int nEdgeModes = v_GetEdgeNcoeffs(eid);
1260 
1261  if (maparray.num_elements() != nEdgeModes)
1262  {
1263  maparray = Array<OneD, unsigned int>(nEdgeModes);
1264  }
1265 
1266  if (signarray.num_elements() != nEdgeModes)
1267  {
1268  signarray = Array<OneD, int>(nEdgeModes, 1.0);
1269  }
1270 
1271  if (edgeOrient == StdRegions::eForwards)
1272  {
1273  maparray[0] = v_GetVertexMap(edgeVerts[eid][0]);
1274  maparray[1] = v_GetVertexMap(edgeVerts[eid][1]);
1275  }
1276  else if (edgeOrient == StdRegions::eBackwards)
1277  {
1278  maparray[0] = v_GetVertexMap(edgeVerts[eid][1]);
1279  maparray[1] = v_GetVertexMap(edgeVerts[eid][0]);
1280  }
1281  else
1282  {
1283  ASSERTL2(false, "Unsupported edge orientation");
1284  }
1285 
1286  Array<OneD, unsigned int> tmp1(nEdgeModes-2);
1287  Array<OneD, int> tmp2(nEdgeModes-2);
1288  v_GetEdgeInteriorMap(eid, edgeOrient, tmp1, tmp2);
1289 
1290  for (int i = 0; i < nEdgeModes-2; ++i)
1291  {
1292  maparray[i+2] = tmp1[i];
1293  signarray[i+2] = tmp2[i];
1294  }
1295  }
Nektar::StdRegions::StdTetExp::v_GetEdgeNcoeffs
virtual int v_GetEdgeNcoeffs(const int i) const
Definition: StdTetExp.cpp:1015
class_topology.P
P
Definition: class_topology.py:290
Nektar::StdRegions::StdTetExp::v_GetEdgeInteriorMap
virtual void v_GetEdgeInteriorMap(const int eid, const Orientation edgeOrient, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray)
Definition: StdTetExp.cpp:1553
Nektar::StdRegions::StdTetExp::v_IsBoundaryInteriorExpansion
virtual bool v_IsBoundaryInteriorExpansion()
Definition: StdTetExp.cpp:1231
ASSERTL2
#define ASSERTL2(condition, msg)
Assert Level 2 – Debugging which is used FULLDEBUG compilation mode. This level assert is designed t...
Definition: ErrorUtil.hpp:274
Nektar::StdRegions::StdTetExp::v_GetVertexMap
virtual int v_GetVertexMap(int localVertexId, bool useCoeffPacking=false)
Definition: StdTetExp.cpp:1475

◆ v_GetFaceInteriorMap()

void Nektar::StdRegions::StdTetExp::v_GetFaceInteriorMap ( const int  fid,
const Orientation  faceOrient,
Array< OneD, unsigned int > &  maparray,
Array< OneD, int > &  signarray 
)
protectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 1670 of file StdTetExp.cpp.

References ASSERTL0, GetMode(), Nektar::StdRegions::StdExpansion::m_base, class_topology::P, and v_GetFaceIntNcoeffs().

Referenced by DetShapeType().

1675  {
1676  int i, j, idx, k;
1677  const int P = m_base[0]->GetNumModes();
1678  const int Q = m_base[1]->GetNumModes();
1679  const int R = m_base[2]->GetNumModes();
1680 
1681  const int nFaceIntCoeffs = v_GetFaceIntNcoeffs(fid);
1682 
1683  if(maparray.num_elements() != nFaceIntCoeffs)
1684  {
1685  maparray = Array<OneD, unsigned int>(nFaceIntCoeffs);
1686  }
1687 
1688  if(signarray.num_elements() != nFaceIntCoeffs)
1689  {
1690  signarray = Array<OneD, int>(nFaceIntCoeffs,1);
1691  }
1692  else
1693  {
1694  fill( signarray.get() , signarray.get()+nFaceIntCoeffs, 1 );
1695  }
1696 
1697  switch (fid)
1698  {
1699  case 0:
1700  idx = 0;
1701  for (i = 2; i < P-1; ++i)
1702  {
1703  for (j = 1; j < Q-i; ++j)
1704  {
1705  if ((int)faceOrient == 7)
1706  {
1707  signarray[idx] = (i%2 ? -1 : 1);
1708  }
1709  maparray[idx++] = GetMode(i,j,0);
1710  }
1711  }
1712  break;
1713  case 1:
1714  idx = 0;
1715  for (i = 2; i < P; ++i)
1716  {
1717  for (k = 1; k < R-i; ++k)
1718  {
1719  if ((int)faceOrient == 7)
1720  {
1721  signarray[idx] = (i%2 ? -1: 1);
1722  }
1723  maparray[idx++] = GetMode(i,0,k);
1724  }
1725  }
1726  break;
1727  case 2:
1728  idx = 0;
1729  for (j = 1; j < Q-2; ++j)
1730  {
1731  for (k = 1; k < R-1-j; ++k)
1732  {
1733  if ((int)faceOrient == 7)
1734  {
1735  signarray[idx] = ((j+1)%2 ? -1: 1);
1736  }
1737  maparray[idx++] = GetMode(1,j,k);
1738  }
1739  }
1740  break;
1741  case 3:
1742  idx = 0;
1743  for (j = 2; j < Q-1; ++j)
1744  {
1745  for (k = 1; k < R-j; ++k)
1746  {
1747  if ((int)faceOrient == 7)
1748  {
1749  signarray[idx] = (j%2 ? -1: 1);
1750  }
1751  maparray[idx++] = GetMode(0,j,k);
1752  }
1753  }
1754  break;
1755  default:
1756  ASSERTL0(false, "Face interior map not available.");
1757  break;
1758  }
1759  }
Nektar::StdRegions::StdTetExp::GetMode
int GetMode(const int i, const int j, const int k)
Compute the mode number in the expansion for a particular tensorial combination.
Definition: StdTetExp.cpp:1981
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:216
class_topology.P
P
Definition: class_topology.py:290
Nektar::StdRegions::StdTetExp::v_GetFaceIntNcoeffs
virtual int v_GetFaceIntNcoeffs(const int i) const
Definition: StdTetExp.cpp:1071
Nektar::StdRegions::StdExpansion::m_base
Array< OneD, LibUtilities::BasisSharedPtr > m_base
Definition: StdExpansion.h:1429

◆ v_GetFaceIntNcoeffs()

int Nektar::StdRegions::StdTetExp::v_GetFaceIntNcoeffs ( const int  i) const
protectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 1071 of file StdTetExp.cpp.

References ASSERTL2, and Nektar::StdRegions::StdExpansion::m_base.

Referenced by DetShapeType(), and v_GetFaceInteriorMap().

1072  {
1073  ASSERTL2((i >= 0) && (i <= 3), "face id is out of range");
1074  int Pi = m_base[0]->GetNumModes() - 2;
1075  int Qi = m_base[1]->GetNumModes() - 2;
1076  int Ri = m_base[2]->GetNumModes() - 2;
1077 
1078  if((i == 0))
1079  {
1080  return Pi * (2*Qi - Pi - 1) / 2;
1081  }
1082  else if((i == 1))
1083  {
1084  return Pi * (2*Ri - Pi - 1) / 2;
1085  }
1086  else
1087  {
1088  return Qi * (2*Ri - Qi - 1) / 2;
1089  }
1090  }
ASSERTL2
#define ASSERTL2(condition, msg)
Assert Level 2 – Debugging which is used FULLDEBUG compilation mode. This level assert is designed t...
Definition: ErrorUtil.hpp:274
Nektar::StdRegions::StdExpansion::m_base
Array< OneD, LibUtilities::BasisSharedPtr > m_base
Definition: StdExpansion.h:1429

◆ v_GetFaceNcoeffs()

int Nektar::StdRegions::StdTetExp::v_GetFaceNcoeffs ( const int  i) const
protectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 1045 of file StdTetExp.cpp.

References ASSERTL2, Nektar::StdRegions::StdExpansion::GetBasisNumModes(), and class_topology::P.

Referenced by DetShapeType().

1046  {
1047  ASSERTL2((i >= 0) && (i <= 3), "face id is out of range");
1048  int nFaceCoeffs = 0;
1049  int nummodesA, nummodesB, P, Q;
1050  if (i == 0)
1051  {
1052  nummodesA = GetBasisNumModes(0);
1053  nummodesB = GetBasisNumModes(1);
1054  }
1055  else if ((i == 1) || (i == 2))
1056  {
1057  nummodesA = GetBasisNumModes(0);
1058  nummodesB = GetBasisNumModes(2);
1059  }
1060  else
1061  {
1062  nummodesA = GetBasisNumModes(1);
1063  nummodesB = GetBasisNumModes(2);
1064  }
1065  P = nummodesA - 1;
1066  Q = nummodesB - 1;
1067  nFaceCoeffs = Q+1 + (P*(1 + 2*Q - P))/2;
1068  return nFaceCoeffs;
1069  }
Nektar::StdRegions::StdExpansion::GetBasisNumModes
int GetBasisNumModes(const int dir) const
This function returns the number of expansion modes in the dir direction.
Definition: StdExpansion.h:177
class_topology.P
P
Definition: class_topology.py:290
ASSERTL2
#define ASSERTL2(condition, msg)
Assert Level 2 – Debugging which is used FULLDEBUG compilation mode. This level assert is designed t...
Definition: ErrorUtil.hpp:274

◆ v_GetFaceNumModes()

void Nektar::StdRegions::StdTetExp::v_GetFaceNumModes ( const int  fid,
const Orientation  faceOrient,
int &  numModes0,
int &  numModes1 
)
protectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 914 of file StdTetExp.cpp.

References Nektar::StdRegions::StdExpansion::m_base.

Referenced by DetShapeType().

919  {
920  boost::ignore_unused(faceOrient);
921 
922  int nummodes [3] = {m_base[0]->GetNumModes(),
923  m_base[1]->GetNumModes(),
924  m_base[2]->GetNumModes()};
925  switch(fid)
926  {
927  case 0:
928  {
929  numModes0 = nummodes[0];
930  numModes1 = nummodes[1];
931  }
932  break;
933  case 1:
934  {
935  numModes0 = nummodes[0];
936  numModes1 = nummodes[2];
937  }
938  break;
939  case 2:
940  case 3:
941  {
942  numModes0 = nummodes[1];
943  numModes1 = nummodes[2];
944  }
945  break;
946  }
947  }
Nektar::StdRegions::StdExpansion::m_base
Array< OneD, LibUtilities::BasisSharedPtr > m_base
Definition: StdExpansion.h:1429

◆ v_GetFaceNumPoints()

int Nektar::StdRegions::StdTetExp::v_GetFaceNumPoints ( const int  i) const
protectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 1103 of file StdTetExp.cpp.

References ASSERTL2, and Nektar::StdRegions::StdExpansion::m_base.

Referenced by DetShapeType().

1104  {
1105  ASSERTL2(i >= 0 && i <= 3, "face id is out of range");
1106 
1107  if (i == 0)
1108  {
1109  return m_base[0]->GetNumPoints()*
1110  m_base[1]->GetNumPoints();
1111  }
1112  else if (i == 1)
1113  {
1114  return m_base[0]->GetNumPoints()*
1115  m_base[2]->GetNumPoints();
1116  }
1117  else
1118  {
1119  return m_base[1]->GetNumPoints()*
1120  m_base[2]->GetNumPoints();
1121  }
1122  }
ASSERTL2
#define ASSERTL2(condition, msg)
Assert Level 2 – Debugging which is used FULLDEBUG compilation mode. This level assert is designed t...
Definition: ErrorUtil.hpp:274
Nektar::StdRegions::StdExpansion::m_base
Array< OneD, LibUtilities::BasisSharedPtr > m_base
Definition: StdExpansion.h:1429

◆ v_GetFacePointsKey()

LibUtilities::PointsKey Nektar::StdRegions::StdTetExp::v_GetFacePointsKey ( const int  i,
const int  j 
) const
protectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 1124 of file StdTetExp.cpp.

References ASSERTL2, and Nektar::StdRegions::StdExpansion::m_base.

Referenced by DetShapeType().

1126  {
1127  ASSERTL2(i >= 0 && i <= 3, "face id is out of range");
1128  ASSERTL2(j == 0 || j == 1, "face direction is out of range");
1129 
1130  if (i == 0)
1131  {
1132  return m_base[j]->GetPointsKey();
1133  }
1134  else if (i == 1)
1135  {
1136  return m_base[2*j]->GetPointsKey();
1137  }
1138  else
1139  {
1140  return m_base[j+1]->GetPointsKey();
1141  }
1142  }
ASSERTL2
#define ASSERTL2(condition, msg)
Assert Level 2 – Debugging which is used FULLDEBUG compilation mode. This level assert is designed t...
Definition: ErrorUtil.hpp:274
Nektar::StdRegions::StdExpansion::m_base
Array< OneD, LibUtilities::BasisSharedPtr > m_base
Definition: StdExpansion.h:1429

◆ v_GetFaceToElementMap()

void Nektar::StdRegions::StdTetExp::v_GetFaceToElementMap ( const int  fid,
const Orientation  faceOrient,
Array< OneD, unsigned int > &  maparray,
Array< OneD, int > &  signarray,
int  P = -1,
int  Q = -1 
)
protectedvirtual

Maps Expansion2D modes of a 2D face to the corresponding expansion modes.

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 1301 of file StdTetExp.cpp.

References ASSERTL0, ASSERTL1, GetMode(), Nektar::StdRegions::StdExpansion::m_base, class_topology::P, and v_IsBoundaryInteriorExpansion().

Referenced by DetShapeType().

1308  {
1309  int nummodesA=0,nummodesB=0, i, j, k, idx;
1310 
1311  ASSERTL1(v_IsBoundaryInteriorExpansion(),
1312  "Method only implemented for Modified_A BasisType (x "
1313  "direction), Modified_B BasisType (y direction), and "
1314  "Modified_C BasisType(z direction)");
1315 
1316  int nFaceCoeffs = 0;
1317 
1318  switch(fid)
1319  {
1320  case 0:
1321  nummodesA = m_base[0]->GetNumModes();
1322  nummodesB = m_base[1]->GetNumModes();
1323  break;
1324  case 1:
1325  nummodesA = m_base[0]->GetNumModes();
1326  nummodesB = m_base[2]->GetNumModes();
1327  break;
1328  case 2:
1329  case 3:
1330  nummodesA = m_base[1]->GetNumModes();
1331  nummodesB = m_base[2]->GetNumModes();
1332  break;
1333  default:
1334  ASSERTL0(false,"fid must be between 0 and 3");
1335  }
1336 
1337  bool CheckForZeroedModes = false;
1338  if(P == -1)
1339  {
1340  P = nummodesA;
1341  Q = nummodesB;
1342  }
1343  else
1344  {
1345  CheckForZeroedModes = true;
1346  }
1347 
1348  nFaceCoeffs = P*(2*Q-P+1)/2;
1349 
1350  // Allocate the map array and sign array; set sign array to ones (+)
1351  if(maparray.num_elements() != nFaceCoeffs)
1352  {
1353  maparray = Array<OneD, unsigned int>(nFaceCoeffs,1);
1354  }
1355 
1356  if(signarray.num_elements() != nFaceCoeffs)
1357  {
1358  signarray = Array<OneD, int>(nFaceCoeffs,1);
1359  }
1360  else
1361  {
1362  fill(signarray.get(),signarray.get()+nFaceCoeffs, 1 );
1363  }
1364 
1365  switch (fid)
1366  {
1367  case 0:
1368  idx = 0;
1369  for (i = 0; i < P; ++i)
1370  {
1371  for (j = 0; j < Q-i; ++j)
1372  {
1373  if ((int)faceOrient == 7 && i > 1)
1374  {
1375  signarray[idx] = (i%2 ? -1 : 1);
1376  }
1377  maparray[idx++] = GetMode(i,j,0);
1378  }
1379  }
1380  break;
1381  case 1:
1382  idx = 0;
1383  for (i = 0; i < P; ++i)
1384  {
1385  for (k = 0; k < Q-i; ++k)
1386  {
1387  if ((int)faceOrient == 7 && i > 1)
1388  {
1389  signarray[idx] = (i%2 ? -1: 1);
1390  }
1391  maparray[idx++] = GetMode(i,0,k);
1392  }
1393  }
1394  break;
1395  case 2:
1396  idx = 0;
1397  for (j = 0; j < P-1; ++j)
1398  {
1399  for (k = 0; k < Q-1-j; ++k)
1400  {
1401  if ((int)faceOrient == 7 && j > 1)
1402  {
1403  signarray[idx] = ((j+1)%2 ? -1: 1);
1404  }
1405  maparray[idx++] = GetMode(1,j,k);
1406  // Incorporate modes from zeroth plane where needed.
1407  if (j == 0 && k == 0)
1408  {
1409  maparray[idx++] = GetMode(0,0,1);
1410  }
1411  if (j == 0 && k == Q-2)
1412  {
1413  for (int r = 0; r < Q-1; ++r)
1414  {
1415  maparray[idx++] = GetMode(0,1,r);
1416  }
1417  }
1418  }
1419  }
1420  break;
1421  case 3:
1422  idx = 0;
1423  for (j = 0; j < P; ++j)
1424  {
1425  for (k = 0; k < Q-j; ++k)
1426  {
1427  if ((int)faceOrient == 7 && j > 1)
1428  {
1429  signarray[idx] = (j%2 ? -1: 1);
1430  }
1431  maparray[idx++] = GetMode(0,j,k);
1432  }
1433  }
1434  break;
1435  default:
1436  ASSERTL0(false, "Element map not available.");
1437  }
1438 
1439  if ((int)faceOrient == 7)
1440  {
1441  swap(maparray[0], maparray[Q]);
1442 
1443  for (i = 1; i < Q-1; ++i)
1444  {
1445  swap(maparray[i+1], maparray[Q+i]);
1446  }
1447  }
1448 
1449  if(CheckForZeroedModes)
1450  {
1451  // zero signmap and set maparray to zero if elemental
1452  // modes are not as large as face modesl
1453  idx = 0;
1454  for (j = 0; j < nummodesA; ++j)
1455  {
1456  idx += nummodesB-j;
1457  for (k = nummodesB-j; k < Q-j; ++k)
1458  {
1459  signarray[idx] = 0.0;
1460  maparray[idx++] = maparray[0];
1461  }
1462  }
1463 
1464  for (j = nummodesA; j < P; ++j)
1465  {
1466  for (k = 0; k < Q-j; ++k)
1467  {
1468  signarray[idx] = 0.0;
1469  maparray[idx++] = maparray[0];
1470  }
1471  }
1472  }
1473  }
Nektar::StdRegions::StdTetExp::GetMode
int GetMode(const int i, const int j, const int k)
Compute the mode number in the expansion for a particular tensorial combination.
Definition: StdTetExp.cpp:1981
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:216
class_topology.P
P
Definition: class_topology.py:290
Nektar::StdRegions::StdTetExp::v_IsBoundaryInteriorExpansion
virtual bool v_IsBoundaryInteriorExpansion()
Definition: StdTetExp.cpp:1231
ASSERTL1
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:250
Nektar::StdRegions::StdExpansion::m_base
Array< OneD, LibUtilities::BasisSharedPtr > m_base
Definition: StdExpansion.h:1429

◆ v_GetInteriorMap()

void Nektar::StdRegions::StdTetExp::v_GetInteriorMap ( Array< OneD, unsigned int > &  outarray)
protectedvirtual

List of all interior modes in the expansion.

Reimplemented from Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::StdRegions::StdNodalTetExp.

Definition at line 1764 of file StdTetExp.cpp.

References ASSERTL1, Nektar::LibUtilities::eGLL_Lagrange, Nektar::LibUtilities::eModified_A, Nektar::LibUtilities::eModified_B, Nektar::LibUtilities::eModified_C, Nektar::StdRegions::StdExpansion::GetBasisType(), GetMode(), Nektar::StdRegions::StdExpansion::m_base, Nektar::StdRegions::StdExpansion::m_ncoeffs, Nektar::StdRegions::StdExpansion::NumBndryCoeffs(), and class_topology::P.

Referenced by DetShapeType().

1765  {
1766  ASSERTL1(GetBasisType(0) == LibUtilities::eModified_A ||
1767  GetBasisType(0) == LibUtilities::eGLL_Lagrange,
1768  "BasisType is not a boundary interior form");
1769  ASSERTL1(GetBasisType(1) == LibUtilities::eModified_B ||
1770  GetBasisType(1) == LibUtilities::eGLL_Lagrange,
1771  "BasisType is not a boundary interior form");
1772  ASSERTL1(GetBasisType(2) == LibUtilities::eModified_C ||
1773  GetBasisType(2) == LibUtilities::eGLL_Lagrange,
1774  "BasisType is not a boundary interior form");
1775 
1776  int P = m_base[0]->GetNumModes();
1777  int Q = m_base[1]->GetNumModes();
1778  int R = m_base[2]->GetNumModes();
1779 
1780  int nIntCoeffs = m_ncoeffs - NumBndryCoeffs();
1781 
1782  if(outarray.num_elements() != nIntCoeffs)
1783  {
1784  outarray = Array<OneD, unsigned int>(nIntCoeffs);
1785  }
1786 
1787  int idx = 0;
1788  for (int i = 2; i < P-2; ++i)
1789  {
1790  for (int j = 1; j < Q-i-1; ++j)
1791  {
1792  for (int k = 1; k < R-i-j; ++k)
1793  {
1794  outarray[idx++] = GetMode(i,j,k);
1795  }
1796  }
1797  }
1798  }
Nektar::StdRegions::StdTetExp::GetMode
int GetMode(const int i, const int j, const int k)
Compute the mode number in the expansion for a particular tensorial combination.
Definition: StdTetExp.cpp:1981
Nektar::LibUtilities::eModified_C
Principle Modified Functions .
Definition: BasisType.h:50
Nektar::LibUtilities::eModified_A
Principle Modified Functions .
Definition: BasisType.h:48
class_topology.P
P
Definition: class_topology.py:290
Nektar::LibUtilities::eModified_B
Principle Modified Functions .
Definition: BasisType.h:49
Nektar::StdRegions::StdExpansion::GetBasisType
LibUtilities::BasisType GetBasisType(const int dir) const
This function returns the type of basis used in the dir direction.
Definition: StdExpansion.h:164
Nektar::LibUtilities::eGLL_Lagrange
Lagrange for SEM basis .
Definition: BasisType.h:54
ASSERTL1
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:250
Nektar::StdRegions::StdExpansion::m_base
Array< OneD, LibUtilities::BasisSharedPtr > m_base
Definition: StdExpansion.h:1429

◆ v_GetNedges()

int Nektar::StdRegions::StdTetExp::v_GetNedges ( ) const
protectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 958 of file StdTetExp.cpp.

Referenced by DetShapeType().

959  {
960  return 6;
961  }

◆ v_GetNfaces()

int Nektar::StdRegions::StdTetExp::v_GetNfaces ( ) const
protectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 963 of file StdTetExp.cpp.

Referenced by DetShapeType().

964  {
965  return 4;
966  }

◆ v_GetNverts()

int Nektar::StdRegions::StdTetExp::v_GetNverts ( ) const
protectedvirtual

Implements Nektar::StdRegions::StdExpansion.

Definition at line 953 of file StdTetExp.cpp.

Referenced by DetShapeType().

954  {
955  return 4;
956  }

◆ v_GetSimplexEquiSpacedConnectivity()

void Nektar::StdRegions::StdTetExp::v_GetSimplexEquiSpacedConnectivity ( Array< OneD, int > &  conn,
bool  standard = true 
)
protectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 2297 of file StdTetExp.cpp.

References Nektar::StdRegions::StdExpansion::m_base.

Referenced by DetShapeType().

2300  {
2301  boost::ignore_unused(standard);
2302 
2303  int np0 = m_base[0]->GetNumPoints();
2304  int np1 = m_base[1]->GetNumPoints();
2305  int np2 = m_base[2]->GetNumPoints();
2306  int np = max(np0,max(np1,np2));
2307 
2308 
2309  conn = Array<OneD, int>(4*(np-1)*(np-1)*(np-1));
2310 
2311  int row = 0;
2312  int rowp1 = 0;
2313  int plane = 0;
2314  int row1 = 0;
2315  int row1p1 = 0;
2316  int planep1= 0;
2317  int cnt = 0;
2318  for(int i = 0; i < np-1; ++i)
2319  {
2320  planep1 += (np-i)*(np-i+1)/2;
2321  row = 0; // current plane row offset
2322  rowp1 = 0; // current plane row plus one offset
2323  row1 = 0; // next plane row offset
2324  row1p1 = 0; // nex plane row plus one offset
2325  for(int j = 0; j < np-i-1; ++j)
2326  {
2327  rowp1 += np-i-j;
2328  row1p1 += np-i-j-1;
2329  for(int k = 0; k < np-i-j-2; ++k)
2330  {
2331  conn[cnt++] = plane + row +k+1;
2332  conn[cnt++] = plane + row +k;
2333  conn[cnt++] = plane + rowp1 +k;
2334  conn[cnt++] = planep1 + row1 +k;
2335 
2336  conn[cnt++] = plane + row +k+1;
2337  conn[cnt++] = plane + rowp1 +k+1;
2338  conn[cnt++] = planep1 + row1 +k+1;
2339  conn[cnt++] = planep1 + row1 +k;
2340 
2341  conn[cnt++] = plane + rowp1 +k+1;
2342  conn[cnt++] = plane + row +k+1;
2343  conn[cnt++] = plane + rowp1 +k;
2344  conn[cnt++] = planep1 + row1 +k;
2345 
2346  conn[cnt++] = planep1 + row1 +k;
2347  conn[cnt++] = planep1 + row1p1+k;
2348  conn[cnt++] = plane + rowp1 +k;
2349  conn[cnt++] = plane + rowp1 +k+1;
2350 
2351  conn[cnt++] = planep1 + row1 +k;
2352  conn[cnt++] = planep1 + row1p1+k;
2353  conn[cnt++] = planep1 + row1 +k+1;
2354  conn[cnt++] = plane + rowp1 +k+1;
2355 
2356  if(k < np-i-j-3)
2357  {
2358  conn[cnt++] = plane + rowp1 +k+1;
2359  conn[cnt++] = planep1 + row1p1 +k+1;
2360  conn[cnt++] = planep1 + row1 +k+1;
2361  conn[cnt++] = planep1 + row1p1 +k;
2362  }
2363  }
2364 
2365  conn[cnt++] = plane + row + np-i-j-1;
2366  conn[cnt++] = plane + row + np-i-j-2;
2367  conn[cnt++] = plane + rowp1 + np-i-j-2;
2368  conn[cnt++] = planep1 + row1 + np-i-j-2;
2369 
2370  row += np-i-j;
2371  row1 += np-i-j-1;
2372  }
2373  plane += (np-i)*(np-i+1)/2;
2374  }
2375  }
Nektar::StdRegions::StdExpansion::m_base
Array< OneD, LibUtilities::BasisSharedPtr > m_base
Definition: StdExpansion.h:1429

◆ v_GetTotalEdgeIntNcoeffs()

int Nektar::StdRegions::StdTetExp::v_GetTotalEdgeIntNcoeffs ( ) const
protectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 1036 of file StdTetExp.cpp.

References Nektar::StdRegions::StdExpansion::m_base, and class_topology::P.

Referenced by DetShapeType().

1037  {
1038  int P = m_base[0]->GetNumModes()-2;
1039  int Q = m_base[1]->GetNumModes()-2;
1040  int R = m_base[2]->GetNumModes()-2;
1041 
1042  return P+Q+4*R;
1043  }
class_topology.P
P
Definition: class_topology.py:290
Nektar::StdRegions::StdExpansion::m_base
Array< OneD, LibUtilities::BasisSharedPtr > m_base
Definition: StdExpansion.h:1429

◆ v_GetTotalFaceIntNcoeffs()

int Nektar::StdRegions::StdTetExp::v_GetTotalFaceIntNcoeffs ( ) const
protectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 1092 of file StdTetExp.cpp.

References Nektar::StdRegions::StdExpansion::m_base.

Referenced by DetShapeType().

1093  {
1094  int Pi = m_base[0]->GetNumModes() - 2;
1095  int Qi = m_base[1]->GetNumModes() - 2;
1096  int Ri = m_base[2]->GetNumModes() - 2;
1097 
1098  return Pi * (2*Qi - Pi - 1) / 2 +
1099  Pi * (2*Ri - Pi - 1) / 2 +
1100  Qi * (2*Ri - Qi - 1);
1101  }
Nektar::StdRegions::StdExpansion::m_base
Array< OneD, LibUtilities::BasisSharedPtr > m_base
Definition: StdExpansion.h:1429

◆ v_GetVertexMap()

int Nektar::StdRegions::StdTetExp::v_GetVertexMap ( int  localVertexId,
bool  useCoeffPacking = false 
)
protectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::StdRegions::StdNodalTetExp.

Definition at line 1475 of file StdTetExp.cpp.

References ASSERTL0, Nektar::LibUtilities::eModified_A, Nektar::LibUtilities::eModified_B, Nektar::LibUtilities::eModified_C, Nektar::StdRegions::StdExpansion::GetEdgeBasisType(), and GetMode().

Referenced by DetShapeType(), and v_GetEdgeToElementMap().

1476  {
1477  ASSERTL0((GetEdgeBasisType(localVertexId)==LibUtilities::eModified_A)||
1478  (GetEdgeBasisType(localVertexId)==LibUtilities::eModified_B)||
1479  (GetEdgeBasisType(localVertexId)==LibUtilities::eModified_C),
1480  "Mapping not defined for this type of basis");
1481 
1482  int localDOF = 0;
1483  if(useCoeffPacking == true) // follow packing of coefficients i.e q,r,p
1484  {
1485  switch(localVertexId)
1486  {
1487  case 0:
1488  {
1489  localDOF = GetMode(0,0,0);
1490  break;
1491  }
1492  case 1:
1493  {
1494  localDOF = GetMode(0,0,1);
1495  break;
1496  }
1497  case 2:
1498  {
1499  localDOF = GetMode(0,1,0);
1500  break;
1501  }
1502  case 3:
1503  {
1504  localDOF = GetMode(1,0,0);
1505  break;
1506  }
1507  default:
1508  {
1509  ASSERTL0(false,"Vertex ID must be between 0 and 3");
1510  break;
1511  }
1512  }
1513  }
1514  else
1515  {
1516  switch(localVertexId)
1517  {
1518  case 0:
1519  {
1520  localDOF = GetMode(0,0,0);
1521  break;
1522  }
1523  case 1:
1524  {
1525  localDOF = GetMode(1,0,0);
1526  break;
1527  }
1528  case 2:
1529  {
1530  localDOF = GetMode(0,1,0);
1531  break;
1532  }
1533  case 3:
1534  {
1535  localDOF = GetMode(0,0,1);
1536  break;
1537  }
1538  default:
1539  {
1540  ASSERTL0(false,"Vertex ID must be between 0 and 3");
1541  break;
1542  }
1543  }
1544 
1545  }
1546 
1547  return localDOF;
1548  }
Nektar::StdRegions::StdTetExp::GetMode
int GetMode(const int i, const int j, const int k)
Compute the mode number in the expansion for a particular tensorial combination.
Definition: StdTetExp.cpp:1981
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:216
Nektar::LibUtilities::eModified_C
Principle Modified Functions .
Definition: BasisType.h:50
Nektar::LibUtilities::eModified_A
Principle Modified Functions .
Definition: BasisType.h:48
Nektar::LibUtilities::eModified_B
Principle Modified Functions .
Definition: BasisType.h:49
Nektar::StdRegions::StdExpansion::GetEdgeBasisType
LibUtilities::BasisType GetEdgeBasisType(const int i) const
This function returns the type of expansion basis on the i-th edge.
Definition: StdExpansion.h:412

◆ v_IProductWRTBase()

void Nektar::StdRegions::StdTetExp::v_IProductWRTBase ( const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray 
)
protectedvirtual

\( \begin{array}{rcl} I_{pqr} = (\phi_{pqr}, u)_{\delta} & = & \sum_{i=0}^{nq_0} \sum_{j=0}^{nq_1} \sum_{k=0}^{nq_2} \psi_{p}^{a} (\eta_{1i}) \psi_{pq}^{b} (\eta_{2j}) \psi_{pqr}^{c} (\eta_{3k}) w_i w_j w_k u(\eta_{1,i} \eta_{2,j} \eta_{3,k}) J_{i,j,k}\\ & = & \sum_{i=0}^{nq_0} \psi_p^a(\eta_{1,i}) \sum_{j=0}^{nq_1} \psi_{pq}^b(\eta_{2,j}) \sum_{k=0}^{nq_2} \psi_{pqr}^c u(\eta_{1i},\eta_{2j},\eta_{3k}) J_{i,j,k} \end{array} \)
where

\( \phi_{pqr} (\xi_1 , \xi_2 , \xi_3) = \psi_p^a (\eta_1) \psi_{pq}^b (\eta_2) \psi_{pqr}^c (\eta_3) \)

which can be implemented as
\(f_{pqr} (\xi_{3k}) = \sum_{k=0}^{nq_3} \psi_{pqr}^c u(\eta_{1i},\eta_{2j},\eta_{3k}) J_{i,j,k} = {\bf B_3 U} \)
\( g_{pq} (\xi_{3k}) = \sum_{j=0}^{nq_1} \psi_{pq}^b (\xi_{2j}) f_{pqr} (\xi_{3k}) = {\bf B_2 F} \)
\( (\phi_{pqr}, u)_{\delta} = \sum_{k=0}^{nq_0} \psi_{p}^a (\xi_{3k}) g_{pq} (\xi_{3k}) = {\bf B_1 G} \)

Parameters
inarrayFunction evaluated at physical collocation points.
outarrayInner product with respect to each basis function over the element.

Implements Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::StdRegions::StdNodalTetExp, and Nektar::LocalRegions::TetExp.

Definition at line 507 of file StdTetExp.cpp.

References ASSERTL1, Nektar::LibUtilities::eModified_B, Nektar::LibUtilities::eModified_C, Nektar::LibUtilities::eOrtho_B, Nektar::LibUtilities::eOrtho_C, Nektar::StdRegions::StdExpansion::GetBasisType(), Nektar::StdRegions::StdExpansion::m_base, Nektar::StdRegions::StdExpansion::MultiplyByQuadratureMetric(), and v_IProductWRTBase_SumFac().

Referenced by DetShapeType(), and v_FwdTrans().

510  {
511  ASSERTL1( (m_base[1]->GetBasisType() != LibUtilities::eOrtho_B) ||
512  (m_base[1]->GetBasisType() != LibUtilities::eModified_B),
513  "Basis[1] is not a general tensor type");
514 
515  ASSERTL1( (m_base[2]->GetBasisType() != LibUtilities::eOrtho_C) ||
516  (m_base[2]->GetBasisType() != LibUtilities::eModified_C),
517  "Basis[2] is not a general tensor type");
518 
519  if(m_base[0]->Collocation() && m_base[1]->Collocation())
520  {
521  MultiplyByQuadratureMetric(inarray,outarray);
522  }
523  else
524  {
525  StdTetExp::v_IProductWRTBase_SumFac(inarray,outarray);
526  }
527  }
Nektar::LibUtilities::eModified_C
Principle Modified Functions .
Definition: BasisType.h:50
Nektar::StdRegions::StdExpansion::MultiplyByQuadratureMetric
void MultiplyByQuadratureMetric(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
Definition: StdExpansion.h:945
Nektar::StdRegions::StdTetExp::v_IProductWRTBase_SumFac
virtual void v_IProductWRTBase_SumFac(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, bool multiplybyweights=true)
Definition: StdTetExp.cpp:549
Nektar::LibUtilities::eOrtho_B
Principle Orthogonal Functions .
Definition: BasisType.h:46
Nektar::LibUtilities::eModified_B
Principle Modified Functions .
Definition: BasisType.h:49
Nektar::LibUtilities::eOrtho_C
Principle Orthogonal Functions .
Definition: BasisType.h:47
Nektar::StdRegions::StdExpansion::GetBasisType
LibUtilities::BasisType GetBasisType(const int dir) const
This function returns the type of basis used in the dir direction.
Definition: StdExpansion.h:164
ASSERTL1
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:250
Nektar::StdRegions::StdExpansion::m_base
Array< OneD, LibUtilities::BasisSharedPtr > m_base
Definition: StdExpansion.h:1429

◆ v_IProductWRTBase_MatOp()

void Nektar::StdRegions::StdTetExp::v_IProductWRTBase_MatOp ( const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray 
)
protectedvirtual

Definition at line 530 of file StdTetExp.cpp.

References DetShapeType(), Blas::Dgemv(), Nektar::StdRegions::eIProductWRTBase, Nektar::StdRegions::StdExpansion::GetStdMatrix(), Nektar::StdRegions::StdExpansion::GetTotPoints(), and Nektar::StdRegions::StdExpansion::m_ncoeffs.

Referenced by DetShapeType().

533  {
534  int nq = GetTotPoints();
535  StdMatrixKey iprodmatkey(eIProductWRTBase,DetShapeType(),*this);
536  DNekMatSharedPtr iprodmat = GetStdMatrix(iprodmatkey);
537 
538  Blas::Dgemv('N',m_ncoeffs,nq,1.0,iprodmat->GetPtr().get(),
539  m_ncoeffs, inarray.get(), 1, 0.0, outarray.get(), 1);
540  }
Nektar::StdRegions::StdTetExp::DetShapeType
LibUtilities::ShapeType DetShapeType() const
Definition: StdTetExp.h:69
Nektar::DNekMatSharedPtr
std::shared_ptr< DNekMat > DNekMatSharedPtr
Definition: NekTypeDefs.hpp:69
Nektar::StdRegions::StdExpansion::GetStdMatrix
DNekMatSharedPtr GetStdMatrix(const StdMatrixKey &mkey)
Definition: StdExpansion.h:714
Blas::Dgemv
static void Dgemv(const char &trans, const int &m, const int &n, const double &alpha, const double *a, const int &lda, const double *x, const int &incx, const double &beta, double *y, const int &incy)
BLAS level 2: Matrix vector multiply y = A x where A[m x n].
Definition: Blas.hpp:168
Nektar::StdRegions::StdExpansion::GetTotPoints
int GetTotPoints() const
This function returns the total number of quadrature points used in the element.
Definition: StdExpansion.h:140

◆ v_IProductWRTBase_SumFac()

void Nektar::StdRegions::StdTetExp::v_IProductWRTBase_SumFac ( const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray,
bool  multiplybyweights = true 
)
protectedvirtual
Parameters
inarrayFunction evaluated at physical collocation points.
outarrayInner product with respect to each basis function over the element.

Reimplemented from Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::StdRegions::StdNodalTetExp, and Nektar::LocalRegions::TetExp.

Definition at line 549 of file StdTetExp.cpp.

References Nektar::StdRegions::StdExpansion3D::IProductWRTBase_SumFacKernel(), Nektar::StdRegions::StdExpansion::m_base, and Nektar::StdRegions::StdExpansion::MultiplyByQuadratureMetric().

Referenced by DetShapeType(), v_IProductWRTBase(), and Nektar::StdRegions::StdNodalTetExp::v_IProductWRTBase_SumFac().

553  {
554  int nquad0 = m_base[0]->GetNumPoints();
555  int nquad1 = m_base[1]->GetNumPoints();
556  int nquad2 = m_base[2]->GetNumPoints();
557  int order0 = m_base[0]->GetNumModes();
558  int order1 = m_base[1]->GetNumModes();
559 
560  Array<OneD, NekDouble> wsp (nquad1*nquad2*order0 +
561  nquad2*order0*(2*order1-order0+1)/2);
562 
563  if(multiplybyweights)
564  {
565  Array<OneD, NekDouble> tmp (nquad0*nquad1*nquad2);
566  MultiplyByQuadratureMetric(inarray, tmp);
567 
568  StdTetExp::IProductWRTBase_SumFacKernel(
569  m_base[0]->GetBdata(),
570  m_base[1]->GetBdata(),
571  m_base[2]->GetBdata(),
572  tmp, outarray, wsp, true, true, true);
573  }
574  else
575  {
576  StdTetExp::IProductWRTBase_SumFacKernel(
577  m_base[0]->GetBdata(),
578  m_base[1]->GetBdata(),
579  m_base[2]->GetBdata(),
580  inarray, outarray, wsp, true, true, true);
581  }
582  }
Nektar::StdRegions::StdExpansion::MultiplyByQuadratureMetric
void MultiplyByQuadratureMetric(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
Definition: StdExpansion.h:945
Nektar::StdRegions::StdExpansion3D::IProductWRTBase_SumFacKernel
void IProductWRTBase_SumFacKernel(const Array< OneD, const NekDouble > &base0, const Array< OneD, const NekDouble > &base1, const Array< OneD, const NekDouble > &base2, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, Array< OneD, NekDouble > &wsp, bool doCheckCollDir0, bool doCheckCollDir1, bool doCheckCollDir2)
Definition: StdExpansion3D.cpp:128
Nektar::StdRegions::StdExpansion::m_base
Array< OneD, LibUtilities::BasisSharedPtr > m_base
Definition: StdExpansion.h:1429

◆ v_IProductWRTBase_SumFacKernel()

void Nektar::StdRegions::StdTetExp::v_IProductWRTBase_SumFacKernel ( const Array< OneD, const NekDouble > &  base0,
const Array< OneD, const NekDouble > &  base1,
const Array< OneD, const NekDouble > &  base2,
const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray,
Array< OneD, NekDouble > &  wsp,
bool  doCheckCollDir0,
bool  doCheckCollDir1,
bool  doCheckCollDir2 
)
protectedvirtual

Implements Nektar::StdRegions::StdExpansion3D.

Definition at line 585 of file StdTetExp.cpp.

References Blas::Ddot(), Blas::Dgemm(), Blas::Dgemv(), Nektar::LibUtilities::eModified_A, Nektar::StdRegions::StdExpansion::GetBasisType(), and Nektar::StdRegions::StdExpansion::m_base.

Referenced by DetShapeType().

595  {
596  boost::ignore_unused(doCheckCollDir0, doCheckCollDir1,
597  doCheckCollDir2);
598 
599  int nquad0 = m_base[0]->GetNumPoints();
600  int nquad1 = m_base[1]->GetNumPoints();
601  int nquad2 = m_base[2]->GetNumPoints();
602 
603  int order0 = m_base[0]->GetNumModes();
604  int order1 = m_base[1]->GetNumModes();
605  int order2 = m_base[2]->GetNumModes();
606 
607  Array<OneD, NekDouble > tmp1 = wsp;
608  Array<OneD, NekDouble > tmp2 = wsp + nquad1*nquad2*order0;
609 
610  int i,j, mode,mode1, cnt;
611 
612  // Inner product with respect to the '0' direction
613  Blas::Dgemm('T', 'N', nquad1*nquad2, order0, nquad0,
614  1.0, inarray.get(), nquad0,
615  base0.get(), nquad0,
616  0.0, tmp1.get(), nquad1*nquad2);
617 
618  // Inner product with respect to the '1' direction
619  for(mode=i=0; i < order0; ++i)
620  {
621  Blas::Dgemm('T', 'N', nquad2, order1-i, nquad1,
622  1.0, tmp1.get()+i*nquad1*nquad2, nquad1,
623  base1.get()+mode*nquad1, nquad1,
624  0.0, tmp2.get()+mode*nquad2, nquad2);
625  mode += order1-i;
626  }
627 
628  // fix for modified basis for base singular vertex
629  if(m_base[0]->GetBasisType() == LibUtilities::eModified_A)
630  {
631  //base singular vertex and singular edge (1+b)/2
632  //(1+a)/2 components (makes tmp[nquad2] entry into (1+b)/2)
633  Blas::Dgemv('T', nquad1, nquad2,
634  1.0, tmp1.get()+nquad1*nquad2, nquad1,
635  base1.get()+nquad1, 1,
636  1.0, tmp2.get()+nquad2, 1);
637  }
638 
639  // Inner product with respect to the '2' direction
640  mode = mode1 = cnt = 0;
641  for(i = 0; i < order0; ++i)
642  {
643  for(j = 0; j < order1-i; ++j, ++cnt)
644  {
645  Blas::Dgemv('T', nquad2, order2-i-j,
646  1.0, base2.get()+mode*nquad2, nquad2,
647  tmp2.get()+cnt*nquad2, 1,
648  0.0, outarray.get()+mode1, 1);
649  mode += order2-i-j;
650  mode1 += order2-i-j;
651  }
652  //increment mode in case order1!=order2
653  for(j = order1-i; j < order2-i; ++j)
654  {
655  mode += order2-i-j;
656  }
657  }
658 
659  // fix for modified basis for top singular vertex component
660  // Already have evaluated (1+c)/2 (1-b)/2 (1-a)/2
661  if(m_base[0]->GetBasisType() == LibUtilities::eModified_A)
662  {
663  // add in (1+c)/2 (1+b)/2 component
664  outarray[1] += Blas::Ddot(nquad2,base2.get()+nquad2,1,
665  &tmp2[nquad2],1);
666 
667  // add in (1+c)/2 (1-b)/2 (1+a)/2 component
668  outarray[1] += Blas::Ddot(nquad2,base2.get()+nquad2,1,
669  &tmp2[nquad2*order1],1);
670  }
671  }
Nektar::LibUtilities::eModified_A
Principle Modified Functions .
Definition: BasisType.h:48
Blas::Dgemm
static void Dgemm(const char &transa, const char &transb, const int &m, const int &n, const int &k, const double &alpha, const double *a, const int &lda, const double *b, const int &ldb, const double &beta, double *c, const int &ldc)
BLAS level 3: Matrix-matrix multiply C = A x B where A[m x n], B[n x k], C[m x k].
Definition: Blas.hpp:213
Blas::Dgemv
static void Dgemv(const char &trans, const int &m, const int &n, const double &alpha, const double *a, const int &lda, const double *x, const int &incx, const double &beta, double *y, const int &incy)
BLAS level 2: Matrix vector multiply y = A x where A[m x n].
Definition: Blas.hpp:168
Blas::Ddot
static double Ddot(const int &n, const double *x, const int &incx, const double *y, const int &incy)
BLAS level 1: output = .
Definition: Blas.hpp:140
Nektar::StdRegions::StdExpansion::GetBasisType
LibUtilities::BasisType GetBasisType(const int dir) const
This function returns the type of basis used in the dir direction.
Definition: StdExpansion.h:164
Nektar::StdRegions::StdExpansion::m_base
Array< OneD, LibUtilities::BasisSharedPtr > m_base
Definition: StdExpansion.h:1429

◆ v_IProductWRTDerivBase()

void Nektar::StdRegions::StdTetExp::v_IProductWRTDerivBase ( const int  dir,
const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray 
)
protectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::StdRegions::StdNodalTetExp, and Nektar::LocalRegions::TetExp.

Definition at line 674 of file StdTetExp.cpp.

References v_IProductWRTDerivBase_SumFac().

Referenced by DetShapeType().

678  {
679  StdTetExp::v_IProductWRTDerivBase_SumFac(dir,inarray,outarray);
680  }
Nektar::StdRegions::StdTetExp::v_IProductWRTDerivBase_SumFac
virtual void v_IProductWRTDerivBase_SumFac(const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
Definition: StdTetExp.cpp:720

◆ v_IProductWRTDerivBase_MatOp()

void Nektar::StdRegions::StdTetExp::v_IProductWRTDerivBase_MatOp ( const int  dir,
const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray 
)
protectedvirtual

Definition at line 683 of file StdTetExp.cpp.

References ASSERTL0, DetShapeType(), Blas::Dgemv(), Nektar::StdRegions::eIProductWRTDerivBase0, Nektar::StdRegions::eIProductWRTDerivBase1, Nektar::StdRegions::eIProductWRTDerivBase2, Nektar::StdRegions::StdExpansion::GetStdMatrix(), Nektar::StdRegions::StdExpansion::GetTotPoints(), and Nektar::StdRegions::StdExpansion::m_ncoeffs.

Referenced by DetShapeType().

687  {
688  ASSERTL0((dir==0)||(dir==1)||(dir==2),"input dir is out of range");
689 
690  int nq = GetTotPoints();
691  MatrixType mtype = eIProductWRTDerivBase0;
692 
693  switch (dir)
694  {
695  case 0:
696  mtype = eIProductWRTDerivBase0;
697  break;
698  case 1:
699  mtype = eIProductWRTDerivBase1;
700  break;
701  case 2:
702  mtype = eIProductWRTDerivBase2;
703  break;
704  }
705 
706  StdMatrixKey iprodmatkey(mtype,DetShapeType(),*this);
707  DNekMatSharedPtr iprodmat = GetStdMatrix(iprodmatkey);
708 
709  Blas::Dgemv('N',m_ncoeffs,nq,1.0,iprodmat->GetPtr().get(),
710  m_ncoeffs, inarray.get(), 1, 0.0, outarray.get(), 1);
711  }
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:216
Nektar::StdRegions::StdTetExp::DetShapeType
LibUtilities::ShapeType DetShapeType() const
Definition: StdTetExp.h:69
Nektar::DNekMatSharedPtr
std::shared_ptr< DNekMat > DNekMatSharedPtr
Definition: NekTypeDefs.hpp:69
Nektar::StdRegions::StdExpansion::GetStdMatrix
DNekMatSharedPtr GetStdMatrix(const StdMatrixKey &mkey)
Definition: StdExpansion.h:714
Blas::Dgemv
static void Dgemv(const char &trans, const int &m, const int &n, const double &alpha, const double *a, const int &lda, const double *x, const int &incx, const double &beta, double *y, const int &incy)
BLAS level 2: Matrix vector multiply y = A x where A[m x n].
Definition: Blas.hpp:168
Nektar::StdRegions::StdExpansion::GetTotPoints
int GetTotPoints() const
This function returns the total number of quadrature points used in the element.
Definition: StdExpansion.h:140

◆ v_IProductWRTDerivBase_SumFac()

void Nektar::StdRegions::StdTetExp::v_IProductWRTDerivBase_SumFac ( const int  dir,
const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray 
)
protectedvirtual
Parameters
inarrayFunction evaluated at physical collocation points.
outarrayInner product with respect to each basis function over the element.

Reimplemented from Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::StdRegions::StdNodalTetExp.

Definition at line 720 of file StdTetExp.cpp.

References ASSERTL1, Nektar::StdRegions::StdExpansion3D::IProductWRTBase_SumFacKernel(), Nektar::StdRegions::StdExpansion::m_base, Nektar::StdRegions::StdExpansion::m_ncoeffs, Nektar::StdRegions::StdExpansion::MultiplyByQuadratureMetric(), Vmath::Smul(), Vmath::Vadd(), and Vmath::Vmul().

Referenced by DetShapeType(), v_IProductWRTDerivBase(), and Nektar::StdRegions::StdNodalTetExp::v_IProductWRTDerivBase_SumFac().

724  {
725  int i;
726  int nquad0 = m_base[0]->GetNumPoints();
727  int nquad1 = m_base[1]->GetNumPoints();
728  int nquad2 = m_base[2]->GetNumPoints();
729  int nqtot = nquad0*nquad1*nquad2;
730  int nmodes0 = m_base[0]->GetNumModes();
731  int nmodes1 = m_base[1]->GetNumModes();
732  int wspsize = nquad0 + nquad1 + nquad2 + max(nqtot,m_ncoeffs)
733  + nquad1*nquad2*nmodes0 + nquad2*nmodes0*(2*nmodes1-nmodes0+1)/2;
734 
735  Array<OneD, NekDouble> gfac0(wspsize);
736  Array<OneD, NekDouble> gfac1(gfac0 + nquad0);
737  Array<OneD, NekDouble> gfac2(gfac1 + nquad1);
738  Array<OneD, NekDouble> tmp0 (gfac2 + nquad2);
739  Array<OneD, NekDouble> wsp(tmp0 + max(nqtot,m_ncoeffs));
740 
741  const Array<OneD, const NekDouble>& z0 = m_base[0]->GetZ();
742  const Array<OneD, const NekDouble>& z1 = m_base[1]->GetZ();
743  const Array<OneD, const NekDouble>& z2 = m_base[2]->GetZ();
744 
745  // set up geometric factor: (1+z0)/2
746  for(i = 0; i < nquad0; ++i)
747  {
748  gfac0[i] = 0.5*(1+z0[i]);
749  }
750 
751  // set up geometric factor: 2/(1-z1)
752  for(i = 0; i < nquad1; ++i)
753  {
754  gfac1[i] = 2.0/(1-z1[i]);
755  }
756 
757  // Set up geometric factor: 2/(1-z2)
758  for(i = 0; i < nquad2; ++i)
759  {
760  gfac2[i] = 2.0/(1-z2[i]);
761  }
762 
763  // Derivative in first direction is always scaled as follows
764  for(i = 0; i < nquad1*nquad2; ++i)
765  {
766  Vmath::Smul(nquad0,gfac1[i%nquad1],&inarray[0]+i*nquad0,1,&tmp0[0]+i*nquad0,1);
767  }
768  for(i = 0; i < nquad2; ++i)
769  {
770  Vmath::Smul(nquad0*nquad1,gfac2[i],&tmp0[0]+i*nquad0*nquad1,1,&tmp0[0]+i*nquad0*nquad1,1);
771  }
772 
773  MultiplyByQuadratureMetric(tmp0,tmp0);
774 
775  switch(dir)
776  {
777  case 0:
778  {
779  IProductWRTBase_SumFacKernel(m_base[0]->GetDbdata(),
780  m_base[1]->GetBdata(),
781  m_base[2]->GetBdata(),
782  tmp0,outarray,wsp,
783  false, true, true);
784  }
785  break;
786  case 1:
787  {
788  Array<OneD, NekDouble> tmp3(m_ncoeffs);
789 
790  for(i = 0; i < nquad1*nquad2; ++i)
791  {
792  Vmath::Vmul(nquad0,&gfac0[0],1,&tmp0[0]+i*nquad0,1,&tmp0[0]+i*nquad0,1);
793  }
794 
795  IProductWRTBase_SumFacKernel(m_base[0]->GetDbdata(),
796  m_base[1]->GetBdata(),
797  m_base[2]->GetBdata(),
798  tmp0,tmp3,wsp,
799  false, true, true);
800 
801  for(i = 0; i < nquad2; ++i)
802  {
803  Vmath::Smul(nquad0*nquad1,gfac2[i],&inarray[0]+i*nquad0*nquad1,1,&tmp0[0]+i*nquad0*nquad1,1);
804  }
805  MultiplyByQuadratureMetric(tmp0,tmp0);
806  IProductWRTBase_SumFacKernel(m_base[0]->GetBdata(),
807  m_base[1]->GetDbdata(),
808  m_base[2]->GetBdata(),
809  tmp0,outarray,wsp,
810  true, false, true);
811  Vmath::Vadd(m_ncoeffs,&tmp3[0],1,&outarray[0],1,&outarray[0],1);
812  }
813  break;
814  case 2:
815  {
816  Array<OneD, NekDouble> tmp3(m_ncoeffs);
817  Array<OneD, NekDouble> tmp4(m_ncoeffs);
818  for(i = 0; i < nquad1; ++i)
819  {
820  gfac1[i] = (1+z1[i])/2;
821  }
822 
823  for(i = 0; i < nquad1*nquad2; ++i)
824  {
825  Vmath::Vmul(nquad0,&gfac0[0],1,&tmp0[0]+i*nquad0,1,&tmp0[0]+i*nquad0,1);
826  }
827  IProductWRTBase_SumFacKernel(m_base[0]->GetDbdata(),
828  m_base[1]->GetBdata(),
829  m_base[2]->GetBdata(),
830  tmp0,tmp3,wsp,
831  false, true, true);
832 
833  for(i = 0; i < nquad2; ++i)
834  {
835  Vmath::Smul(nquad0*nquad1,gfac2[i],&inarray[0]+i*nquad0*nquad1,1,&tmp0[0]+i*nquad0*nquad1,1);
836  }
837  for(i = 0; i < nquad1*nquad2; ++i)
838  {
839  Vmath::Smul(nquad0,gfac1[i%nquad1],&tmp0[0]+i*nquad0,1,&tmp0[0]+i*nquad0,1);
840  }
841  MultiplyByQuadratureMetric(tmp0,tmp0);
842  IProductWRTBase_SumFacKernel(m_base[0]->GetBdata(),
843  m_base[1]->GetDbdata(),
844  m_base[2]->GetBdata(),
845  tmp0,tmp4,wsp,
846  true, false, true);
847 
848  MultiplyByQuadratureMetric(inarray,tmp0);
849  IProductWRTBase_SumFacKernel(m_base[0]->GetBdata(),
850  m_base[1]->GetBdata(),
851  m_base[2]->GetDbdata(),
852  tmp0,outarray,wsp,
853  true, true, false);
854 
855  Vmath::Vadd(m_ncoeffs,&tmp3[0],1,&outarray[0],1,&outarray[0],1);
856  Vmath::Vadd(m_ncoeffs,&tmp4[0],1,&outarray[0],1,&outarray[0],1);
857  }
858  break;
859  default:
860  {
861  ASSERTL1(false, "input dir is out of range");
862  }
863  break;
864  }
865  }
Nektar::StdRegions::StdExpansion::MultiplyByQuadratureMetric
void MultiplyByQuadratureMetric(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
Definition: StdExpansion.h:945
Nektar::StdRegions::StdExpansion3D::IProductWRTBase_SumFacKernel
void IProductWRTBase_SumFacKernel(const Array< OneD, const NekDouble > &base0, const Array< OneD, const NekDouble > &base1, const Array< OneD, const NekDouble > &base2, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, Array< OneD, NekDouble > &wsp, bool doCheckCollDir0, bool doCheckCollDir1, bool doCheckCollDir2)
Definition: StdExpansion3D.cpp:128
Vmath::Smul
void Smul(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Scalar multiply y = alpha*y.
Definition: Vmath.cpp:216
ASSERTL1
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:250
Nektar::StdRegions::StdExpansion::m_base
Array< OneD, LibUtilities::BasisSharedPtr > m_base
Definition: StdExpansion.h:1429
Vmath::Vadd
void Vadd(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Add vector z = x+y.
Definition: Vmath.cpp:302
Vmath::Vmul
void Vmul(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Multiply vector z = x*y.
Definition: Vmath.cpp:186

◆ v_IsBoundaryInteriorExpansion()

bool Nektar::StdRegions::StdTetExp::v_IsBoundaryInteriorExpansion ( )
protectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 1231 of file StdTetExp.cpp.

References Nektar::LibUtilities::eModified_A, Nektar::LibUtilities::eModified_B, Nektar::LibUtilities::eModified_C, Nektar::StdRegions::StdExpansion::GetBasisType(), and Nektar::StdRegions::StdExpansion::m_base.

Referenced by DetShapeType(), v_GetEdgeToElementMap(), and v_GetFaceToElementMap().

1232  {
1233  return (m_base[0]->GetBasisType() == LibUtilities::eModified_A) &&
1234  (m_base[1]->GetBasisType() == LibUtilities::eModified_B) &&
1235  (m_base[2]->GetBasisType() == LibUtilities::eModified_C);
1236  }
Nektar::LibUtilities::eModified_C
Principle Modified Functions .
Definition: BasisType.h:50
Nektar::LibUtilities::eModified_A
Principle Modified Functions .
Definition: BasisType.h:48
Nektar::LibUtilities::eModified_B
Principle Modified Functions .
Definition: BasisType.h:49
Nektar::StdRegions::StdExpansion::GetBasisType
LibUtilities::BasisType GetBasisType(const int dir) const
This function returns the type of basis used in the dir direction.
Definition: StdExpansion.h:164
Nektar::StdRegions::StdExpansion::m_base
Array< OneD, LibUtilities::BasisSharedPtr > m_base
Definition: StdExpansion.h:1429

◆ v_LocCoordToLocCollapsed()

void Nektar::StdRegions::StdTetExp::v_LocCoordToLocCollapsed ( const Array< OneD, const NekDouble > &  xi,
Array< OneD, NekDouble > &  eta 
)
protectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 873 of file StdTetExp.cpp.

References Nektar::NekConstants::kNekZeroTol.

Referenced by DetShapeType().

876  {
877  if( fabs(xi[2]-1.0) < NekConstants::kNekZeroTol)
878  {
879  // Very top point of the tetrahedron
880  eta[0] = -1.0;
881  eta[1] = -1.0;
882  eta[2] = xi[2];
883  }
884  else
885  {
886  if( fabs(xi[1]-1.0) < NekConstants::kNekZeroTol )
887  {
888  // Distant diagonal edge shared by all eta_x
889  // coordinate planes: the xi_y == -xi_z line
890  eta[0] = -1.0;
891  }
892  else if (fabs(xi[1] + xi[2]) < NekConstants::kNekZeroTol)
893  {
894  eta[0] = -1.0;
895  }
896  else
897  {
898  eta[0] = 2.0*(1.0+xi[0])/(-xi[1]-xi[2]) - 1.0;
899  }
900  eta[1] = 2.0*(1.0+xi[1])/(1.0-xi[2]) - 1.0;
901  eta[2] = xi[2];
902  }
903  }
Nektar::NekConstants::kNekZeroTol
static const NekDouble kNekZeroTol
Definition: NektarUnivConsts.hpp:50

◆ v_MultiplyByStdQuadratureMetric()

void Nektar::StdRegions::StdTetExp::v_MultiplyByStdQuadratureMetric ( const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray 
)
protectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 2013 of file StdTetExp.cpp.

References Blas::Dscal(), Nektar::LibUtilities::eGaussRadauMAlpha1Beta0, Nektar::LibUtilities::eGaussRadauMAlpha2Beta0, Nektar::StdRegions::StdExpansion::GetPointsType(), Nektar::StdRegions::StdExpansion::m_base, and Vmath::Vmul().

Referenced by DetShapeType().

2016  {
2017  int i, j;
2018 
2019  int nquad0 = m_base[0]->GetNumPoints();
2020  int nquad1 = m_base[1]->GetNumPoints();
2021  int nquad2 = m_base[2]->GetNumPoints();
2022 
2023  const Array<OneD, const NekDouble>& w0 = m_base[0]->GetW();
2024  const Array<OneD, const NekDouble>& w1 = m_base[1]->GetW();
2025  const Array<OneD, const NekDouble>& w2 = m_base[2]->GetW();
2026 
2027  const Array<OneD, const NekDouble>& z1 = m_base[1]->GetZ();
2028  const Array<OneD, const NekDouble>& z2 = m_base[2]->GetZ();
2029 
2030  // multiply by integration constants
2031  for(i = 0; i < nquad1*nquad2; ++i)
2032  {
2033  Vmath::Vmul(nquad0,(NekDouble*)&inarray[0]+i*nquad0,1,
2034  w0.get(),1, &outarray[0]+i*nquad0,1);
2035  }
2036 
2037  switch(m_base[1]->GetPointsType())
2038  {
2039  // (1,0) Jacobi Inner product.
2040  case LibUtilities::eGaussRadauMAlpha1Beta0:
2041  for(j = 0; j < nquad2; ++j)
2042  {
2043  for(i = 0; i < nquad1; ++i)
2044  {
2045  Blas::Dscal(nquad0,0.5*w1[i], &outarray[0]+i*nquad0+
2046  j*nquad0*nquad1,1);
2047  }
2048  }
2049  break;
2050 
2051  default:
2052  for(j = 0; j < nquad2; ++j)
2053  {
2054  for(i = 0; i < nquad1; ++i)
2055  {
2056  Blas::Dscal(nquad0,
2057  0.5*(1-z1[i])*w1[i],
2058  &outarray[0]+i*nquad0 + j*nquad0*nquad1,
2059  1 );
2060  }
2061  }
2062  break;
2063  }
2064 
2065  switch(m_base[2]->GetPointsType())
2066  {
2067  // (2,0) Jacobi inner product.
2068  case LibUtilities::eGaussRadauMAlpha2Beta0:
2069  for(i = 0; i < nquad2; ++i)
2070  {
2071  Blas::Dscal(nquad0*nquad1, 0.25*w2[i],
2072  &outarray[0]+i*nquad0*nquad1, 1);
2073  }
2074  break;
2075  // (1,0) Jacobi inner product.
2076  case LibUtilities::eGaussRadauMAlpha1Beta0:
2077  for(i = 0; i < nquad2; ++i)
2078  {
2079  Blas::Dscal(nquad0*nquad1, 0.25*(1-z2[i])*w2[i],
2080  &outarray[0]+i*nquad0*nquad1, 1);
2081  }
2082  break;
2083  default:
2084  for(i = 0; i < nquad2; ++i)
2085  {
2086  Blas::Dscal(nquad0*nquad1,0.25*(1-z2[i])*(1-z2[i])*w2[i],
2087  &outarray[0]+i*nquad0*nquad1,1);
2088  }
2089  break;
2090  }
2091  }
Nektar::LibUtilities::eGaussRadauMAlpha1Beta0
Gauss Radau pinned at x=-1, .
Definition: PointsType.h:58
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:43
Blas::Dscal
static void Dscal(const int &n, const double &alpha, double *x, const int &incx)
BLAS level 1: x = alpha x.
Definition: Blas.hpp:125
Nektar::StdRegions::StdExpansion::GetPointsType
LibUtilities::PointsType GetPointsType(const int dir) const
This function returns the type of quadrature points used in the dir direction.
Definition: StdExpansion.h:215
Nektar::LibUtilities::eGaussRadauMAlpha2Beta0
Gauss Radau pinned at x=-1, .
Definition: PointsType.h:59
Nektar::StdRegions::StdExpansion::m_base
Array< OneD, LibUtilities::BasisSharedPtr > m_base
Definition: StdExpansion.h:1429
Vmath::Vmul
void Vmul(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Multiply vector z = x*y.
Definition: Vmath.cpp:186

◆ v_NumBndryCoeffs()

int Nektar::StdRegions::StdTetExp::v_NumBndryCoeffs ( ) const
protectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 973 of file StdTetExp.cpp.

References ASSERTL1, Nektar::LibUtilities::eGLL_Lagrange, Nektar::LibUtilities::eModified_A, Nektar::LibUtilities::eModified_B, Nektar::LibUtilities::eModified_C, Nektar::StdRegions::StdExpansion::GetBasisType(), Nektar::LibUtilities::StdTetData::getNumberOfBndCoefficients(), Nektar::StdRegions::StdExpansion::m_base, and class_topology::P.

Referenced by DetShapeType().

974  {
975  ASSERTL1(GetBasisType(0) == LibUtilities::eModified_A ||
976  GetBasisType(0) == LibUtilities::eGLL_Lagrange,
977  "BasisType is not a boundary interior form");
978  ASSERTL1(GetBasisType(1) == LibUtilities::eModified_B ||
979  GetBasisType(1) == LibUtilities::eGLL_Lagrange,
980  "BasisType is not a boundary interior form");
981  ASSERTL1(GetBasisType(2) == LibUtilities::eModified_C ||
982  GetBasisType(2) == LibUtilities::eGLL_Lagrange,
983  "BasisType is not a boundary interior form");
984 
985  int P = m_base[0]->GetNumModes();
986  int Q = m_base[1]->GetNumModes();
987  int R = m_base[2]->GetNumModes();
988 
989  return LibUtilities::StdTetData::
990  getNumberOfBndCoefficients(P, Q, R);
991  }
Nektar::LibUtilities::eModified_C
Principle Modified Functions .
Definition: BasisType.h:50
Nektar::LibUtilities::eModified_A
Principle Modified Functions .
Definition: BasisType.h:48
class_topology.P
P
Definition: class_topology.py:290
Nektar::LibUtilities::eModified_B
Principle Modified Functions .
Definition: BasisType.h:49
Nektar::StdRegions::StdExpansion::GetBasisType
LibUtilities::BasisType GetBasisType(const int dir) const
This function returns the type of basis used in the dir direction.
Definition: StdExpansion.h:164
Nektar::LibUtilities::eGLL_Lagrange
Lagrange for SEM basis .
Definition: BasisType.h:54
ASSERTL1
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:250
Nektar::StdRegions::StdExpansion::m_base
Array< OneD, LibUtilities::BasisSharedPtr > m_base
Definition: StdExpansion.h:1429
Nektar::LibUtilities::StdTetData::getNumberOfBndCoefficients
int getNumberOfBndCoefficients(int Na, int Nb, int Nc)
Definition: ShapeType.hpp:217

◆ v_NumDGBndryCoeffs()

int Nektar::StdRegions::StdTetExp::v_NumDGBndryCoeffs ( ) const
protectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 993 of file StdTetExp.cpp.

References ASSERTL1, Nektar::LibUtilities::eGLL_Lagrange, Nektar::LibUtilities::eModified_A, Nektar::LibUtilities::eModified_B, Nektar::LibUtilities::eModified_C, Nektar::StdRegions::StdExpansion::GetBasisType(), Nektar::StdRegions::StdExpansion::m_base, and class_topology::P.

Referenced by DetShapeType().

994  {
995  ASSERTL1(GetBasisType(0) == LibUtilities::eModified_A ||
996  GetBasisType(0) == LibUtilities::eGLL_Lagrange,
997  "BasisType is not a boundary interior form");
998  ASSERTL1(GetBasisType(1) == LibUtilities::eModified_B ||
999  GetBasisType(1) == LibUtilities::eGLL_Lagrange,
1000  "BasisType is not a boundary interior form");
1001  ASSERTL1(GetBasisType(2) == LibUtilities::eModified_C ||
1002  GetBasisType(2) == LibUtilities::eGLL_Lagrange,
1003  "BasisType is not a boundary interior form");
1004 
1005  int P = m_base[0]->GetNumModes()-1;
1006  int Q = m_base[1]->GetNumModes()-1;
1007  int R = m_base[2]->GetNumModes()-1;
1008 
1009 
1010  return (Q+1) + P*(1 + 2*Q - P)/2 // base face
1011  + (R+1) + P*(1 + 2*R - P)/2 // front face
1012  + 2*(R+1) + Q*(1 + 2*R - Q); // back two faces
1013  }
Nektar::LibUtilities::eModified_C
Principle Modified Functions .
Definition: BasisType.h:50
Nektar::LibUtilities::eModified_A
Principle Modified Functions .
Definition: BasisType.h:48
class_topology.P
P
Definition: class_topology.py:290
Nektar::LibUtilities::eModified_B
Principle Modified Functions .
Definition: BasisType.h:49
Nektar::StdRegions::StdExpansion::GetBasisType
LibUtilities::BasisType GetBasisType(const int dir) const
This function returns the type of basis used in the dir direction.
Definition: StdExpansion.h:164
Nektar::LibUtilities::eGLL_Lagrange
Lagrange for SEM basis .
Definition: BasisType.h:54
ASSERTL1
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:250
Nektar::StdRegions::StdExpansion::m_base
Array< OneD, LibUtilities::BasisSharedPtr > m_base
Definition: StdExpansion.h:1429

◆ v_PhysDeriv() [1/2]

void Nektar::StdRegions::StdTetExp::v_PhysDeriv ( const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  out_dxi0,
Array< OneD, NekDouble > &  out_dxi1,
Array< OneD, NekDouble > &  out_dxi2 
)
protectedvirtual

Calculate the derivative of the physical points.

The derivative is evaluated at the nodal physical points. Derivatives with respect to the local Cartesian coordinates

\(\begin{Bmatrix} \frac {\partial} {\partial \xi_1} \\ \frac {\partial} {\partial \xi_2} \\ \frac {\partial} {\partial \xi_3} \end{Bmatrix} = \begin{Bmatrix} \frac 4 {(1-\eta_2)(1-\eta_3)} \frac \partial {\partial \eta_1} \ \ \frac {2(1+\eta_1)} {(1-\eta_2)(1-\eta_3)} \frac \partial {\partial \eta_1} + \frac 2 {1-\eta_3} \frac \partial {\partial \eta_3} \\ \frac {2(1 + \eta_1)} {2(1 - \eta_2)(1-\eta_3)} \frac \partial {\partial \eta_1} + \frac {1 + \eta_2} {1 - \eta_3} \frac \partial {\partial \eta_2} + \frac \partial {\partial \eta_3} \end{Bmatrix}\)

Reimplemented from Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::LocalRegions::TetExp.

Definition at line 107 of file StdTetExp.cpp.

References Nektar::StdRegions::StdExpansion::m_base, Nektar::NullNekDouble1DArray, Nektar::StdRegions::StdExpansion3D::PhysTensorDeriv(), Vmath::Sadd(), Vmath::Smul(), Vmath::Vadd(), and Vmath::Vmul().

Referenced by DetShapeType(), v_PhysDeriv(), and v_StdPhysDeriv().

112  {
113  int Q0 = m_base[0]->GetNumPoints();
114  int Q1 = m_base[1]->GetNumPoints();
115  int Q2 = m_base[2]->GetNumPoints();
116  int Qtot = Q0*Q1*Q2;
117 
118  // Compute the physical derivative
119  Array<OneD, NekDouble> out_dEta0(3*Qtot,0.0);
120  Array<OneD, NekDouble> out_dEta1 = out_dEta0 + Qtot;
121  Array<OneD, NekDouble> out_dEta2 = out_dEta1 + Qtot;
122 
123  bool Do_2 = (out_dxi2.num_elements() > 0)? true:false;
124  bool Do_1 = (out_dxi1.num_elements() > 0)? true:false;
125 
126  if(Do_2) // Need all local derivatives
127  {
128  PhysTensorDeriv(inarray, out_dEta0, out_dEta1, out_dEta2);
129  }
130  else if (Do_1) // Need 0 and 1 derivatives
131  {
132  PhysTensorDeriv(inarray, out_dEta0, out_dEta1, NullNekDouble1DArray);
133  }
134  else // Only need Eta0 derivaitve
135  {
136  PhysTensorDeriv(inarray, out_dEta0, NullNekDouble1DArray,
137  NullNekDouble1DArray);
138  }
139 
140  Array<OneD, const NekDouble> eta_0, eta_1, eta_2;
141  eta_0 = m_base[0]->GetZ();
142  eta_1 = m_base[1]->GetZ();
143  eta_2 = m_base[2]->GetZ();
144 
145  // calculate 2.0/((1-eta_1)(1-eta_2)) Out_dEta0
146 
147  NekDouble *dEta0 = &out_dEta0[0];
148  NekDouble fac;
149  for(int k=0; k< Q2; ++k)
150  {
151  for(int j=0; j<Q1; ++j,dEta0+=Q0)
152  {
153  Vmath::Smul(Q0,2.0/(1.0-eta_1[j]),dEta0,1,dEta0,1);
154  }
155  fac = 1.0/(1.0-eta_2[k]);
156  Vmath::Smul(Q0*Q1,fac,&out_dEta0[0]+k*Q0*Q1,1,&out_dEta0[0]+k*Q0*Q1,1);
157  }
158 
159  if (out_dxi0.num_elements() > 0)
160  {
161  // out_dxi0 = 4.0/((1-eta_1)(1-eta_2)) Out_dEta0
162  Vmath::Smul(Qtot,2.0,out_dEta0,1,out_dxi0,1);
163  }
164 
165  if (Do_1||Do_2)
166  {
167  Array<OneD, NekDouble> Fac0(Q0);
168  Vmath::Sadd(Q0,1.0,eta_0,1,Fac0,1);
169 
170 
171  // calculate 2.0*(1+eta_0)/((1-eta_1)(1-eta_2)) Out_dEta0
172  for(int k = 0; k < Q1*Q2; ++k)
173  {
174  Vmath::Vmul(Q0,&Fac0[0],1,&out_dEta0[0]+k*Q0,1,&out_dEta0[0]+k*Q0,1);
175  }
176  // calculate 2/(1.0-eta_2) out_dEta1
177  for(int k = 0; k < Q2; ++k)
178  {
179  Vmath::Smul(Q0*Q1,2.0/(1.0-eta_2[k]),&out_dEta1[0]+k*Q0*Q1,1,
180  &out_dEta1[0]+k*Q0*Q1,1);
181  }
182 
183  if(Do_1)
184  {
185  // calculate out_dxi1 = 2.0(1+eta_0)/((1-eta_1)(1-eta_2)) Out_dEta0
186  // + 2/(1.0-eta_2) out_dEta1
187  Vmath::Vadd(Qtot,out_dEta0,1,out_dEta1,1,out_dxi1,1);
188  }
189 
190 
191  if(Do_2)
192  {
193  // calculate (1 + eta_1)/(1 -eta_2)*out_dEta1
194  NekDouble *dEta1 = &out_dEta1[0];
195  for(int k=0; k< Q2; ++k)
196  {
197  for(int j=0; j<Q1; ++j,dEta1+=Q0)
198  {
199  Vmath::Smul(Q0,(1.0+eta_1[j])/2.0,dEta1,1,dEta1,1);
200  }
201  }
202 
203  // calculate out_dxi2 =
204  // 2.0(1+eta_0)/((1-eta_1)(1-eta_2)) Out_dEta0 +
205  // (1 + eta_1)/(1 -eta_2)*out_dEta1 + out_dEta2
206  Vmath::Vadd(Qtot,out_dEta0,1,out_dEta1,1,out_dxi2,1);
207  Vmath::Vadd(Qtot,out_dEta2,1,out_dxi2 ,1,out_dxi2,1);
208 
209  }
210  }
211  }
Nektar::NullNekDouble1DArray
static Array< OneD, NekDouble > NullNekDouble1DArray
Definition: SharedArray.hpp:787
Nektar::StdRegions::StdExpansion3D::PhysTensorDeriv
void PhysTensorDeriv(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray_d1, Array< OneD, NekDouble > &outarray_d2, Array< OneD, NekDouble > &outarray_d3)
Calculate the 3D derivative in the local tensor/collapsed coordinate at the physical points...
Definition: StdExpansion3D.cpp:69
Vmath::Smul
void Smul(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Scalar multiply y = alpha*y.
Definition: Vmath.cpp:216
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:43
Vmath::Sadd
void Sadd(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Add vector y = alpha + x.
Definition: Vmath.cpp:318
Nektar::StdRegions::StdExpansion::m_base
Array< OneD, LibUtilities::BasisSharedPtr > m_base
Definition: StdExpansion.h:1429
Vmath::Vadd
void Vadd(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Add vector z = x+y.
Definition: Vmath.cpp:302
Vmath::Vmul
void Vmul(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Multiply vector z = x*y.
Definition: Vmath.cpp:186

◆ v_PhysDeriv() [2/2]

void Nektar::StdRegions::StdTetExp::v_PhysDeriv ( const int  dir,
const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray 
)
protectedvirtual
Parameters
dirDirection in which to compute derivative. Valid values are 0, 1, 2.
inarrayInput array.
outarrayOutput array.

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 219 of file StdTetExp.cpp.

References ASSERTL1, Nektar::NullNekDouble1DArray, and v_PhysDeriv().

223  {
224  switch(dir)
225  {
226  case 0:
227  {
228  v_PhysDeriv(inarray, outarray, NullNekDouble1DArray,
229  NullNekDouble1DArray);
230  break;
231  }
232  case 1:
233  {
234  v_PhysDeriv(inarray, NullNekDouble1DArray, outarray,
235  NullNekDouble1DArray);
236  break;
237  }
238  case 2:
239  {
240  v_PhysDeriv(inarray, NullNekDouble1DArray,
241  NullNekDouble1DArray, outarray);
242  break;
243  }
244  default:
245  {
246  ASSERTL1(false, "input dir is out of range");
247  }
248  break;
249  }
250  }
Nektar::NullNekDouble1DArray
static Array< OneD, NekDouble > NullNekDouble1DArray
Definition: SharedArray.hpp:787
Nektar::StdRegions::StdTetExp::v_PhysDeriv
virtual void v_PhysDeriv(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_dx, Array< OneD, NekDouble > &out_dy, Array< OneD, NekDouble > &out_dz)
Calculate the derivative of the physical points.
Definition: StdTetExp.cpp:107
ASSERTL1
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode...
Definition: ErrorUtil.hpp:250

◆ v_ReduceOrderCoeffs()

void Nektar::StdRegions::StdTetExp::v_ReduceOrderCoeffs ( int  numMin,
const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray 
)
protectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 2232 of file StdTetExp.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::StdRegions::StdExpansion::BwdTrans(), Nektar::LibUtilities::eOrtho_A, Nektar::LibUtilities::eOrtho_B, Nektar::LibUtilities::eOrtho_C, Nektar::StdRegions::StdExpansion::FwdTrans(), Nektar::StdRegions::StdExpansion::m_base, Nektar::StdRegions::StdExpansion::m_ncoeffs, Vmath::Vcopy(), and Vmath::Zero().

Referenced by DetShapeType().

2236  {
2237  int nquad0 = m_base[0]->GetNumPoints();
2238  int nquad1 = m_base[1]->GetNumPoints();
2239  int nquad2 = m_base[2]->GetNumPoints();
2240  int nqtot = nquad0 * nquad1 * nquad2;
2241  int nmodes0 = m_base[0]->GetNumModes();
2242  int nmodes1 = m_base[1]->GetNumModes();
2243  int nmodes2 = m_base[2]->GetNumModes();
2244  int numMax = nmodes0;
2245 
2246  Array<OneD, NekDouble> coeff (m_ncoeffs);
2247  Array<OneD, NekDouble> coeff_tmp1(m_ncoeffs, 0.0);
2248  Array<OneD, NekDouble> coeff_tmp2(m_ncoeffs, 0.0);
2249  Array<OneD, NekDouble> phys_tmp (nqtot, 0.0);
2250  Array<OneD, NekDouble> tmp, tmp2, tmp3, tmp4;
2251 
2252  Vmath::Vcopy(m_ncoeffs,inarray,1,coeff_tmp2,1);
2253 
2254  const LibUtilities::PointsKey Pkey0 = m_base[0]->GetPointsKey();
2255  const LibUtilities::PointsKey Pkey1 = m_base[1]->GetPointsKey();
2256  const LibUtilities::PointsKey Pkey2 = m_base[2]->GetPointsKey();
2257 
2258  LibUtilities::BasisKey bortho0(LibUtilities::eOrtho_A,
2259  nmodes0, Pkey0);
2260  LibUtilities::BasisKey bortho1(LibUtilities::eOrtho_B,
2261  nmodes1, Pkey1);
2262  LibUtilities::BasisKey bortho2(LibUtilities::eOrtho_C,
2263  nmodes2, Pkey2);
2264 
2265  Vmath::Zero(m_ncoeffs, coeff_tmp2, 1);
2266 
2267  StdRegions::StdTetExpSharedPtr OrthoTetExp;
2268  OrthoTetExp = MemoryManager<StdRegions::StdTetExp>
2269  ::AllocateSharedPtr(bortho0, bortho1, bortho2);
2270 
2271  BwdTrans(inarray,phys_tmp);
2272  OrthoTetExp->FwdTrans(phys_tmp, coeff);
2273 
2274  Vmath::Zero(m_ncoeffs,outarray,1);
2275 
2276  // filtering
2277  int cnt = 0;
2278  for (int u = 0; u < numMin; ++u)
2279  {
2280  for (int i = 0; i < numMin-u; ++i)
2281  {
2282  Vmath::Vcopy(numMin - u - i, tmp = coeff + cnt, 1,
2283  tmp2 = coeff_tmp1 + cnt, 1);
2284  cnt += numMax - u - i;
2285  }
2286  for (int i = numMin; i < numMax-u; ++i)
2287  {
2288  cnt += numMax - u - i;
2289  }
2290  }
2291 
2292  OrthoTetExp->BwdTrans(coeff_tmp1,phys_tmp);
2293  FwdTrans(phys_tmp, outarray);
2294  }
Nektar::StdRegions::StdTetExpSharedPtr
std::shared_ptr< StdTetExp > StdTetExpSharedPtr
Definition: StdTetExp.h:279
Nektar::LibUtilities::eOrtho_B
Principle Orthogonal Functions .
Definition: BasisType.h:46
Nektar::MemoryManager::AllocateSharedPtr
static std::shared_ptr< DataType > AllocateSharedPtr(const Args &...args)
Allocate a shared pointer from the memory pool.
Definition: NekMemoryManager.hpp:161
Nektar::LibUtilities::eOrtho_C
Principle Orthogonal Functions .
Definition: BasisType.h:47
Nektar::LibUtilities::eOrtho_A
Principle Orthogonal Functions .
Definition: BasisType.h:45
Nektar::StdRegions::StdExpansion::BwdTrans
void BwdTrans(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
This function performs the Backward transformation from coefficient space to physical space...
Definition: StdExpansion.h:530
Vmath::Zero
void Zero(int n, T *x, const int incx)
Zero vector.
Definition: Vmath.cpp:376
Nektar::StdRegions::StdExpansion::m_base
Array< OneD, LibUtilities::BasisSharedPtr > m_base
Definition: StdExpansion.h:1429
Vmath::Vcopy
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1064
Nektar::StdRegions::StdExpansion::FwdTrans
void FwdTrans(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
This function performs the Forward transformation from physical space to coefficient space...
Definition: StdExpansion.h:1957

◆ v_StdPhysDeriv() [1/2]

void Nektar::StdRegions::StdTetExp::v_StdPhysDeriv ( const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  out_d0,
Array< OneD, NekDouble > &  out_d1,
Array< OneD, NekDouble > &  out_d2 
)
protectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 252 of file StdTetExp.cpp.

References v_PhysDeriv().

Referenced by DetShapeType().

257  {
258  StdTetExp::v_PhysDeriv(inarray, out_d0, out_d1, out_d2);
259  }
Nektar::StdRegions::StdTetExp::v_PhysDeriv
virtual void v_PhysDeriv(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_dx, Array< OneD, NekDouble > &out_dy, Array< OneD, NekDouble > &out_dz)
Calculate the derivative of the physical points.
Definition: StdTetExp.cpp:107

◆ v_StdPhysDeriv() [2/2]

void Nektar::StdRegions::StdTetExp::v_StdPhysDeriv ( const int  dir,
const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray 
)
protectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 261 of file StdTetExp.cpp.

References v_PhysDeriv().

265  {
266  StdTetExp::v_PhysDeriv(dir, inarray, outarray);
267  }
Nektar::StdRegions::StdTetExp::v_PhysDeriv
virtual void v_PhysDeriv(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_dx, Array< OneD, NekDouble > &out_dy, Array< OneD, NekDouble > &out_dz)
Calculate the derivative of the physical points.
Definition: StdTetExp.cpp:107

◆ v_SVVLaplacianFilter()

void Nektar::StdRegions::StdTetExp::v_SVVLaplacianFilter ( Array< OneD, NekDouble > &  array,
const StdMatrixKey &  mkey 
)
protectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::LocalRegions::TetExp.

Definition at line 2093 of file StdTetExp.cpp.

References Nektar::StdRegions::StdExpansion::BwdTrans(), Nektar::StdRegions::StdMatrixKey::ConstFactorExists(), Nektar::StdRegions::eFactorSVVCutoffRatio, Nektar::StdRegions::eFactorSVVDGKerDiffCoeff, Nektar::StdRegions::eFactorSVVDiffCoeff, Nektar::StdRegions::eFactorSVVPowerKerDiffCoeff, Nektar::LibUtilities::eOrtho_A, Nektar::LibUtilities::eOrtho_B, Nektar::LibUtilities::eOrtho_C, Nektar::StdRegions::StdExpansion::FwdTrans(), Nektar::StdRegions::StdMatrixKey::GetConstFactor(), Nektar::StdRegions::StdExpansion::GetNcoeffs(), Nektar::StdRegions::StdExpansion::GetPointsType(), Nektar::StdRegions::kSVVDGFilter, Nektar::StdRegions::kSVVDGFiltermodesmax, Nektar::StdRegions::kSVVDGFiltermodesmin, and Nektar::StdRegions::StdExpansion::m_base.

Referenced by DetShapeType().

2095  {
2096  //To do : 1) add a test to ensure 0 \leq SvvCutoff \leq 1.
2097  // 2) check if the transfer function needs an analytical
2098  // Fourier transform.
2099  // 3) if it doesn't : find a transfer function that renders
2100  // the if( cutoff_a ...) useless to reduce computational
2101  // cost.
2102  // 4) add SVVDiffCoef to both models!!
2103 
2104  int qa = m_base[0]->GetNumPoints();
2105  int qb = m_base[1]->GetNumPoints();
2106  int qc = m_base[2]->GetNumPoints();
2107  int nmodes_a = m_base[0]->GetNumModes();
2108  int nmodes_b = m_base[1]->GetNumModes();
2109  int nmodes_c = m_base[2]->GetNumModes();
2110 
2111  // Declare orthogonal basis.
2112  LibUtilities::PointsKey pa(qa,m_base[0]->GetPointsType());
2113  LibUtilities::PointsKey pb(qb,m_base[1]->GetPointsType());
2114  LibUtilities::PointsKey pc(qc,m_base[2]->GetPointsType());
2115 
2116  LibUtilities::BasisKey Ba(LibUtilities::eOrtho_A,nmodes_a,pa);
2117  LibUtilities::BasisKey Bb(LibUtilities::eOrtho_B,nmodes_b,pb);
2118  LibUtilities::BasisKey Bc(LibUtilities::eOrtho_C,nmodes_c,pc);
2119 
2120  StdTetExp OrthoExp(Ba,Bb,Bc);
2121 
2122 
2123  Array<OneD, NekDouble> orthocoeffs(OrthoExp.GetNcoeffs());
2124  int i,j,k,cnt = 0;
2125 
2126  // project onto physical space.
2127  OrthoExp.FwdTrans(array,orthocoeffs);
2128 
2129  if(mkey.ConstFactorExists(eFactorSVVPowerKerDiffCoeff))
2130  {
2131  // Rodrigo's power kernel
2132  NekDouble cutoff = mkey.GetConstFactor(eFactorSVVCutoffRatio);
2133  NekDouble SvvDiffCoeff =
2134  mkey.GetConstFactor(eFactorSVVPowerKerDiffCoeff)*
2135  mkey.GetConstFactor(eFactorSVVDiffCoeff);
2136 
2137  for(int i = 0; i < nmodes_a; ++i)
2138  {
2139  for(int j = 0; j < nmodes_b-j; ++j)
2140  {
2141  NekDouble fac1 = std::max(
2142  pow((1.0*i)/(nmodes_a-1),cutoff*nmodes_a),
2143  pow((1.0*j)/(nmodes_b-1),cutoff*nmodes_b));
2144 
2145  for(int k = 0; k < nmodes_c-i-j; ++k)
2146  {
2147  NekDouble fac = std::max(fac1,
2148  pow((1.0*k)/(nmodes_c-1),cutoff*nmodes_c));
2149 
2150  orthocoeffs[cnt] *= SvvDiffCoeff * fac;
2151  cnt++;
2152  }
2153  }
2154  }
2155  }
2156  else if(mkey.ConstFactorExists(eFactorSVVDGKerDiffCoeff)) // Rodrigo/Mansoor's DG Kernel
2157  {
2158  NekDouble SvvDiffCoeff =
2159  mkey.GetConstFactor(eFactorSVVDGKerDiffCoeff)*
2160  mkey.GetConstFactor(eFactorSVVDiffCoeff);
2161 
2162  int max_abc = max(nmodes_a-kSVVDGFiltermodesmin,
2163  nmodes_b-kSVVDGFiltermodesmin);
2164  max_abc = max(max_abc, nmodes_c-kSVVDGFiltermodesmin);
2165  // clamp max_abc
2166  max_abc = max(max_abc,0);
2167  max_abc = min(max_abc,kSVVDGFiltermodesmax-kSVVDGFiltermodesmin);
2168 
2169  for(int i = 0; i < nmodes_a; ++i)
2170  {
2171  for(int j = 0; j < nmodes_b-j; ++j)
2172  {
2173  int maxij = max(i,j);
2174 
2175  for(int k = 0; k < nmodes_c-i-j; ++k)
2176  {
2177  int maxijk = max(maxij,k);
2178  maxijk = min(maxijk,kSVVDGFiltermodesmax-1);
2179 
2180  orthocoeffs[cnt] *= SvvDiffCoeff *
2181  kSVVDGFilter[max_abc][maxijk];
2182  cnt++;
2183  }
2184  }
2185  }
2186  }
2187  else
2188  {
2189 
2190  //SVV filter paramaters (how much added diffusion
2191  //relative to physical one and fraction of modes from
2192  //which you start applying this added diffusion)
2193 
2194  NekDouble SvvDiffCoeff = mkey.GetConstFactor(StdRegions::eFactorSVVDiffCoeff);
2195  NekDouble SVVCutOff = mkey.GetConstFactor(StdRegions::eFactorSVVCutoffRatio);
2196 
2197  //Defining the cut of mode
2198  int cutoff_a = (int) (SVVCutOff*nmodes_a);
2199  int cutoff_b = (int) (SVVCutOff*nmodes_b);
2200  int cutoff_c = (int) (SVVCutOff*nmodes_c);
2201  int nmodes = min(min(nmodes_a,nmodes_b),nmodes_c);
2202  NekDouble cutoff = min(min(cutoff_a,cutoff_b),cutoff_c);
2203  NekDouble epsilon = 1;
2204 
2205 
2206  //------"New" Version August 22nd '13--------------------
2207  for(i = 0; i < nmodes_a; ++i)
2208  {
2209  for(j = 0; j < nmodes_b-i; ++j)
2210  {
2211  for(k = 0; k < nmodes_c-i-j; ++k)
2212  {
2213  if(i + j + k >= cutoff)
2214  {
2215  orthocoeffs[cnt] *= ((SvvDiffCoeff)*exp(-(i+j+k-nmodes)*(i+j+k-nmodes)/((NekDouble)((i+j+k-cutoff+epsilon)*(i+j+k-cutoff+epsilon)))));
2216  }
2217  else
2218  {
2219  orthocoeffs[cnt] *= 0.0;
2220  }
2221  cnt++;
2222  }
2223  }
2224  }
2225  }
2226 
2227  // backward transform to physical space
2228  OrthoExp.BwdTrans(orthocoeffs,array);
2229  }
Nektar::StdRegions::kSVVDGFiltermodesmax
const int kSVVDGFiltermodesmax
Definition: StdRegions.hpp:385
Nektar::StdRegions::kSVVDGFiltermodesmin
const int kSVVDGFiltermodesmin
Definition: StdRegions.hpp:384
Nektar::LibUtilities::eOrtho_B
Principle Orthogonal Functions .
Definition: BasisType.h:46
Nektar::LibUtilities::eOrtho_C
Principle Orthogonal Functions .
Definition: BasisType.h:47
Nektar::LibUtilities::eOrtho_A
Principle Orthogonal Functions .
Definition: BasisType.h:45
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:43
Nektar::StdRegions::kSVVDGFilter
const NekDouble kSVVDGFilter[9][11]
Definition: StdRegions.hpp:387
Nektar::StdRegions::StdExpansion::GetPointsType
LibUtilities::PointsType GetPointsType(const int dir) const
This function returns the type of quadrature points used in the dir direction.
Definition: StdExpansion.h:215
Nektar::StdRegions::StdExpansion::m_base
Array< OneD, LibUtilities::BasisSharedPtr > m_base
Definition: StdExpansion.h:1429
Generated on Wed Jan 20 2021 03:34:20 for Nektar++ by   doxygen 1.8.13