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

Class representing a prismatic element in reference space. More...

#include <StdPrismExp.h>

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

Public Member Functions

 StdPrismExp ()
 
 StdPrismExp (const LibUtilities::BasisKey &Ba, const LibUtilities::BasisKey &Bb, const LibUtilities::BasisKey &Bc)
 
 StdPrismExp (const LibUtilities::BasisKey &Ba, const LibUtilities::BasisKey &Bb, const LibUtilities::BasisKey &Bc, NekDouble *coeffs, NekDouble *phys)
 
 StdPrismExp (const StdPrismExp &T)
 
virtual ~StdPrismExp () override
 
- 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 () override
 
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)
 
int GetNedges () const
 return the number of edges in 3D expansion More...
 
int GetEdgeNcoeffs (const int i) const
 This function returns the number of expansion coefficients belonging to the i-th edge. More...
 
void GetEdgeInteriorToElementMap (const int tid, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray, Orientation traceOrient=eForwards)
 
- 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 GetTraceNcoeffs (const int i) const
 This function returns the number of expansion coefficients belonging to the i-th trace. More...
 
int GetTraceIntNcoeffs (const int i) const
 
int GetTraceNumPoints (const int i) const
 This function returns the number of quadrature points belonging to the i-th trace. More...
 
const LibUtilities::BasisKey GetTraceBasisKey (const int i, int k=-1) const
 This function returns the basis key belonging to the i-th trace. More...
 
LibUtilities::PointsKey GetTracePointsKey (const int i, int k=-1) const
 This function returns the basis key belonging to the i-th trace. More...
 
int NumBndryCoeffs (void) const
 
int NumDGBndryCoeffs (void) const
 
const LibUtilities::PointsKey GetNodalPointsKey () const
 This function returns the type of expansion Nodal point type if defined. More...
 
int GetNtraces () 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 () const
 
std::shared_ptr< StdExpansion > GetLinStdExp (void) const
 
int GetShapeDimension () const
 
bool IsBoundaryInteriorExpansion () const
 
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 FwdTransBndConstrained (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)
 
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)
 
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 GetTraceToElementMap (const int tid, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray, Orientation traceOrient=eForwards, int P=-1, int Q=-1)
 
void GetTraceCoeffMap (const unsigned int traceid, Array< OneD, unsigned int > &maparray)
 
void GetElmtTraceToTraceMap (const unsigned int tid, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray, Orientation traceOrient=eForwards, int P=-1, int Q=-1)
 
void GetTraceInteriorToElementMap (const int tid, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray, const Orientation traceOrient=eForwards)
 
void GetTraceNumModes (const int tid, int &numModes0, int &numModes1, const Orientation traceOrient=eDir1FwdDir1_Dir2FwdDir2)
 
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)
 
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, NekDouble > &coord, const Array< OneD, const NekDouble > &inarray, std::array< NekDouble, 3 > &firstOrderDerivs)
 This function evaluates the first derivative of the expansion at a single (arbitrary) point of the domain. More...
 
NekDouble PhysEvaluate (const Array< OneD, NekDouble > &coord, const Array< OneD, const NekDouble > &inarray, std::array< NekDouble, 3 > &firstOrderDerivs, std::array< NekDouble, 6 > &secondOrderDerivs)
 
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...
 
NekDouble PhysEvaluateBasis (const Array< OneD, const NekDouble > &coords, int mode)
 This function evaluates the basis function mode mode at a point coords 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...
 
void LocCollapsedToLocCoord (const Array< OneD, const NekDouble > &eta, Array< OneD, NekDouble > &xi)
 Convert local collapsed coordinates eta into local cartesian coordinate xi. More...
 
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)
 
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 LibUtilities::PointsKeyVector GetPointsKeys () const
 
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)
 
void GenStdMatBwdDeriv (const int dir, DNekMatSharedPtr &mat)
 

Protected Member Functions

void v_PhysDeriv (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_d0, Array< OneD, NekDouble > &out_d1, Array< OneD, NekDouble > &out_d2) override
 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) override
 Calculate the derivative of the physical points in a given direction. More...
 
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) override
 
virtual void v_StdPhysDeriv (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) override
 
void v_BwdTrans (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) override
 
virtual void v_BwdTrans_SumFac (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) override
 
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) override
 
virtual void v_FwdTrans (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) override
 Forward transform from physical quadrature space stored in inarray and evaluate the expansion coefficients and store in outarray. More...
 
void v_IProductWRTBase (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) override
 Calculate the inner product of inarray with respect to the basis B=base0*base1*base2 and put into outarray: More...
 
virtual void v_IProductWRTBase_SumFac (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, bool multiplybyweights=true) override
 
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) override
 
virtual void v_IProductWRTDerivBase (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) override
 Inner product of inarray over region with respect to the object's default expansion basis; output in outarray. More...
 
virtual void v_IProductWRTDerivBase_SumFac (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) override
 
virtual void v_LocCoordToLocCollapsed (const Array< OneD, const NekDouble > &xi, Array< OneD, NekDouble > &eta) override
 
virtual void v_LocCollapsedToLocCoord (const Array< OneD, const NekDouble > &eta, Array< OneD, NekDouble > &xi) override
 
virtual void v_GetCoords (Array< OneD, NekDouble > &xi_x, Array< OneD, NekDouble > &xi_y, Array< OneD, NekDouble > &xi_z) override
 
virtual void v_FillMode (const int mode, Array< OneD, NekDouble > &outarray) override
 
NekDouble v_PhysEvaluateBasis (const Array< OneD, const NekDouble > &coords, int mode) final override
 
virtual void v_GetTraceNumModes (const int fid, int &numModes0, int &numModes1, Orientation faceOrient=eDir1FwdDir1_Dir2FwdDir2) override
 
virtual NekDouble v_PhysEvaluate (const Array< OneD, NekDouble > &coord, const Array< OneD, const NekDouble > &inarray, std::array< NekDouble, 3 > &firstOrderDerivs) override
 
virtual int v_GetNverts () const override
 
virtual int v_GetNedges () const override
 
virtual int v_GetNtraces () const override
 
virtual LibUtilities::ShapeType v_DetShapeType () const override
 Return Shape of region, using ShapeType enum list; i.e. prism. More...
 
virtual int v_NumBndryCoeffs () const override
 
virtual int v_NumDGBndryCoeffs () const override
 
virtual int v_GetTraceNcoeffs (const int i) const override
 
virtual int v_GetTraceIntNcoeffs (const int i) const override
 
virtual int v_GetTraceNumPoints (const int i) const override
 
virtual int v_GetEdgeNcoeffs (const int i) const override
 
virtual const LibUtilities::BasisKey v_GetTraceBasisKey (const int i, const int k) const override
 
virtual LibUtilities::PointsKey v_GetTracePointsKey (const int i, const int j) const override
 
virtual int v_CalcNumberOfCoefficients (const std::vector< unsigned int > &nummodes, int &modes_offset) override
 
virtual bool v_IsBoundaryInteriorExpansion () const override
 
virtual int v_GetVertexMap (int localVertexId, bool useCoeffPacking=false) override
 
virtual void v_GetInteriorMap (Array< OneD, unsigned int > &outarray) override
 
virtual void v_GetBoundaryMap (Array< OneD, unsigned int > &outarray) override
 
virtual void v_GetTraceCoeffMap (const unsigned int fid, Array< OneD, unsigned int > &maparray) override
 
virtual void v_GetElmtTraceToTraceMap (const unsigned int fid, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray, Orientation faceOrient, int P, int Q) override
 
virtual void v_GetEdgeInteriorToElementMap (const int tid, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray, const Orientation traceOrient=eDir1FwdDir1_Dir2FwdDir2) override
 
void v_GetTraceInteriorToElementMap (const int tid, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray, const Orientation traceOrient=eDir1FwdDir1_Dir2FwdDir2) override
 
virtual DNekMatSharedPtr v_GenMatrix (const StdMatrixKey &mkey) override
 
virtual DNekMatSharedPtr v_CreateStdMatrix (const StdMatrixKey &mkey) override
 
void v_MultiplyByStdQuadratureMetric (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) override
 
void v_SVVLaplacianFilter (Array< OneD, NekDouble > &array, const StdMatrixKey &mkey) override
 
void v_ReduceOrderCoeffs (int numMin, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) override
 
- Protected Member Functions inherited from Nektar::StdRegions::StdExpansion3D
virtual NekDouble v_PhysEvaluate (const Array< OneD, const NekDouble > &coords, const Array< OneD, const NekDouble > &physvals) override
 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) override
 
virtual void v_LaplacianMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey) override
 
virtual void v_HelmholtzMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey) override
 
virtual NekDouble v_Integral (const Array< OneD, const NekDouble > &inarray) override
 Integrates the specified function over the domain. More...
 
NekDouble BaryTensorDeriv (const Array< OneD, NekDouble > &coord, const Array< OneD, const NekDouble > &inarray, std::array< NekDouble, 3 > &firstOrderDerivs)
 
virtual void v_GetTraceToElementMap (const int tid, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray, Orientation traceOrient, int P, int Q) override
 
virtual void v_GenStdMatBwdDeriv (const int dir, DNekMatSharedPtr &mat) override
 
- 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...
 
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)
 
template<int DIR, bool DERIV = false, bool DERIV2 = false>
NekDouble BaryEvaluate (const NekDouble &coord, const NekDouble *physvals, NekDouble &deriv, NekDouble &deriv2)
 This function performs the barycentric interpolation of the polynomial stored in coord at a point physvals using barycentric interpolation weights in direction. More...
 
template<int DIR>
NekDouble BaryEvaluateBasis (const NekDouble &coord, const int &mode)
 
template<int DIR, bool DERIV = false, bool DERIV2 = false>
NekDouble BaryEvaluate (const NekDouble &coord, const NekDouble *physvals)
 Helper function to pass an unused value by reference into BaryEvaluate. More...
 
template<int DIR, bool DERIV = false, bool DERIV2 = false>
NekDouble BaryEvaluate (const NekDouble &coord, const NekDouble *physvals, NekDouble &deriv)
 

Private Member Functions

int GetMode (int I, int J, int K)
 Compute the local mode number in the expansion for a particular tensorial combination. More...
 

Additional Inherited Members

- 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
 

Detailed Description

Class representing a prismatic element in reference space.

Definition at line 48 of file StdPrismExp.h.

Constructor & Destructor Documentation

◆ StdPrismExp() [1/4]

Nektar::StdRegions::StdPrismExp::StdPrismExp ( )

Definition at line 47 of file StdPrismExp.cpp.

48 {
49 }

◆ StdPrismExp() [2/4]

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

Definition at line 51 of file StdPrismExp.cpp.

54  : StdExpansion(LibUtilities::StdPrismData::getNumberOfCoefficients(
55  Ba.GetNumModes(), Bb.GetNumModes(), Bc.GetNumModes()),
56  3, Ba, Bb, Bc),
57  StdExpansion3D(LibUtilities::StdPrismData::getNumberOfCoefficients(
58  Ba.GetNumModes(), Bb.GetNumModes(), Bc.GetNumModes()),
59  Ba, Bb, Bc)
60 {
61  ASSERTL0(Ba.GetNumModes() <= Bc.GetNumModes(),
62  "order in 'a' direction is higher than order in 'c' direction");
63 }
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:215
Nektar::StdRegions::StdExpansion::StdExpansion
StdExpansion()
Default Constructor.
Definition: StdExpansion.cpp:46
Nektar::LibUtilities::StdPrismData::getNumberOfCoefficients
int getNumberOfCoefficients(int Na, int Nb, int Nc)
Definition: ShapeType.hpp:284

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

◆ StdPrismExp() [3/4]

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

◆ StdPrismExp() [4/4]

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

Definition at line 65 of file StdPrismExp.cpp.

66  : StdExpansion(T), StdExpansion3D(T)
67 {
68 }

◆ ~StdPrismExp()

Nektar::StdRegions::StdPrismExp::~StdPrismExp ( )
overridevirtual

Definition at line 71 of file StdPrismExp.cpp.

72 {
73 }

Member Function Documentation

◆ GetMode()

int Nektar::StdRegions::StdPrismExp::GetMode ( int  p,
int  q,
int  r 
)
private

Compute the local 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 (R+1-p). For example, with P=1, Q=2, R=3, the indexing inside each q-r plane (with r increasing upwards and q to the right) is:

p = 0: p = 1:

3 7 11 2 6 10 14 17 20 1 5 9 13 16 19 0 4 8 12 15 18

Note that in this element, we must have that \( P <= R \).

Definition at line 1949 of file StdPrismExp.cpp.

1950 {
1951  int Q = m_base[1]->GetNumModes() - 1;
1952  int R = m_base[2]->GetNumModes() - 1;
1953 
1954  return r + // Skip along stacks (r-direction)
1955  q * (R + 1 - p) + // Skip along columns (q-direction)
1956  (Q + 1) * (p * R + 1 -
1957  (p - 2) * (p - 1) / 2); // Skip along rows (p-direction)
1958 }
Nektar::StdRegions::StdExpansion::m_base
Array< OneD, LibUtilities::BasisSharedPtr > m_base
Definition: StdExpansion.h:1172
CellMLToNektar.cellml_metadata.p
p
Definition: cellml_metadata.py:350

References Nektar::StdRegions::StdExpansion::m_base, and CellMLToNektar.cellml_metadata::p.

Referenced by v_GetBoundaryMap(), v_GetEdgeInteriorToElementMap(), v_GetInteriorMap(), v_GetTraceCoeffMap(), v_GetTraceInteriorToElementMap(), v_GetVertexMap(), and v_IProductWRTBase_SumFacKernel().

◆ v_BwdTrans()

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

Perform backwards transformation at the quadrature points:

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

In the prism this expansion becomes:

\( u (\xi_{1i}, \xi_{2j}, \xi_{3k}) = \sum_{p=0}^{Q_x} \psi_p^a (\xi_{1i}) \lbrace { \sum_{q=0}^{Q_y} \psi_{q}^a (\xi_{2j}) \lbrace { \sum_{r=0}^{Q_z} \hat u_{pqr} \psi_{pr}^b (\xi_{3k}) \rbrace} \rbrace}. \)

And sumfactorizing step of the form is as:\

\( f_{pr} (\xi_{3k}) = \sum_{r=0}^{Q_z} \hat u_{pqr} \psi_{pr}^b (\xi_{3k}),\\ g_{p} (\xi_{2j}, \xi_{3k}) = \sum_{r=0}^{Q_y} \psi_{p}^a (\xi_{2j}) f_{pr} (\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.

Definition at line 238 of file StdPrismExp.cpp.

240 {
241  ASSERTL1((m_base[1]->GetBasisType() != LibUtilities::eOrtho_B) ||
242  (m_base[1]->GetBasisType() != LibUtilities::eModified_B),
243  "Basis[1] is not a general tensor type");
244 
245  ASSERTL1((m_base[2]->GetBasisType() != LibUtilities::eOrtho_C) ||
246  (m_base[2]->GetBasisType() != LibUtilities::eModified_C),
247  "Basis[2] is not a general tensor type");
248 
249  if (m_base[0]->Collocation() && m_base[1]->Collocation() &&
250  m_base[2]->Collocation())
251  {
252  Vmath::Vcopy(m_base[0]->GetNumPoints() * m_base[1]->GetNumPoints() *
253  m_base[2]->GetNumPoints(),
254  inarray, 1, outarray, 1);
255  }
256  else
257  {
258  StdPrismExp::v_BwdTrans_SumFac(inarray, outarray);
259  }
260 }
ASSERTL1
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode....
Definition: ErrorUtil.hpp:249
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:162
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:224
Nektar::StdRegions::StdPrismExp::v_BwdTrans_SumFac
virtual void v_BwdTrans_SumFac(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) override
Definition: StdPrismExp.cpp:262
Nektar::LibUtilities::eModified_B
@ eModified_B
Principle Modified Functions .
Definition: BasisType.h:51
Nektar::LibUtilities::eModified_C
@ eModified_C
Principle Modified Functions .
Definition: BasisType.h:52
Nektar::LibUtilities::eOrtho_C
@ eOrtho_C
Principle Orthogonal Functions .
Definition: BasisType.h:48
Nektar::LibUtilities::eOrtho_B
@ eOrtho_B
Principle Orthogonal Functions .
Definition: BasisType.h:46
Vmath::Vcopy
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1255

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 v_FillMode().

◆ v_BwdTrans_SumFac()

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::StdRegions::StdNodalPrismExp.

Definition at line 262 of file StdPrismExp.cpp.

264 {
265  int nquad1 = m_base[1]->GetNumPoints();
266  int nquad2 = m_base[2]->GetNumPoints();
267  int order0 = m_base[0]->GetNumModes();
268  int order1 = m_base[1]->GetNumModes();
269 
270  Array<OneD, NekDouble> wsp(nquad2 * order1 * order0 +
271  nquad1 * nquad2 * order0);
272 
273  BwdTrans_SumFacKernel(m_base[0]->GetBdata(), m_base[1]->GetBdata(),
274  m_base[2]->GetBdata(), inarray, outarray, wsp, true,
275  true, true);
276 }
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:110

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

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

◆ v_BwdTrans_SumFacKernel()

void Nektar::StdRegions::StdPrismExp::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 
)
overrideprotectedvirtual

Implements Nektar::StdRegions::StdExpansion3D.

Definition at line 278 of file StdPrismExp.cpp.

285 {
286  boost::ignore_unused(doCheckCollDir0, doCheckCollDir1, doCheckCollDir2);
287 
288  int i, mode;
289  int nquad0 = m_base[0]->GetNumPoints();
290  int nquad1 = m_base[1]->GetNumPoints();
291  int nquad2 = m_base[2]->GetNumPoints();
292  int nummodes0 = m_base[0]->GetNumModes();
293  int nummodes1 = m_base[1]->GetNumModes();
294  int nummodes2 = m_base[2]->GetNumModes();
295  Array<OneD, NekDouble> tmp0 = wsp;
296  Array<OneD, NekDouble> tmp1 = tmp0 + nquad2 * nummodes1 * nummodes0;
297 
298  for (i = mode = 0; i < nummodes0; ++i)
299  {
300  Blas::Dgemm('N', 'N', nquad2, nummodes1, nummodes2 - i, 1.0,
301  base2.get() + mode * nquad2, nquad2,
302  inarray.get() + mode * nummodes1, nummodes2 - i, 0.0,
303  tmp0.get() + i * nquad2 * nummodes1, nquad2);
304  mode += nummodes2 - i;
305  }
306 
307  if (m_base[0]->GetBasisType() == LibUtilities::eModified_A)
308  {
309  for (i = 0; i < nummodes1; i++)
310  {
311  Blas::Daxpy(nquad2, inarray[1 + i * nummodes2],
312  base2.get() + nquad2, 1,
313  tmp0.get() + nquad2 * (nummodes1 + i), 1);
314  }
315  }
316 
317  for (i = 0; i < nummodes0; i++)
318  {
319  Blas::Dgemm('N', 'T', nquad1, nquad2, nummodes1, 1.0, base1.get(),
320  nquad1, tmp0.get() + i * nquad2 * nummodes1, nquad2, 0.0,
321  tmp1.get() + i * nquad2 * nquad1, nquad1);
322  }
323 
324  Blas::Dgemm('N', 'T', nquad0, nquad2 * nquad1, nummodes0, 1.0, base0.get(),
325  nquad0, tmp1.get(), nquad2 * nquad1, 0.0, outarray.get(),
326  nquad0);
327 }
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 op(A)[m x k], op(B)[k x n], C[m x n] DGEMM perfo...
Definition: Blas.hpp:368
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:154
Nektar::LibUtilities::eModified_A
@ eModified_A
Principle Modified Functions .
Definition: BasisType.h:50

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

◆ v_CalcNumberOfCoefficients()

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 974 of file StdPrismExp.cpp.

976 {
977  int nmodes = LibUtilities::StdPrismData::getNumberOfCoefficients(
978  nummodes[modes_offset], nummodes[modes_offset + 1],
979  nummodes[modes_offset + 2]);
980 
981  modes_offset += 3;
982  return nmodes;
983 }

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

◆ v_CreateStdMatrix()

DNekMatSharedPtr Nektar::StdRegions::StdPrismExp::v_CreateStdMatrix ( const StdMatrixKey &  mkey)
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::LocalRegions::PrismExp, and Nektar::StdRegions::StdNodalPrismExp.

Definition at line 1926 of file StdPrismExp.cpp.

1927 {
1928  return v_GenMatrix(mkey);
1929 }
Nektar::StdRegions::StdPrismExp::v_GenMatrix
virtual DNekMatSharedPtr v_GenMatrix(const StdMatrixKey &mkey) override
Definition: StdPrismExp.cpp:1839

References v_GenMatrix().

◆ v_DetShapeType()

LibUtilities::ShapeType Nektar::StdRegions::StdPrismExp::v_DetShapeType ( ) const
overrideprotectedvirtual

Return Shape of region, using ShapeType enum list; i.e. prism.

Implements Nektar::StdRegions::StdExpansion.

Definition at line 816 of file StdPrismExp.cpp.

817 {
818  return LibUtilities::ePrism;
819 }

References Nektar::LibUtilities::ePrism.

◆ v_FillMode()

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::StdRegions::StdNodalPrismExp.

Definition at line 699 of file StdPrismExp.cpp.

700 {
701  Array<OneD, NekDouble> tmp(m_ncoeffs, 0.0);
702  tmp[mode] = 1.0;
703  StdPrismExp::v_BwdTrans(tmp, outarray);
704 }
Nektar::StdRegions::StdPrismExp::v_BwdTrans
void v_BwdTrans(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) override
Definition: StdPrismExp.cpp:238

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

Referenced by Nektar::StdRegions::StdNodalPrismExp::GenNBasisTransMatrix().

◆ v_FwdTrans()

void Nektar::StdRegions::StdPrismExp::v_FwdTrans ( const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray 
)
overrideprotectedvirtual

Forward transform from physical quadrature space stored in inarray and evaluate the expansion coefficients and store in outarray.

Inputs:

  • inarray: array of physical quadrature points to be transformed

Outputs:

  • outarray: updated array of expansion coefficients.

Implements Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::StdRegions::StdNodalPrismExp, and Nektar::LocalRegions::PrismExp.

Definition at line 340 of file StdPrismExp.cpp.

342 {
343  v_IProductWRTBase(inarray, outarray);
344 
345  // Get Mass matrix inverse
346  StdMatrixKey masskey(eInvMass, DetShapeType(), *this);
347  DNekMatSharedPtr matsys = GetStdMatrix(masskey);
348 
349  // copy inarray in case inarray == outarray
350  DNekVec in(m_ncoeffs, outarray);
351  DNekVec out(m_ncoeffs, outarray, eWrapper);
352 
353  out = (*matsys) * in;
354 }
Nektar::StdRegions::StdExpansion::GetStdMatrix
DNekMatSharedPtr GetStdMatrix(const StdMatrixKey &mkey)
Definition: StdExpansion.h:609
Nektar::StdRegions::StdExpansion::DetShapeType
LibUtilities::ShapeType DetShapeType() const
This function returns the shape of the expansion domain.
Definition: StdExpansion.h:373
Nektar::StdRegions::StdPrismExp::v_IProductWRTBase
void v_IProductWRTBase(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) override
Calculate the inner product of inarray with respect to the basis B=base0*base1*base2 and put into out...
Definition: StdPrismExp.cpp:386
Nektar::DNekVec
NekVector< NekDouble > DNekVec
Definition: NekTypeDefs.hpp:48
Nektar::DNekMatSharedPtr
std::shared_ptr< DNekMat > DNekMatSharedPtr
Definition: NekTypeDefs.hpp:75

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

◆ v_GenMatrix()

DNekMatSharedPtr Nektar::StdRegions::StdPrismExp::v_GenMatrix ( const StdMatrixKey &  mkey)
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::LocalRegions::PrismExp, and Nektar::StdRegions::StdNodalPrismExp.

Definition at line 1839 of file StdPrismExp.cpp.

1840 {
1841 
1842  MatrixType mtype = mkey.GetMatrixType();
1843 
1844  DNekMatSharedPtr Mat;
1845 
1846  switch (mtype)
1847  {
1848  case ePhysInterpToEquiSpaced:
1849  {
1850  int nq0 = m_base[0]->GetNumPoints();
1851  int nq1 = m_base[1]->GetNumPoints();
1852  int nq2 = m_base[2]->GetNumPoints();
1853  int nq;
1854 
1855  // take definition from key
1856  if (mkey.ConstFactorExists(eFactorConst))
1857  {
1858  nq = (int)mkey.GetConstFactor(eFactorConst);
1859  }
1860  else
1861  {
1862  nq = max(nq0, max(nq1, nq2));
1863  }
1864 
1865  int neq =
1866  LibUtilities::StdPrismData::getNumberOfCoefficients(nq, nq, nq);
1867  Array<OneD, Array<OneD, NekDouble>> coords(neq);
1868  Array<OneD, NekDouble> coll(3);
1869  Array<OneD, DNekMatSharedPtr> I(3);
1870  Array<OneD, NekDouble> tmp(nq0);
1871 
1872  Mat =
1873  MemoryManager<DNekMat>::AllocateSharedPtr(neq, nq0 * nq1 * nq2);
1874  int cnt = 0;
1875  for (int i = 0; i < nq; ++i)
1876  {
1877  for (int j = 0; j < nq; ++j)
1878  {
1879  for (int k = 0; k < nq - i; ++k, ++cnt)
1880  {
1881  coords[cnt] = Array<OneD, NekDouble>(3);
1882  coords[cnt][0] = -1.0 + 2 * k / (NekDouble)(nq - 1);
1883  coords[cnt][1] = -1.0 + 2 * j / (NekDouble)(nq - 1);
1884  coords[cnt][2] = -1.0 + 2 * i / (NekDouble)(nq - 1);
1885  }
1886  }
1887  }
1888 
1889  for (int i = 0; i < neq; ++i)
1890  {
1891  LocCoordToLocCollapsed(coords[i], coll);
1892 
1893  I[0] = m_base[0]->GetI(coll);
1894  I[1] = m_base[1]->GetI(coll + 1);
1895  I[2] = m_base[2]->GetI(coll + 2);
1896 
1897  // interpolate first coordinate direction
1898  NekDouble fac;
1899  for (int k = 0; k < nq2; ++k)
1900  {
1901  for (int j = 0; j < nq1; ++j)
1902  {
1903 
1904  fac = (I[1]->GetPtr())[j] * (I[2]->GetPtr())[k];
1905  Vmath::Smul(nq0, fac, I[0]->GetPtr(), 1, tmp, 1);
1906 
1907  Vmath::Vcopy(nq0, &tmp[0], 1,
1908  Mat->GetRawPtr() + k * nq0 * nq1 * neq +
1909  j * nq0 * neq + i,
1910  neq);
1911  }
1912  }
1913  }
1914  }
1915  break;
1916  default:
1917  {
1918  Mat = StdExpansion::CreateGeneralMatrix(mkey);
1919  }
1920  break;
1921  }
1922 
1923  return Mat;
1924 }
Nektar::MemoryManager::AllocateSharedPtr
static std::shared_ptr< DataType > AllocateSharedPtr(const Args &...args)
Allocate a shared pointer from the memory pool.
Definition: NekMemoryManager.hpp:168
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:1001
Nektar::StdRegions::StdExpansion::CreateGeneralMatrix
DNekMatSharedPtr CreateGeneralMatrix(const StdMatrixKey &mkey)
this function generates the mass matrix
Definition: StdExpansion.cpp:255
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:43
Vmath::Smul
void Smul(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Scalar multiply y = alpha*x.
Definition: Vmath.cpp:248

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::StdPrismData::getNumberOfCoefficients(), Nektar::StdRegions::StdExpansion::LocCoordToLocCollapsed(), Nektar::StdRegions::StdExpansion::m_base, Vmath::Smul(), and Vmath::Vcopy().

Referenced by v_CreateStdMatrix().

◆ v_GetBoundaryMap()

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::StdRegions::StdNodalPrismExp.

Definition at line 1099 of file StdPrismExp.cpp.

1100 {
1101  ASSERTL1(GetBasisType(0) == LibUtilities::eModified_A ||
1102  GetBasisType(0) == LibUtilities::eGLL_Lagrange,
1103  "BasisType is not a boundary interior form");
1104  ASSERTL1(GetBasisType(1) == LibUtilities::eModified_A ||
1105  GetBasisType(1) == LibUtilities::eGLL_Lagrange,
1106  "BasisType is not a boundary interior form");
1107  ASSERTL1(GetBasisType(2) == LibUtilities::eModified_B ||
1108  GetBasisType(2) == LibUtilities::eGLL_Lagrange,
1109  "BasisType is not a boundary interior form");
1110 
1111  int P = m_base[0]->GetNumModes() - 1, p;
1112  int Q = m_base[1]->GetNumModes() - 1, q;
1113  int R = m_base[2]->GetNumModes() - 1, r;
1114  int idx = 0;
1115 
1116  int nBnd = NumBndryCoeffs();
1117 
1118  if (maparray.size() != nBnd)
1119  {
1120  maparray = Array<OneD, unsigned int>(nBnd);
1121  }
1122 
1123  // Loop over all boundary modes (in ascending order).
1124  for (p = 0; p <= P; ++p)
1125  {
1126  // First two q-r planes are entirely boundary modes.
1127  if (p <= 1)
1128  {
1129  for (q = 0; q <= Q; ++q)
1130  {
1131  for (r = 0; r <= R - p; ++r)
1132  {
1133  maparray[idx++] = GetMode(p, q, r);
1134  }
1135  }
1136  }
1137  else
1138  {
1139  // Remaining q-r planes contain boundary modes on the two
1140  // left-hand sides and bottom edge.
1141  for (q = 0; q <= Q; ++q)
1142  {
1143  if (q <= 1)
1144  {
1145  for (r = 0; r <= R - p; ++r)
1146  {
1147  maparray[idx++] = GetMode(p, q, r);
1148  }
1149  }
1150  else
1151  {
1152  maparray[idx++] = GetMode(p, q, 0);
1153  }
1154  }
1155  }
1156  }
1157 }
Nektar::StdRegions::StdPrismExp::GetMode
int GetMode(int I, int J, int K)
Compute the local mode number in the expansion for a particular tensorial combination.
Definition: StdPrismExp.cpp:1949
Nektar::LibUtilities::eGLL_Lagrange
@ eGLL_Lagrange
Lagrange for SEM basis .
Definition: BasisType.h:58

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

◆ v_GetCoords()

void Nektar::StdRegions::StdPrismExp::v_GetCoords ( Array< OneD, NekDouble > &  xi_x,
Array< OneD, NekDouble > &  xi_y,
Array< OneD, NekDouble > &  xi_z 
)
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::LocalRegions::PrismExp.

Definition at line 626 of file StdPrismExp.cpp.

629 {
630  Array<OneD, const NekDouble> etaBar_x = m_base[0]->GetZ();
631  Array<OneD, const NekDouble> eta_y = m_base[1]->GetZ();
632  Array<OneD, const NekDouble> eta_z = m_base[2]->GetZ();
633  int Qx = GetNumPoints(0);
634  int Qy = GetNumPoints(1);
635  int Qz = GetNumPoints(2);
636 
637  // Convert collapsed coordinates into cartesian coordinates: eta --> xi
638  for (int k = 0; k < Qz; ++k)
639  {
640  for (int j = 0; j < Qy; ++j)
641  {
642  for (int i = 0; i < Qx; ++i)
643  {
644  int s = i + Qx * (j + Qy * k);
645  xi_x[s] = (1.0 - eta_z[k]) * (1.0 + etaBar_x[i]) / 2.0 - 1.0;
646  xi_y[s] = eta_y[j];
647  xi_z[s] = eta_z[k];
648  }
649  }
650  }
651 }

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

◆ v_GetEdgeInteriorToElementMap()

void Nektar::StdRegions::StdPrismExp::v_GetEdgeInteriorToElementMap ( const int  tid,
Array< OneD, unsigned int > &  maparray,
Array< OneD, int > &  signarray,
const Orientation  traceOrient = eDir1FwdDir1_Dir2FwdDir2 
)
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion3D.

Definition at line 1536 of file StdPrismExp.cpp.

1539 {
1540  int i;
1541  bool signChange;
1542  const int P = m_base[0]->GetNumModes() - 1;
1543  const int Q = m_base[1]->GetNumModes() - 1;
1544  const int R = m_base[2]->GetNumModes() - 1;
1545  const int nEdgeIntCoeffs = v_GetEdgeNcoeffs(eid) - 2;
1546 
1547  if (maparray.size() != nEdgeIntCoeffs)
1548  {
1549  maparray = Array<OneD, unsigned int>(nEdgeIntCoeffs);
1550  }
1551 
1552  if (signarray.size() != nEdgeIntCoeffs)
1553  {
1554  signarray = Array<OneD, int>(nEdgeIntCoeffs, 1);
1555  }
1556  else
1557  {
1558  fill(signarray.get(), signarray.get() + nEdgeIntCoeffs, 1);
1559  }
1560 
1561  // If edge is oriented backwards, change sign of modes which have
1562  // degree 2n+1, n >= 1.
1563  signChange = edgeOrient == eBackwards;
1564 
1565  switch (eid)
1566  {
1567  case 0:
1568  for (i = 2; i <= P; ++i)
1569  {
1570  maparray[i - 2] = GetMode(i, 0, 0);
1571  }
1572  break;
1573 
1574  case 1:
1575  for (i = 2; i <= Q; ++i)
1576  {
1577  maparray[i - 2] = GetMode(1, i, 0);
1578  }
1579  break;
1580 
1581  case 2:
1582  // Base quad; reverse direction.
1583  // signChange = !signChange;
1584  for (i = 2; i <= P; ++i)
1585  {
1586  maparray[i - 2] = GetMode(i, 1, 0);
1587  }
1588  break;
1589 
1590  case 3:
1591  // Base quad; reverse direction.
1592  // signChange = !signChange;
1593  for (i = 2; i <= Q; ++i)
1594  {
1595  maparray[i - 2] = GetMode(0, i, 0);
1596  }
1597  break;
1598 
1599  case 4:
1600  for (i = 2; i <= R; ++i)
1601  {
1602  maparray[i - 2] = GetMode(0, 0, i);
1603  }
1604  break;
1605 
1606  case 5:
1607  for (i = 1; i <= R - 1; ++i)
1608  {
1609  maparray[i - 1] = GetMode(1, 0, i);
1610  }
1611  break;
1612 
1613  case 6:
1614  for (i = 1; i <= R - 1; ++i)
1615  {
1616  maparray[i - 1] = GetMode(1, 1, i);
1617  }
1618  break;
1619 
1620  case 7:
1621  for (i = 2; i <= R; ++i)
1622  {
1623  maparray[i - 2] = GetMode(0, 1, i);
1624  }
1625  break;
1626 
1627  case 8:
1628  for (i = 2; i <= Q; ++i)
1629  {
1630  maparray[i - 2] = GetMode(0, i, 1);
1631  }
1632  break;
1633 
1634  default:
1635  ASSERTL0(false, "Edge not defined.");
1636  break;
1637  }
1638 
1639  if (signChange)
1640  {
1641  for (i = 1; i < nEdgeIntCoeffs; i += 2)
1642  {
1643  signarray[i] = -1;
1644  }
1645  }
1646 }
Nektar::StdRegions::StdPrismExp::v_GetEdgeNcoeffs
virtual int v_GetEdgeNcoeffs(const int i) const override
Definition: StdPrismExp.cpp:775

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

◆ v_GetEdgeNcoeffs()

int Nektar::StdRegions::StdPrismExp::v_GetEdgeNcoeffs ( const int  i) const
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion3D.

Definition at line 775 of file StdPrismExp.cpp.

776 {
777  ASSERTL2(i >= 0 && i <= 8, "edge id is out of range");
778 
779  if (i == 0 || i == 2)
780  {
781  return GetBasisNumModes(0);
782  }
783  else if (i == 1 || i == 3 || i == 8)
784  {
785  return GetBasisNumModes(1);
786  }
787  else
788  {
789  return GetBasisNumModes(2);
790  }
791 }
ASSERTL2
#define ASSERTL2(condition, msg)
Assert Level 2 – Debugging which is used FULLDEBUG compilation mode. This level assert is designed to...
Definition: ErrorUtil.hpp:272
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:175

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

Referenced by v_GetEdgeInteriorToElementMap().

◆ v_GetElmtTraceToTraceMap()

void Nektar::StdRegions::StdPrismExp::v_GetElmtTraceToTraceMap ( const unsigned int  fid,
Array< OneD, unsigned int > &  maparray,
Array< OneD, int > &  signarray,
Orientation  faceOrient,
int  P,
int  Q 
)
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 1260 of file StdPrismExp.cpp.

1264 {
1265  ASSERTL1(GetBasisType(0) == GetBasisType(1),
1266  "Method only implemented if BasisType is identical"
1267  "in x and y directions");
1268  ASSERTL1(GetBasisType(0) == LibUtilities::eModified_A &&
1269  GetBasisType(2) == LibUtilities::eModified_B,
1270  "Method only implemented for Modified_A BasisType"
1271  "(x and y direction) and Modified_B BasisType (z "
1272  "direction)");
1273 
1274  int i, j, k, p, r, nFaceCoeffs, idx = 0;
1275  int nummodesA = 0, nummodesB = 0;
1276 
1277  switch (fid)
1278  {
1279  case 0:
1280  nummodesA = m_base[0]->GetNumModes();
1281  nummodesB = m_base[1]->GetNumModes();
1282  break;
1283  case 1:
1284  case 3:
1285  nummodesA = m_base[0]->GetNumModes();
1286  nummodesB = m_base[2]->GetNumModes();
1287  break;
1288  case 2:
1289  case 4:
1290  nummodesA = m_base[1]->GetNumModes();
1291  nummodesB = m_base[2]->GetNumModes();
1292  break;
1293  default:
1294  ASSERTL0(false, "fid must be between 0 and 4");
1295  }
1296 
1297  if (P == -1)
1298  {
1299  P = nummodesA;
1300  Q = nummodesB;
1301  nFaceCoeffs = GetTraceNcoeffs(fid);
1302  }
1303  else if (fid == 1 || fid == 3)
1304  {
1305  nFaceCoeffs = P * (2 * Q - P + 1) / 2;
1306  }
1307  else
1308  {
1309  nFaceCoeffs = P * Q;
1310  }
1311 
1312  // Allocate the map array and sign array; set sign array to ones (+)
1313  if (maparray.size() != nFaceCoeffs)
1314  {
1315  maparray = Array<OneD, unsigned int>(nFaceCoeffs);
1316  }
1317 
1318  if (signarray.size() != nFaceCoeffs)
1319  {
1320  signarray = Array<OneD, int>(nFaceCoeffs, 1);
1321  }
1322  else
1323  {
1324  fill(signarray.get(), signarray.get() + nFaceCoeffs, 1);
1325  }
1326 
1327  int minPA = min(nummodesA, P);
1328  int minQB = min(nummodesB, Q);
1329  // triangular faces
1330  if (fid == 1 || fid == 3)
1331  {
1332  // zero signmap and set maparray to zero if elemental
1333  // modes are not as large as face modesl
1334  idx = 0;
1335  int cnt = 0;
1336 
1337  for (j = 0; j < minPA; ++j)
1338  {
1339  // set maparray
1340  for (k = 0; k < minQB - j; ++k, ++cnt)
1341  {
1342  maparray[idx++] = cnt;
1343  }
1344 
1345  cnt += nummodesB - minQB;
1346 
1347  // idx += nummodesB-j;
1348  for (k = nummodesB - j; k < Q - j; ++k)
1349  {
1350  signarray[idx] = 0.0;
1351  maparray[idx++] = maparray[0];
1352  }
1353  }
1354 #if 0 // no required?
1355  for (j = minPA; j < nummodesA; ++j)
1356  {
1357  // set maparray
1358  for (k = 0; k < minQB-j; ++k, ++cnt)
1359  {
1360  maparray[idx++] = cnt;
1361  }
1362 
1363  cnt += nummodesB-minQB;
1364 
1365  //idx += nummodesB-j;
1366  for (k = nummodesB-j; k < Q-j; ++k)
1367  {
1368  signarray[idx] = 0.0;
1369  maparray[idx++] = maparray[0];
1370  }
1371  }
1372 #endif
1373  for (j = nummodesA; j < P; ++j)
1374  {
1375  for (k = 0; k < Q - j; ++k)
1376  {
1377  signarray[idx] = 0.0;
1378  maparray[idx++] = maparray[0];
1379  }
1380  }
1381 
1382  // Triangles only have one possible orientation (base
1383  // direction reversed); swap edge modes.
1384  if (faceOrient == eDir1BwdDir1_Dir2FwdDir2)
1385  {
1386  idx = 0;
1387  for (p = 0; p < P; ++p)
1388  {
1389  for (r = 0; r < Q - p; ++r, idx++)
1390  {
1391  if (p > 1)
1392  {
1393  signarray[idx] = p % 2 ? -1 : 1;
1394  }
1395  }
1396  }
1397 
1398  swap(maparray[0], maparray[Q]);
1399  for (i = 1; i < Q - 1; ++i)
1400  {
1401  swap(maparray[i + 1], maparray[Q + i]);
1402  }
1403  }
1404  }
1405  else
1406  {
1407  // Set up an array indexing for quads, since the
1408  // ordering may need to be transposed.
1409  Array<OneD, int> arrayindx(nFaceCoeffs, -1);
1410 
1411  for (i = 0; i < Q; i++)
1412  {
1413  for (j = 0; j < P; j++)
1414  {
1415  if (faceOrient < eDir1FwdDir2_Dir2FwdDir1)
1416  {
1417  arrayindx[i * P + j] = i * P + j;
1418  }
1419  else
1420  {
1421  arrayindx[i * P + j] = j * Q + i;
1422  }
1423  }
1424  }
1425 
1426  // zero signmap and set maparray to zero if elemental
1427  // modes are not as large as face modesl
1428  for (j = 0; j < P; ++j)
1429  {
1430  // set up default maparray
1431  for (k = 0; k < Q; k++)
1432  {
1433  maparray[arrayindx[j + k * P]] = j + k * nummodesA;
1434  }
1435 
1436  for (k = nummodesB; k < Q; ++k)
1437  {
1438  signarray[arrayindx[j + k * P]] = 0.0;
1439  maparray[arrayindx[j + k * P]] = maparray[0];
1440  }
1441  }
1442 
1443  for (j = nummodesA; j < P; ++j)
1444  {
1445  for (k = 0; k < Q; ++k)
1446  {
1447  signarray[arrayindx[j + k * P]] = 0.0;
1448  maparray[arrayindx[j + k * P]] = maparray[0];
1449  }
1450  }
1451 
1452  // The code below is exactly the same as that taken from
1453  // StdHexExp and reverses the 'b' and 'a' directions as
1454  // appropriate (1st and 2nd if statements respectively) in
1455  // quadrilateral faces.
1456  if (faceOrient == eDir1FwdDir1_Dir2BwdDir2 ||
1457  faceOrient == eDir1BwdDir1_Dir2BwdDir2 ||
1458  faceOrient == eDir1BwdDir2_Dir2FwdDir1 ||
1459  faceOrient == eDir1BwdDir2_Dir2BwdDir1)
1460  {
1461  if (faceOrient < eDir1FwdDir2_Dir2FwdDir1)
1462  {
1463  for (i = 3; i < Q; i += 2)
1464  {
1465  for (j = 0; j < P; j++)
1466  {
1467  signarray[arrayindx[i * P + j]] *= -1;
1468  }
1469  }
1470 
1471  for (i = 0; i < P; i++)
1472  {
1473  swap(maparray[i], maparray[i + P]);
1474  swap(signarray[i], signarray[i + P]);
1475  }
1476  }
1477  else
1478  {
1479  for (i = 0; i < Q; i++)
1480  {
1481  for (j = 3; j < P; j += 2)
1482  {
1483  signarray[arrayindx[i * P + j]] *= -1;
1484  }
1485  }
1486 
1487  for (i = 0; i < Q; i++)
1488  {
1489  swap(maparray[i], maparray[i + Q]);
1490  swap(signarray[i], signarray[i + Q]);
1491  }
1492  }
1493  }
1494 
1495  if (faceOrient == eDir1BwdDir1_Dir2FwdDir2 ||
1496  faceOrient == eDir1BwdDir1_Dir2BwdDir2 ||
1497  faceOrient == eDir1FwdDir2_Dir2BwdDir1 ||
1498  faceOrient == eDir1BwdDir2_Dir2BwdDir1)
1499  {
1500  if (faceOrient < eDir1FwdDir2_Dir2FwdDir1)
1501  {
1502  for (i = 0; i < Q; i++)
1503  {
1504  for (j = 3; j < P; j += 2)
1505  {
1506  signarray[arrayindx[i * P + j]] *= -1;
1507  }
1508  }
1509 
1510  for (i = 0; i < Q; i++)
1511  {
1512  swap(maparray[i * P], maparray[i * P + 1]);
1513  swap(signarray[i * P], signarray[i * P + 1]);
1514  }
1515  }
1516  else
1517  {
1518  for (i = 3; i < Q; i += 2)
1519  {
1520  for (j = 0; j < P; j++)
1521  {
1522  signarray[arrayindx[i * P + j]] *= -1;
1523  }
1524  }
1525 
1526  for (i = 0; i < P; i++)
1527  {
1528  swap(maparray[i * Q], maparray[i * Q + 1]);
1529  swap(signarray[i * Q], signarray[i * Q + 1]);
1530  }
1531  }
1532  }
1533  }
1534 }
Nektar::StdRegions::StdExpansion::GetTraceNcoeffs
int GetTraceNcoeffs(const int i) const
This function returns the number of expansion coefficients belonging to the i-th trace.
Definition: StdExpansion.h:267

References ASSERTL0, ASSERTL1, Nektar::StdRegions::eDir1BwdDir1_Dir2BwdDir2, Nektar::StdRegions::eDir1BwdDir1_Dir2FwdDir2, Nektar::StdRegions::eDir1BwdDir2_Dir2BwdDir1, Nektar::StdRegions::eDir1BwdDir2_Dir2FwdDir1, Nektar::StdRegions::eDir1FwdDir1_Dir2BwdDir2, Nektar::StdRegions::eDir1FwdDir2_Dir2BwdDir1, Nektar::StdRegions::eDir1FwdDir2_Dir2FwdDir1, Nektar::LibUtilities::eModified_A, Nektar::LibUtilities::eModified_B, Nektar::StdRegions::StdExpansion::GetBasisType(), Nektar::StdRegions::StdExpansion::GetTraceNcoeffs(), Nektar::StdRegions::StdExpansion::m_base, Nektar::LibUtilities::P, and CellMLToNektar.cellml_metadata::p.

◆ v_GetInteriorMap()

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::StdRegions::StdNodalPrismExp.

Definition at line 1061 of file StdPrismExp.cpp.

1062 {
1063  ASSERTL1(GetBasisType(0) == LibUtilities::eModified_A ||
1064  GetBasisType(0) == LibUtilities::eGLL_Lagrange,
1065  "BasisType is not a boundary interior form");
1066  ASSERTL1(GetBasisType(1) == LibUtilities::eModified_A ||
1067  GetBasisType(1) == LibUtilities::eGLL_Lagrange,
1068  "BasisType is not a boundary interior form");
1069  ASSERTL1(GetBasisType(2) == LibUtilities::eModified_B ||
1070  GetBasisType(2) == LibUtilities::eGLL_Lagrange,
1071  "BasisType is not a boundary interior form");
1072 
1073  int P = m_base[0]->GetNumModes() - 1, p;
1074  int Q = m_base[1]->GetNumModes() - 1, q;
1075  int R = m_base[2]->GetNumModes() - 1, r;
1076 
1077  int nIntCoeffs = m_ncoeffs - NumBndryCoeffs();
1078 
1079  if (outarray.size() != nIntCoeffs)
1080  {
1081  outarray = Array<OneD, unsigned int>(nIntCoeffs);
1082  }
1083 
1084  int idx = 0;
1085 
1086  // Loop over all interior modes.
1087  for (p = 2; p <= P; ++p)
1088  {
1089  for (q = 2; q <= Q; ++q)
1090  {
1091  for (r = 1; r <= R - p; ++r)
1092  {
1093  outarray[idx++] = GetMode(p, q, r);
1094  }
1095  }
1096  }
1097 }

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

◆ v_GetNedges()

int Nektar::StdRegions::StdPrismExp::v_GetNedges ( void  ) const
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion3D.

Definition at line 802 of file StdPrismExp.cpp.

803 {
804  return 9;
805 }

◆ v_GetNtraces()

int Nektar::StdRegions::StdPrismExp::v_GetNtraces ( ) const
overrideprotectedvirtual

Implements Nektar::StdRegions::StdExpansion.

Definition at line 807 of file StdPrismExp.cpp.

808 {
809  return 5;
810 }

◆ v_GetNverts()

int Nektar::StdRegions::StdPrismExp::v_GetNverts ( ) const
overrideprotectedvirtual

Implements Nektar::StdRegions::StdExpansion.

Definition at line 797 of file StdPrismExp.cpp.

798 {
799  return 6;
800 }

◆ v_GetTraceBasisKey()

const LibUtilities::BasisKey Nektar::StdRegions::StdPrismExp::v_GetTraceBasisKey ( const int  i,
const int  k 
) const
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 939 of file StdPrismExp.cpp.

941 {
942  ASSERTL2(i >= 0 && i <= 4, "face id is out of range");
943  ASSERTL2(k >= 0 && k <= 1, "basis key id is out of range");
944 
945  switch (i)
946  {
947  case 0:
948  {
949  return EvaluateQuadFaceBasisKey(k, m_base[k]->GetBasisType(),
950  m_base[k]->GetNumPoints(),
951  m_base[k]->GetNumModes());
952  }
953  case 2:
954  case 4:
955  {
956  return EvaluateQuadFaceBasisKey(k, m_base[k + 1]->GetBasisType(),
957  m_base[k + 1]->GetNumPoints(),
958  m_base[k + 1]->GetNumModes());
959  }
960  case 1:
961  case 3:
962  {
963  return EvaluateTriFaceBasisKey(k, m_base[2 * k]->GetBasisType(),
964  m_base[2 * k]->GetNumPoints(),
965  m_base[2 * k]->GetNumModes());
966  }
967  break;
968  }
969 
970  // Should never get here.
971  return LibUtilities::NullBasisKey;
972 }
Nektar::LibUtilities::NullBasisKey
static const BasisKey NullBasisKey(eNoBasisType, 0, NullPointsKey)
Defines a null basis with no type or points.
Nektar::StdRegions::EvaluateTriFaceBasisKey
LibUtilities::BasisKey EvaluateTriFaceBasisKey(const int facedir, const LibUtilities::BasisType faceDirBasisType, const int numpoints, const int nummodes)
Definition: StdExpansion3D.cpp:509
Nektar::StdRegions::EvaluateQuadFaceBasisKey
LibUtilities::BasisKey EvaluateQuadFaceBasisKey(const int facedir, const LibUtilities::BasisType faceDirBasisType, const int numpoints, const int nummodes)
Definition: StdExpansion3D.cpp:453

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

◆ v_GetTraceCoeffMap()

void Nektar::StdRegions::StdPrismExp::v_GetTraceCoeffMap ( const unsigned int  fid,
Array< OneD, unsigned int > &  maparray 
)
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 1159 of file StdPrismExp.cpp.

1161 {
1162  ASSERTL1(GetBasisType(0) == GetBasisType(1),
1163  "Method only implemented if BasisType is identical"
1164  "in x and y directions");
1165  ASSERTL1(GetBasisType(0) == LibUtilities::eModified_A &&
1166  GetBasisType(2) == LibUtilities::eModified_B,
1167  "Method only implemented for Modified_A BasisType"
1168  "(x and y direction) and Modified_B BasisType (z "
1169  "direction)");
1170  int p, q, r, idx = 0;
1171  int P = 0, Q = 0;
1172 
1173  switch (fid)
1174  {
1175  case 0:
1176  P = m_base[0]->GetNumModes();
1177  Q = m_base[1]->GetNumModes();
1178  break;
1179  case 1:
1180  case 3:
1181  P = m_base[0]->GetNumModes();
1182  Q = m_base[2]->GetNumModes();
1183  break;
1184  case 2:
1185  case 4:
1186  P = m_base[1]->GetNumModes();
1187  Q = m_base[2]->GetNumModes();
1188  break;
1189  default:
1190  ASSERTL0(false, "fid must be between 0 and 4");
1191  }
1192 
1193  if (maparray.size() != P * Q)
1194  {
1195  maparray = Array<OneD, unsigned int>(P * Q);
1196  }
1197 
1198  // Set up ordering inside each 2D face. Also for triangular faces,
1199  // populate signarray.
1200  switch (fid)
1201  {
1202  case 0: // Bottom quad
1203  for (q = 0; q < Q; ++q)
1204  {
1205  for (p = 0; p < P; ++p)
1206  {
1207  maparray[q * P + p] = GetMode(p, q, 0);
1208  }
1209  }
1210  break;
1211  case 1: // Left triangle
1212  for (p = 0; p < P; ++p)
1213  {
1214  for (r = 0; r < Q - p; ++r)
1215  {
1216  maparray[idx++] = GetMode(p, 0, r);
1217  }
1218  }
1219  break;
1220  case 2: // Slanted quad
1221  for (q = 0; q < P; ++q)
1222  {
1223  maparray[q] = GetMode(1, q, 0);
1224  }
1225  for (q = 0; q < P; ++q)
1226  {
1227  maparray[P + q] = GetMode(0, q, 1);
1228  }
1229  for (r = 1; r < Q - 1; ++r)
1230  {
1231  for (q = 0; q < P; ++q)
1232  {
1233  maparray[(r + 1) * P + q] = GetMode(1, q, r);
1234  }
1235  }
1236  break;
1237  case 3: // Right triangle
1238  for (p = 0; p < P; ++p)
1239  {
1240  for (r = 0; r < Q - p; ++r)
1241  {
1242  maparray[idx++] = GetMode(p, 1, r);
1243  }
1244  }
1245  break;
1246  case 4: // Rear quad
1247  for (r = 0; r < Q; ++r)
1248  {
1249  for (q = 0; q < P; ++q)
1250  {
1251  maparray[r * P + q] = GetMode(0, q, r);
1252  }
1253  }
1254  break;
1255  default:
1256  ASSERTL0(false, "Face to element map unavailable.");
1257  }
1258 }

References ASSERTL0, ASSERTL1, Nektar::LibUtilities::eModified_A, Nektar::LibUtilities::eModified_B, Nektar::StdRegions::StdExpansion::GetBasisType(), GetMode(), Nektar::StdRegions::StdExpansion::m_base, Nektar::LibUtilities::P, and CellMLToNektar.cellml_metadata::p.

◆ v_GetTraceInteriorToElementMap()

void Nektar::StdRegions::StdPrismExp::v_GetTraceInteriorToElementMap ( const int  tid,
Array< OneD, unsigned int > &  maparray,
Array< OneD, int > &  signarray,
const Orientation  traceOrient = eDir1FwdDir1_Dir2FwdDir2 
)
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 1648 of file StdPrismExp.cpp.

1651 {
1652  const int P = m_base[0]->GetNumModes() - 1;
1653  const int Q = m_base[1]->GetNumModes() - 1;
1654  const int R = m_base[2]->GetNumModes() - 1;
1655  const int nFaceIntCoeffs = v_GetTraceIntNcoeffs(fid);
1656  int p, q, r, idx = 0;
1657  int nummodesA = 0;
1658  int nummodesB = 0;
1659  int i = 0;
1660  int j = 0;
1661 
1662  if (maparray.size() != nFaceIntCoeffs)
1663  {
1664  maparray = Array<OneD, unsigned int>(nFaceIntCoeffs);
1665  }
1666 
1667  if (signarray.size() != nFaceIntCoeffs)
1668  {
1669  signarray = Array<OneD, int>(nFaceIntCoeffs, 1);
1670  }
1671  else
1672  {
1673  fill(signarray.get(), signarray.get() + nFaceIntCoeffs, 1);
1674  }
1675 
1676  // Set up an array indexing for quad faces, since the ordering may
1677  // need to be transposed depending on orientation.
1678  Array<OneD, int> arrayindx(nFaceIntCoeffs);
1679  if (fid != 1 && fid != 3)
1680  {
1681  if (fid == 0) // Base quad
1682  {
1683  nummodesA = P - 1;
1684  nummodesB = Q - 1;
1685  }
1686  else // front and back quad
1687  {
1688  nummodesA = Q - 1;
1689  nummodesB = R - 1;
1690  }
1691 
1692  for (i = 0; i < nummodesB; i++)
1693  {
1694  for (j = 0; j < nummodesA; j++)
1695  {
1696  if (faceOrient < eDir1FwdDir2_Dir2FwdDir1)
1697  {
1698  arrayindx[i * nummodesA + j] = i * nummodesA + j;
1699  }
1700  else
1701  {
1702  arrayindx[i * nummodesA + j] = j * nummodesB + i;
1703  }
1704  }
1705  }
1706  }
1707 
1708  switch (fid)
1709  {
1710  case 0: // Bottom quad
1711  for (q = 2; q <= Q; ++q)
1712  {
1713  for (p = 2; p <= P; ++p)
1714  {
1715  maparray[arrayindx[(q - 2) * nummodesA + (p - 2)]] =
1716  GetMode(p, q, 0);
1717  }
1718  }
1719  break;
1720 
1721  case 1: // Left triangle
1722  for (p = 2; p <= P; ++p)
1723  {
1724  for (r = 1; r <= R - p; ++r)
1725  {
1726  if (faceOrient == eDir1BwdDir1_Dir2FwdDir2)
1727  {
1728  signarray[idx] = p % 2 ? -1 : 1;
1729  }
1730  maparray[idx++] = GetMode(p, 0, r);
1731  }
1732  }
1733  break;
1734 
1735  case 2: // Slanted quad
1736  for (r = 1; r <= R - 1; ++r)
1737  {
1738  for (q = 2; q <= Q; ++q)
1739  {
1740  maparray[arrayindx[(r - 1) * nummodesA + (q - 2)]] =
1741  GetMode(1, q, r);
1742  }
1743  }
1744  break;
1745 
1746  case 3: // Right triangle
1747  for (p = 2; p <= P; ++p)
1748  {
1749  for (r = 1; r <= R - p; ++r)
1750  {
1751  if (faceOrient == eDir1BwdDir1_Dir2FwdDir2)
1752  {
1753  signarray[idx] = p % 2 ? -1 : 1;
1754  }
1755  maparray[idx++] = GetMode(p, 1, r);
1756  }
1757  }
1758  break;
1759 
1760  case 4: // Back quad
1761  for (r = 2; r <= R; ++r)
1762  {
1763  for (q = 2; q <= Q; ++q)
1764  {
1765  maparray[arrayindx[(r - 2) * nummodesA + (q - 2)]] =
1766  GetMode(0, q, r);
1767  }
1768  }
1769  break;
1770 
1771  default:
1772  ASSERTL0(false, "Face interior map not available.");
1773  }
1774 
1775  // Triangular faces are processed in the above switch loop; for
1776  // remaining quad faces, set up orientation if necessary.
1777  if (fid == 1 || fid == 3)
1778  return;
1779 
1780  if (faceOrient == eDir1FwdDir1_Dir2BwdDir2 ||
1781  faceOrient == eDir1BwdDir1_Dir2BwdDir2 ||
1782  faceOrient == eDir1BwdDir2_Dir2FwdDir1 ||
1783  faceOrient == eDir1BwdDir2_Dir2BwdDir1)
1784  {
1785  if (faceOrient < eDir1FwdDir2_Dir2FwdDir1)
1786  {
1787  for (i = 1; i < nummodesB; i += 2)
1788  {
1789  for (j = 0; j < nummodesA; j++)
1790  {
1791  signarray[arrayindx[i * nummodesA + j]] *= -1;
1792  }
1793  }
1794  }
1795  else
1796  {
1797  for (i = 0; i < nummodesB; i++)
1798  {
1799  for (j = 1; j < nummodesA; j += 2)
1800  {
1801  signarray[arrayindx[i * nummodesA + j]] *= -1;
1802  }
1803  }
1804  }
1805  }
1806 
1807  if (faceOrient == eDir1BwdDir1_Dir2FwdDir2 ||
1808  faceOrient == eDir1BwdDir1_Dir2BwdDir2 ||
1809  faceOrient == eDir1FwdDir2_Dir2BwdDir1 ||
1810  faceOrient == eDir1BwdDir2_Dir2BwdDir1)
1811  {
1812  if (faceOrient < eDir1FwdDir2_Dir2FwdDir1)
1813  {
1814  for (i = 0; i < nummodesB; i++)
1815  {
1816  for (j = 1; j < nummodesA; j += 2)
1817  {
1818  signarray[arrayindx[i * nummodesA + j]] *= -1;
1819  }
1820  }
1821  }
1822  else
1823  {
1824  for (i = 1; i < nummodesB; i += 2)
1825  {
1826  for (j = 0; j < nummodesA; j++)
1827  {
1828  signarray[arrayindx[i * nummodesA + j]] *= -1;
1829  }
1830  }
1831  }
1832  }
1833 }
Nektar::StdRegions::StdPrismExp::v_GetTraceIntNcoeffs
virtual int v_GetTraceIntNcoeffs(const int i) const override
Definition: StdPrismExp.cpp:879

References ASSERTL0, Nektar::StdRegions::eDir1BwdDir1_Dir2BwdDir2, Nektar::StdRegions::eDir1BwdDir1_Dir2FwdDir2, Nektar::StdRegions::eDir1BwdDir2_Dir2BwdDir1, Nektar::StdRegions::eDir1BwdDir2_Dir2FwdDir1, Nektar::StdRegions::eDir1FwdDir1_Dir2BwdDir2, Nektar::StdRegions::eDir1FwdDir2_Dir2BwdDir1, Nektar::StdRegions::eDir1FwdDir2_Dir2FwdDir1, GetMode(), Nektar::StdRegions::StdExpansion::m_base, Nektar::LibUtilities::P, CellMLToNektar.cellml_metadata::p, and v_GetTraceIntNcoeffs().

◆ v_GetTraceIntNcoeffs()

int Nektar::StdRegions::StdPrismExp::v_GetTraceIntNcoeffs ( const int  i) const
overrideprotectedvirtual

Implements Nektar::StdRegions::StdExpansion.

Definition at line 879 of file StdPrismExp.cpp.

880 {
881  ASSERTL2(i >= 0 && i <= 4, "face id is out of range");
882 
883  int Pi = GetBasisNumModes(0) - 2;
884  int Qi = GetBasisNumModes(1) - 2;
885  int Ri = GetBasisNumModes(2) - 2;
886 
887  if (i == 0)
888  {
889  return Pi * Qi;
890  }
891  else if (i == 1 || i == 3)
892  {
893  return Pi * (2 * Ri - Pi - 1) / 2;
894  }
895  else
896  {
897  return Qi * Ri;
898  }
899 }

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

Referenced by v_GetTraceInteriorToElementMap().

◆ v_GetTraceNcoeffs()

int Nektar::StdRegions::StdPrismExp::v_GetTraceNcoeffs ( const int  i) const
overrideprotectedvirtual

Implements Nektar::StdRegions::StdExpansion.

Definition at line 861 of file StdPrismExp.cpp.

862 {
863  ASSERTL2(i >= 0 && i <= 4, "face id is out of range");
864  if (i == 0)
865  {
866  return GetBasisNumModes(0) * GetBasisNumModes(1);
867  }
868  else if (i == 1 || i == 3)
869  {
870  int P = GetBasisNumModes(0) - 1, Q = GetBasisNumModes(2) - 1;
871  return Q + 1 + (P * (1 + 2 * Q - P)) / 2;
872  }
873  else
874  {
875  return GetBasisNumModes(1) * GetBasisNumModes(2);
876  }
877 }

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

◆ v_GetTraceNumModes()

void Nektar::StdRegions::StdPrismExp::v_GetTraceNumModes ( const int  fid,
int &  numModes0,
int &  numModes1,
Orientation  faceOrient = eDir1FwdDir1_Dir2FwdDir2 
)
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 737 of file StdPrismExp.cpp.

739 {
740  int nummodes[3] = {m_base[0]->GetNumModes(), m_base[1]->GetNumModes(),
741  m_base[2]->GetNumModes()};
742  switch (fid)
743  {
744  // base quad
745  case 0:
746  {
747  numModes0 = nummodes[0];
748  numModes1 = nummodes[1];
749  }
750  break;
751  // front and back quad
752  case 2:
753  case 4:
754  {
755  numModes0 = nummodes[1];
756  numModes1 = nummodes[2];
757  }
758  break;
759  // triangles
760  case 1:
761  case 3:
762  {
763  numModes0 = nummodes[0];
764  numModes1 = nummodes[2];
765  }
766  break;
767  }
768 
769  if (faceOrient >= eDir1FwdDir2_Dir2FwdDir1)
770  {
771  std::swap(numModes0, numModes1);
772  }
773 }

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

◆ v_GetTraceNumPoints()

int Nektar::StdRegions::StdPrismExp::v_GetTraceNumPoints ( const int  i) const
overrideprotectedvirtual

Implements Nektar::StdRegions::StdExpansion.

Definition at line 901 of file StdPrismExp.cpp.

902 {
903  ASSERTL2(i >= 0 && i <= 4, "face id is out of range");
904 
905  if (i == 0)
906  {
907  return m_base[0]->GetNumPoints() * m_base[1]->GetNumPoints();
908  }
909  else if (i == 1 || i == 3)
910  {
911  return m_base[0]->GetNumPoints() * m_base[2]->GetNumPoints();
912  }
913  else
914  {
915  return m_base[1]->GetNumPoints() * m_base[2]->GetNumPoints();
916  }
917 }

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

◆ v_GetTracePointsKey()

LibUtilities::PointsKey Nektar::StdRegions::StdPrismExp::v_GetTracePointsKey ( const int  i,
const int  j 
) const
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 919 of file StdPrismExp.cpp.

921 {
922  ASSERTL2(i >= 0 && i <= 4, "face id is out of range");
923  ASSERTL2(j == 0 || j == 1, "face direction is out of range");
924 
925  if (i == 0)
926  {
927  return m_base[j]->GetPointsKey();
928  }
929  else if (i == 1 || i == 3)
930  {
931  return m_base[2 * j]->GetPointsKey();
932  }
933  else
934  {
935  return m_base[j + 1]->GetPointsKey();
936  }
937 }

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

◆ v_GetVertexMap()

int Nektar::StdRegions::StdPrismExp::v_GetVertexMap ( int  localVertexId,
bool  useCoeffPacking = false 
)
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::StdRegions::StdNodalPrismExp.

Definition at line 996 of file StdPrismExp.cpp.

997 {
998  ASSERTL1(GetBasisType(0) == LibUtilities::eModified_A ||
999  GetBasisType(1) == LibUtilities::eModified_A ||
1000  GetBasisType(2) == LibUtilities::eModified_B,
1001  "Mapping not defined for this type of basis");
1002 
1003  int l = 0;
1004 
1005  if (useCoeffPacking == true) // follow packing of coefficients i.e q,r,p
1006  {
1007  switch (vId)
1008  {
1009  case 0:
1010  l = GetMode(0, 0, 0);
1011  break;
1012  case 1:
1013  l = GetMode(0, 0, 1);
1014  break;
1015  case 2:
1016  l = GetMode(0, 1, 0);
1017  break;
1018  case 3:
1019  l = GetMode(0, 1, 1);
1020  break;
1021  case 4:
1022  l = GetMode(1, 0, 0);
1023  break;
1024  case 5:
1025  l = GetMode(1, 1, 0);
1026  break;
1027  default:
1028  ASSERTL0(false, "local vertex id must be between 0 and 5");
1029  }
1030  }
1031  else
1032  {
1033  switch (vId)
1034  {
1035  case 0:
1036  l = GetMode(0, 0, 0);
1037  break;
1038  case 1:
1039  l = GetMode(1, 0, 0);
1040  break;
1041  case 2:
1042  l = GetMode(1, 1, 0);
1043  break;
1044  case 3:
1045  l = GetMode(0, 1, 0);
1046  break;
1047  case 4:
1048  l = GetMode(0, 0, 1);
1049  break;
1050  case 5:
1051  l = GetMode(0, 1, 1);
1052  break;
1053  default:
1054  ASSERTL0(false, "local vertex id must be between 0 and 5");
1055  }
1056  }
1057 
1058  return l;
1059 }

References ASSERTL0, ASSERTL1, Nektar::LibUtilities::eModified_A, Nektar::LibUtilities::eModified_B, Nektar::StdRegions::StdExpansion::GetBasisType(), and GetMode().

◆ v_IProductWRTBase()

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

Calculate the inner product of inarray with respect to the basis B=base0*base1*base2 and put into outarray:

\( \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} (\bar \eta_{1i}) \psi_{q}^{a} (\xi_{2j}) \psi_{pr}^{b} (\xi_{3k}) w_i w_j w_k u(\bar \eta_{1,i} \xi_{2,j} \xi_{3,k}) J_{i,j,k}\\ & = & \sum_{i=0}^{nq_0} \psi_p^a(\bar \eta_{1,i}) \sum_{j=0}^{nq_1} \psi_{q}^a(\xi_{2,j}) \sum_{k=0}^{nq_2} \psi_{pr}^b u(\bar \eta_{1i},\xi_{2j},\xi_{3k}) J_{i,j,k} \end{array} \)
where

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

Implements Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::LocalRegions::PrismExp.

Definition at line 386 of file StdPrismExp.cpp.

388 {
389  ASSERTL1((m_base[1]->GetBasisType() != LibUtilities::eOrtho_B) ||
390  (m_base[1]->GetBasisType() != LibUtilities::eModified_B),
391  "Basis[1] is not a general tensor type");
392 
393  ASSERTL1((m_base[2]->GetBasisType() != LibUtilities::eOrtho_C) ||
394  (m_base[2]->GetBasisType() != LibUtilities::eModified_C),
395  "Basis[2] is not a general tensor type");
396 
397  if (m_base[0]->Collocation() && m_base[1]->Collocation())
398  {
399  MultiplyByQuadratureMetric(inarray, outarray);
400  }
401  else
402  {
403  StdPrismExp::v_IProductWRTBase_SumFac(inarray, outarray);
404  }
405 }
Nektar::StdRegions::StdExpansion::MultiplyByQuadratureMetric
void MultiplyByQuadratureMetric(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
Definition: StdExpansion.h:729
Nektar::StdRegions::StdPrismExp::v_IProductWRTBase_SumFac
virtual void v_IProductWRTBase_SumFac(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, bool multiplybyweights=true) override
Definition: StdPrismExp.cpp:407

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 v_FwdTrans().

◆ v_IProductWRTBase_SumFac()

void Nektar::StdRegions::StdPrismExp::v_IProductWRTBase_SumFac ( const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray,
bool  multiplybyweights = true 
)
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::LocalRegions::PrismExp, and Nektar::StdRegions::StdNodalPrismExp.

Definition at line 407 of file StdPrismExp.cpp.

410 {
411  int nquad1 = m_base[1]->GetNumPoints();
412  int nquad2 = m_base[2]->GetNumPoints();
413  int order0 = m_base[0]->GetNumModes();
414  int order1 = m_base[1]->GetNumModes();
415 
416  Array<OneD, NekDouble> wsp(order0 * nquad2 * (nquad1 + order1));
417 
418  if (multiplybyweights)
419  {
420  Array<OneD, NekDouble> tmp(inarray.size());
421 
422  MultiplyByQuadratureMetric(inarray, tmp);
423  IProductWRTBase_SumFacKernel(
424  m_base[0]->GetBdata(), m_base[1]->GetBdata(), m_base[2]->GetBdata(),
425  tmp, outarray, wsp, true, true, true);
426  }
427  else
428  {
429  IProductWRTBase_SumFacKernel(
430  m_base[0]->GetBdata(), m_base[1]->GetBdata(), m_base[2]->GetBdata(),
431  inarray, outarray, wsp, true, true, true);
432  }
433 }
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:122

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

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

◆ v_IProductWRTBase_SumFacKernel()

void Nektar::StdRegions::StdPrismExp::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 
)
overrideprotectedvirtual

Implements Nektar::StdRegions::StdExpansion3D.

Definition at line 435 of file StdPrismExp.cpp.

442 {
443  boost::ignore_unused(doCheckCollDir0, doCheckCollDir1, doCheckCollDir2);
444 
445  // Interior prism implementation based on Spen's book page
446  // 119. and 608.
447  const int nquad0 = m_base[0]->GetNumPoints();
448  const int nquad1 = m_base[1]->GetNumPoints();
449  const int nquad2 = m_base[2]->GetNumPoints();
450  const int order0 = m_base[0]->GetNumModes();
451  const int order1 = m_base[1]->GetNumModes();
452  const int order2 = m_base[2]->GetNumModes();
453 
454  int i, mode;
455 
456  ASSERTL1(wsp.size() >= nquad1 * nquad2 * order0 + nquad2 * order0 * order1,
457  "Insufficient workspace size");
458 
459  Array<OneD, NekDouble> tmp0 = wsp;
460  Array<OneD, NekDouble> tmp1 = wsp + nquad1 * nquad2 * order0;
461 
462  // Inner product with respect to the '0' direction
463  Blas::Dgemm('T', 'N', nquad1 * nquad2, order0, nquad0, 1.0, inarray.get(),
464  nquad0, base0.get(), nquad0, 0.0, tmp0.get(), nquad1 * nquad2);
465 
466  // Inner product with respect to the '1' direction
467  Blas::Dgemm('T', 'N', nquad2 * order0, order1, nquad1, 1.0, tmp0.get(),
468  nquad1, base1.get(), nquad1, 0.0, tmp1.get(), nquad2 * order0);
469 
470  // Inner product with respect to the '2' direction
471  for (mode = i = 0; i < order0; ++i)
472  {
473  Blas::Dgemm('T', 'N', order2 - i, order1, nquad2, 1.0,
474  base2.get() + mode * nquad2, nquad2,
475  tmp1.get() + i * nquad2, nquad2 * order0, 0.0,
476  outarray.get() + mode * order1, order2 - i);
477  mode += order2 - i;
478  }
479 
480  // Fix top singular vertices; performs phi_{0,q,1} +=
481  // phi_1(xi_1)*phi_q(xi_2)*phi_{01}*phi_r(xi_2).
482  if (m_base[0]->GetBasisType() == LibUtilities::eModified_A)
483  {
484  for (i = 0; i < order1; ++i)
485  {
486  mode = GetMode(0, i, 1);
487  outarray[mode] +=
488  Blas::Ddot(nquad2, base2.get() + nquad2, 1,
489  tmp1.get() + i * order0 * nquad2 + nquad2, 1);
490  }
491  }
492 }
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:182

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

◆ v_IProductWRTDerivBase()

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

Inner product of inarray over region with respect to the object's default expansion basis; output in outarray.

Reimplemented from Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::StdRegions::StdNodalPrismExp, and Nektar::LocalRegions::PrismExp.

Definition at line 498 of file StdPrismExp.cpp.

501 {
502  v_IProductWRTDerivBase_SumFac(dir, inarray, outarray);
503 }
Nektar::StdRegions::StdPrismExp::v_IProductWRTDerivBase_SumFac
virtual void v_IProductWRTDerivBase_SumFac(const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) override
Definition: StdPrismExp.cpp:505

References v_IProductWRTDerivBase_SumFac().

◆ v_IProductWRTDerivBase_SumFac()

void Nektar::StdRegions::StdPrismExp::v_IProductWRTDerivBase_SumFac ( const int  dir,
const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray 
)
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::StdRegions::StdNodalPrismExp, and Nektar::LocalRegions::PrismExp.

Definition at line 505 of file StdPrismExp.cpp.

508 {
509  ASSERTL0(dir >= 0 && dir <= 2, "input dir is out of range");
510 
511  int i;
512  int order0 = m_base[0]->GetNumModes();
513  int order1 = m_base[1]->GetNumModes();
514  int nquad0 = m_base[0]->GetNumPoints();
515  int nquad1 = m_base[1]->GetNumPoints();
516  int nquad2 = m_base[2]->GetNumPoints();
517 
518  const Array<OneD, const NekDouble> &z0 = m_base[0]->GetZ();
519  const Array<OneD, const NekDouble> &z2 = m_base[2]->GetZ();
520  Array<OneD, NekDouble> gfac0(nquad0);
521  Array<OneD, NekDouble> gfac2(nquad2);
522  Array<OneD, NekDouble> tmp0(nquad0 * nquad1 * nquad2);
523  Array<OneD, NekDouble> wsp(order0 * nquad2 * (nquad1 + order1));
524 
525  // set up geometric factor: (1+z0)/2
526  for (i = 0; i < nquad0; ++i)
527  {
528  gfac0[i] = 0.5 * (1 + z0[i]);
529  }
530 
531  // Set up geometric factor: 2/(1-z2)
532  for (i = 0; i < nquad2; ++i)
533  {
534  gfac2[i] = 2.0 / (1 - z2[i]);
535  }
536 
537  // Scale first derivative term by gfac2.
538  if (dir != 1)
539  {
540  for (i = 0; i < nquad2; ++i)
541  {
542  Vmath::Smul(nquad0 * nquad1, gfac2[i],
543  &inarray[0] + i * nquad0 * nquad1, 1,
544  &tmp0[0] + i * nquad0 * nquad1, 1);
545  }
546  MultiplyByQuadratureMetric(tmp0, tmp0);
547  }
548 
549  switch (dir)
550  {
551  case 0:
552  {
553  IProductWRTBase_SumFacKernel(
554  m_base[0]->GetDbdata(), m_base[1]->GetBdata(),
555  m_base[2]->GetBdata(), tmp0, outarray, wsp, true, true, true);
556  break;
557  }
558  case 1:
559  {
560  MultiplyByQuadratureMetric(inarray, tmp0);
561  IProductWRTBase_SumFacKernel(
562  m_base[0]->GetBdata(), m_base[1]->GetDbdata(),
563  m_base[2]->GetBdata(), tmp0, outarray, wsp, true, true, true);
564  break;
565  }
566 
567  case 2:
568  {
569  Array<OneD, NekDouble> tmp1(m_ncoeffs);
570 
571  // Scale eta_1 derivative with gfac0.
572  for (i = 0; i < nquad1 * nquad2; ++i)
573  {
574  Vmath::Vmul(nquad0, &gfac0[0], 1, &tmp0[0] + i * nquad0, 1,
575  &tmp0[0] + i * nquad0, 1);
576  }
577 
578  IProductWRTBase_SumFacKernel(
579  m_base[0]->GetDbdata(), m_base[1]->GetBdata(),
580  m_base[2]->GetBdata(), tmp0, tmp1, wsp, true, true, true);
581 
582  MultiplyByQuadratureMetric(inarray, tmp0);
583  IProductWRTBase_SumFacKernel(
584  m_base[0]->GetBdata(), m_base[1]->GetBdata(),
585  m_base[2]->GetDbdata(), tmp0, outarray, wsp, true, true, true);
586 
587  Vmath::Vadd(m_ncoeffs, &tmp1[0], 1, &outarray[0], 1, &outarray[0],
588  1);
589  break;
590  }
591  }
592 }
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:209
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:359

References ASSERTL0, 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 v_IProductWRTDerivBase(), and Nektar::StdRegions::StdNodalPrismExp::v_IProductWRTDerivBase_SumFac().

◆ v_IsBoundaryInteriorExpansion()

bool Nektar::StdRegions::StdPrismExp::v_IsBoundaryInteriorExpansion ( ) const
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 985 of file StdPrismExp.cpp.

986 {
987  return (m_base[0]->GetBasisType() == LibUtilities::eModified_A) &&
988  (m_base[1]->GetBasisType() == LibUtilities::eModified_A) &&
989  (m_base[2]->GetBasisType() == LibUtilities::eModified_B);
990 }

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

◆ v_LocCollapsedToLocCoord()

void Nektar::StdRegions::StdPrismExp::v_LocCollapsedToLocCoord ( const Array< OneD, const NekDouble > &  eta,
Array< OneD, NekDouble > &  xi 
)
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 618 of file StdPrismExp.cpp.

620 {
621  xi[0] = (1.0 + eta[0]) * (1.0 - eta[2]) * 0.5 - 1.0;
622  xi[1] = eta[1];
623  xi[2] = eta[2];
624 }

◆ v_LocCoordToLocCollapsed()

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 598 of file StdPrismExp.cpp.

600 {
601  NekDouble d2 = 1.0 - xi[2];
602  if (fabs(d2) < NekConstants::kNekZeroTol)
603  {
604  if (d2 >= 0.)
605  {
606  d2 = NekConstants::kNekZeroTol;
607  }
608  else
609  {
610  d2 = -NekConstants::kNekZeroTol;
611  }
612  }
613  eta[2] = xi[2]; // eta_z = xi_z
614  eta[1] = xi[1]; // eta_y = xi_y
615  eta[0] = 2.0 * (1.0 + xi[0]) / d2 - 1.0;
616 }
Nektar::NekConstants::kNekZeroTol
static const NekDouble kNekZeroTol
Definition: NektarUnivConsts.hpp:51

References Nektar::NekConstants::kNekZeroTol.

◆ v_MultiplyByStdQuadratureMetric()

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 1960 of file StdPrismExp.cpp.

1963 {
1964  int i, j;
1965  int nquad0 = m_base[0]->GetNumPoints();
1966  int nquad1 = m_base[1]->GetNumPoints();
1967  int nquad2 = m_base[2]->GetNumPoints();
1968 
1969  const Array<OneD, const NekDouble> &w0 = m_base[0]->GetW();
1970  const Array<OneD, const NekDouble> &w1 = m_base[1]->GetW();
1971  const Array<OneD, const NekDouble> &w2 = m_base[2]->GetW();
1972 
1973  const Array<OneD, const NekDouble> &z2 = m_base[2]->GetZ();
1974 
1975  // Multiply by integration constants in x-direction
1976  for (i = 0; i < nquad1 * nquad2; ++i)
1977  {
1978  Vmath::Vmul(nquad0, inarray.get() + i * nquad0, 1, w0.get(), 1,
1979  outarray.get() + i * nquad0, 1);
1980  }
1981 
1982  // Multiply by integration constants in y-direction
1983  for (j = 0; j < nquad2; ++j)
1984  {
1985  for (i = 0; i < nquad1; ++i)
1986  {
1987  Blas::Dscal(nquad0, w1[i],
1988  &outarray[0] + i * nquad0 + j * nquad0 * nquad1, 1);
1989  }
1990  }
1991 
1992  // Multiply by integration constants in z-direction; need to
1993  // incorporate factor (1-eta_3)/2 into weights, but only if using
1994  // GLL quadrature points.
1995  switch (m_base[2]->GetPointsType())
1996  {
1997  // (1,0) Jacobi inner product.
1998  case LibUtilities::eGaussRadauMAlpha1Beta0:
1999  for (i = 0; i < nquad2; ++i)
2000  {
2001  Blas::Dscal(nquad0 * nquad1, 0.5 * w2[i],
2002  &outarray[0] + i * nquad0 * nquad1, 1);
2003  }
2004  break;
2005 
2006  default:
2007  for (i = 0; i < nquad2; ++i)
2008  {
2009  Blas::Dscal(nquad0 * nquad1, 0.5 * (1 - z2[i]) * w2[i],
2010  &outarray[0] + i * nquad0 * nquad1, 1);
2011  }
2012  break;
2013  }
2014 }
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:211
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:168

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

◆ v_NumBndryCoeffs()

int Nektar::StdRegions::StdPrismExp::v_NumBndryCoeffs ( ) const
overrideprotectedvirtual

Implements Nektar::StdRegions::StdExpansion.

Definition at line 821 of file StdPrismExp.cpp.

822 {
823  ASSERTL1(GetBasisType(0) == LibUtilities::eModified_A ||
824  GetBasisType(0) == LibUtilities::eGLL_Lagrange,
825  "BasisType is not a boundary interior form");
826  ASSERTL1(GetBasisType(1) == LibUtilities::eModified_A ||
827  GetBasisType(1) == LibUtilities::eGLL_Lagrange,
828  "BasisType is not a boundary interior form");
829  ASSERTL1(GetBasisType(2) == LibUtilities::eModified_B ||
830  GetBasisType(2) == LibUtilities::eGLL_Lagrange,
831  "BasisType is not a boundary interior form");
832 
833  int P = m_base[0]->GetNumModes();
834  int Q = m_base[1]->GetNumModes();
835  int R = m_base[2]->GetNumModes();
836 
837  return LibUtilities::StdPrismData::getNumberOfBndCoefficients(P, Q, R);
838 }
Nektar::LibUtilities::StdPrismData::getNumberOfBndCoefficients
int getNumberOfBndCoefficients(int Na, int Nb, int Nc)
Definition: ShapeType.hpp:295

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

◆ v_NumDGBndryCoeffs()

int Nektar::StdRegions::StdPrismExp::v_NumDGBndryCoeffs ( ) const
overrideprotectedvirtual

Implements Nektar::StdRegions::StdExpansion.

Definition at line 840 of file StdPrismExp.cpp.

841 {
842  ASSERTL1(GetBasisType(0) == LibUtilities::eModified_A ||
843  GetBasisType(0) == LibUtilities::eGLL_Lagrange,
844  "BasisType is not a boundary interior form");
845  ASSERTL1(GetBasisType(1) == LibUtilities::eModified_A ||
846  GetBasisType(1) == LibUtilities::eGLL_Lagrange,
847  "BasisType is not a boundary interior form");
848  ASSERTL1(GetBasisType(2) == LibUtilities::eModified_B ||
849  GetBasisType(2) == LibUtilities::eGLL_Lagrange,
850  "BasisType is not a boundary interior form");
851 
852  int P = m_base[0]->GetNumModes() - 1;
853  int Q = m_base[1]->GetNumModes() - 1;
854  int R = m_base[2]->GetNumModes() - 1;
855 
856  return (P + 1) * (Q + 1) // 1 rect. face on base
857  + 2 * (Q + 1) * (R + 1) // other 2 rect. faces
858  + 2 * (R + 1) + P * (1 + 2 * R - P); // 2 tri. faces
859 }

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

◆ v_PhysDeriv() [1/2]

void Nektar::StdRegions::StdPrismExp::v_PhysDeriv ( const Array< OneD, const NekDouble > &  u_physical,
Array< OneD, NekDouble > &  out_dxi1,
Array< OneD, NekDouble > &  out_dxi2,
Array< OneD, NekDouble > &  out_dxi3 
)
overrideprotectedvirtual

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 2 {(1-\eta_3)} \frac \partial {\partial \bar \eta_1} \\ \frac {\partial} {\partial \xi_2} \ \ \frac {(1 + \bar \eta_1)} {(1 - \eta_3)} \frac \partial {\partial \bar \eta_1} + \frac {\partial} {\partial \eta_3} \end{Bmatrix}\)

Reimplemented from Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::LocalRegions::PrismExp.

Definition at line 93 of file StdPrismExp.cpp.

97 {
98  int Qx = m_base[0]->GetNumPoints();
99  int Qy = m_base[1]->GetNumPoints();
100  int Qz = m_base[2]->GetNumPoints();
101  int Qtot = Qx * Qy * Qz;
102 
103  Array<OneD, NekDouble> dEta_bar1(Qtot, 0.0);
104 
105  Array<OneD, const NekDouble> eta_x, eta_z;
106  eta_x = m_base[0]->GetZ();
107  eta_z = m_base[2]->GetZ();
108 
109  int i, k;
110 
111  bool Do_1 = (out_dxi1.size() > 0) ? true : false;
112  bool Do_3 = (out_dxi3.size() > 0) ? true : false;
113 
114  // out_dXi2 is just a tensor derivative so is just passed through
115  if (Do_3)
116  {
117  PhysTensorDeriv(u_physical, dEta_bar1, out_dxi2, out_dxi3);
118  }
119  else if (Do_1)
120  {
121  PhysTensorDeriv(u_physical, dEta_bar1, out_dxi2, NullNekDouble1DArray);
122  }
123  else // case if just require 2nd direction
124  {
125  PhysTensorDeriv(u_physical, NullNekDouble1DArray, out_dxi2,
126  NullNekDouble1DArray);
127  }
128 
129  if (Do_1)
130  {
131  for (k = 0; k < Qz; ++k)
132  {
133  Vmath::Smul(Qx * Qy, 2.0 / (1.0 - eta_z[k]),
134  &dEta_bar1[0] + k * Qx * Qy, 1,
135  &out_dxi1[0] + k * Qx * Qy, 1);
136  }
137  }
138 
139  if (Do_3)
140  {
141  // divide dEta_Bar1 by (1-eta_z)
142  for (k = 0; k < Qz; ++k)
143  {
144  Vmath::Smul(Qx * Qy, 1.0 / (1.0 - eta_z[k]),
145  &dEta_bar1[0] + k * Qx * Qy, 1,
146  &dEta_bar1[0] + k * Qx * Qy, 1);
147  }
148 
149  // Multiply dEta_Bar1 by (1+eta_x) and add ot out_dxi3
150  for (i = 0; i < Qx; ++i)
151  {
152  Vmath::Svtvp(Qz * Qy, 1.0 + eta_x[i], &dEta_bar1[0] + i, Qx,
153  &out_dxi3[0] + i, Qx, &out_dxi3[0] + i, Qx);
154  }
155  }
156 }
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:68
Nektar::NullNekDouble1DArray
static Array< OneD, NekDouble > NullNekDouble1DArray
Definition: SharedArray.hpp:900
Vmath::Svtvp
void Svtvp(int n, const T alpha, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
svtvp (scalar times vector plus vector): z = alpha*x + y
Definition: Vmath.cpp:622

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

Referenced by v_PhysDeriv(), and v_StdPhysDeriv().

◆ v_PhysDeriv() [2/2]

void Nektar::StdRegions::StdPrismExp::v_PhysDeriv ( const int  dir,
const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  out_d0 
)
overrideprotectedvirtual

Calculate the derivative of the physical points in a given direction.

See also
StdRegions::StdExpansion::PhysDeriv

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 158 of file StdPrismExp.cpp.

161 {
162  switch (dir)
163  {
164  case 0:
165  {
166  v_PhysDeriv(inarray, outarray, NullNekDouble1DArray,
167  NullNekDouble1DArray);
168  break;
169  }
170 
171  case 1:
172  {
173  v_PhysDeriv(inarray, NullNekDouble1DArray, outarray,
174  NullNekDouble1DArray);
175  break;
176  }
177 
178  case 2:
179  {
180  v_PhysDeriv(inarray, NullNekDouble1DArray, NullNekDouble1DArray,
181  outarray);
182  break;
183  }
184 
185  default:
186  {
187  ASSERTL1(false, "input dir is out of range");
188  }
189  break;
190  }
191 }
Nektar::StdRegions::StdPrismExp::v_PhysDeriv
void v_PhysDeriv(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_d0, Array< OneD, NekDouble > &out_d1, Array< OneD, NekDouble > &out_d2) override
Calculate the derivative of the physical points.
Definition: StdPrismExp.cpp:93

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

◆ v_PhysEvaluate()

NekDouble Nektar::StdRegions::StdPrismExp::v_PhysEvaluate ( const Array< OneD, NekDouble > &  coord,
const Array< OneD, const NekDouble > &  inarray,
std::array< NekDouble, 3 > &  firstOrderDerivs 
)
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion3D.

Reimplemented in Nektar::LocalRegions::PrismExp.

Definition at line 653 of file StdPrismExp.cpp.

657 {
658  // Collapse coordinates
659  Array<OneD, NekDouble> coll(3, 0.0);
660  LocCoordToLocCollapsed(coord, coll);
661 
662  // If near singularity do the old interpolation matrix method
663  if ((1 - coll[2]) < 1e-5)
664  {
665  int totPoints = GetTotPoints();
666  Array<OneD, NekDouble> EphysDeriv0(totPoints), EphysDeriv1(totPoints),
667  EphysDeriv2(totPoints);
668  PhysDeriv(inarray, EphysDeriv0, EphysDeriv1, EphysDeriv2);
669 
670  Array<OneD, DNekMatSharedPtr> I(3);
671  I[0] = GetBase()[0]->GetI(coll);
672  I[1] = GetBase()[1]->GetI(coll + 1);
673  I[2] = GetBase()[2]->GetI(coll + 2);
674 
675  firstOrderDerivs[0] = PhysEvaluate(I, EphysDeriv0);
676  firstOrderDerivs[1] = PhysEvaluate(I, EphysDeriv1);
677  firstOrderDerivs[2] = PhysEvaluate(I, EphysDeriv2);
678  return PhysEvaluate(I, inarray);
679  }
680 
681  NekDouble val = BaryTensorDeriv(coll, inarray, firstOrderDerivs);
682 
683  NekDouble dEta_bar1 = firstOrderDerivs[0];
684 
685  NekDouble fac = 2.0 / (1.0 - coll[2]);
686  firstOrderDerivs[0] = fac * dEta_bar1;
687 
688  // divide dEta_Bar1 by (1-eta_z)
689  fac = 1.0 / (1.0 - coll[2]);
690  dEta_bar1 = fac * dEta_bar1;
691 
692  // Multiply dEta_Bar1 by (1+eta_x) and add ot out_dxi3
693  fac = 1.0 + coll[0];
694  firstOrderDerivs[2] += fac * dEta_bar1;
695 
696  return val;
697 }
Nektar::StdRegions::StdExpansion3D::BaryTensorDeriv
NekDouble BaryTensorDeriv(const Array< OneD, NekDouble > &coord, const Array< OneD, const NekDouble > &inarray, std::array< NekDouble, 3 > &firstOrderDerivs)
Definition: StdExpansion3D.h:232
Nektar::StdRegions::StdExpansion::GetTotPoints
int GetTotPoints() const
This function returns the total number of quadrature points used in the element.
Definition: StdExpansion.h:140
Nektar::StdRegions::StdExpansion::GetBase
const Array< OneD, const LibUtilities::BasisSharedPtr > & GetBase() const
This function gets the shared point to basis.
Definition: StdExpansion.h:106
Nektar::StdRegions::StdExpansion::PhysEvaluate
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.
Definition: StdExpansion.h:918
Nektar::StdRegions::StdExpansion::PhysDeriv
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)
Definition: StdExpansion.h:848

References Nektar::StdRegions::StdExpansion3D::BaryTensorDeriv(), Nektar::StdRegions::StdExpansion::GetBase(), Nektar::StdRegions::StdExpansion::GetTotPoints(), Nektar::StdRegions::StdExpansion::LocCoordToLocCollapsed(), Nektar::StdRegions::StdExpansion::PhysDeriv(), and Nektar::StdRegions::StdExpansion::PhysEvaluate().

◆ v_PhysEvaluateBasis()

NekDouble Nektar::StdRegions::StdPrismExp::v_PhysEvaluateBasis ( const Array< OneD, const NekDouble > &  coords,
int  mode 
)
finaloverrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 706 of file StdPrismExp.cpp.

708 {
709  Array<OneD, NekDouble> coll(3);
710  LocCoordToLocCollapsed(coords, coll);
711 
712  const int nm1 = m_base[1]->GetNumModes();
713  const int nm2 = m_base[2]->GetNumModes();
714  const int b = 2 * nm2 + 1;
715 
716  const int mode0 = floor(0.5 * (b - sqrt(b * b - 8.0 * mode / nm1)));
717  const int tmp =
718  mode - nm1 * (mode0 * (nm2 - 1) + 1 - (mode0 - 2) * (mode0 - 1) / 2);
719  const int mode1 = tmp / (nm2 - mode0);
720  const int mode2 = tmp % (nm2 - mode0);
721 
722  if (mode0 == 0 && mode2 == 1 &&
723  m_base[0]->GetBasisType() == LibUtilities::eModified_A)
724  {
725  // handle collapsed top edge to remove mode0 terms
726  return StdExpansion::BaryEvaluateBasis<1>(coll[1], mode1) *
727  StdExpansion::BaryEvaluateBasis<2>(coll[2], mode2);
728  }
729  else
730  {
731  return StdExpansion::BaryEvaluateBasis<0>(coll[0], mode0) *
732  StdExpansion::BaryEvaluateBasis<1>(coll[1], mode1) *
733  StdExpansion::BaryEvaluateBasis<2>(coll[2], mode2);
734  }
735 }
tinysimd::sqrt
scalarT< T > sqrt(scalarT< T > in)
Definition: scalar.hpp:294

References Nektar::LibUtilities::eModified_A, Nektar::StdRegions::StdExpansion::GetBasisType(), Nektar::StdRegions::StdExpansion::LocCoordToLocCollapsed(), Nektar::StdRegions::StdExpansion::m_base, and tinysimd::sqrt().

◆ v_ReduceOrderCoeffs()

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 2154 of file StdPrismExp.cpp.

2157 {
2158  int nquad0 = m_base[0]->GetNumPoints();
2159  int nquad1 = m_base[1]->GetNumPoints();
2160  int nquad2 = m_base[2]->GetNumPoints();
2161  int nqtot = nquad0 * nquad1 * nquad2;
2162  int nmodes0 = m_base[0]->GetNumModes();
2163  int nmodes1 = m_base[1]->GetNumModes();
2164  int nmodes2 = m_base[2]->GetNumModes();
2165  int numMax = nmodes0;
2166 
2167  Array<OneD, NekDouble> coeff(m_ncoeffs);
2168  Array<OneD, NekDouble> coeff_tmp1(m_ncoeffs, 0.0);
2169  Array<OneD, NekDouble> phys_tmp(nqtot, 0.0);
2170  Array<OneD, NekDouble> tmp, tmp2, tmp3, tmp4;
2171 
2172  const LibUtilities::PointsKey Pkey0 = m_base[0]->GetPointsKey();
2173  const LibUtilities::PointsKey Pkey1 = m_base[1]->GetPointsKey();
2174  const LibUtilities::PointsKey Pkey2 = m_base[2]->GetPointsKey();
2175 
2176  LibUtilities::BasisKey bortho0(LibUtilities::eOrtho_A, nmodes0, Pkey0);
2177  LibUtilities::BasisKey bortho1(LibUtilities::eOrtho_A, nmodes1, Pkey1);
2178  LibUtilities::BasisKey bortho2(LibUtilities::eOrtho_B, nmodes2, Pkey2);
2179 
2180  int cnt = 0;
2181  int u = 0;
2182  int i = 0;
2183  StdRegions::StdPrismExpSharedPtr OrthoPrismExp;
2184 
2185  OrthoPrismExp = MemoryManager<StdRegions::StdPrismExp>::AllocateSharedPtr(
2186  bortho0, bortho1, bortho2);
2187 
2188  BwdTrans(inarray, phys_tmp);
2189  OrthoPrismExp->FwdTrans(phys_tmp, coeff);
2190 
2191  // filtering
2192  for (u = 0; u < numMin; ++u)
2193  {
2194  for (i = 0; i < numMin; ++i)
2195  {
2196  Vmath::Vcopy(numMin - u, tmp = coeff + cnt, 1,
2197  tmp2 = coeff_tmp1 + cnt, 1);
2198  cnt += numMax - u;
2199  }
2200 
2201  for (i = numMin; i < numMax; ++i)
2202  {
2203  cnt += numMax - u;
2204  }
2205  }
2206 
2207  OrthoPrismExp->BwdTrans(coeff_tmp1, phys_tmp);
2208  StdPrismExp::FwdTrans(phys_tmp, outarray);
2209 }
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:430
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:1791
Nektar::LibUtilities::eOrtho_A
@ eOrtho_A
Principle Orthogonal Functions .
Definition: BasisType.h:44
Nektar::StdRegions::StdPrismExpSharedPtr
std::shared_ptr< StdPrismExp > StdPrismExpSharedPtr
Definition: StdPrismExp.h:239

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

◆ v_StdPhysDeriv() [1/2]

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 193 of file StdPrismExp.cpp.

197 {
198  StdPrismExp::v_PhysDeriv(inarray, out_d0, out_d1, out_d2);
199 }

References v_PhysDeriv().

◆ v_StdPhysDeriv() [2/2]

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 201 of file StdPrismExp.cpp.

204 {
205  StdPrismExp::v_PhysDeriv(dir, inarray, outarray);
206 }

References v_PhysDeriv().

◆ v_SVVLaplacianFilter()

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::LocalRegions::PrismExp.

Definition at line 2016 of file StdPrismExp.cpp.

2018 {
2019  // Generate an orthonogal expansion
2020  int qa = m_base[0]->GetNumPoints();
2021  int qb = m_base[1]->GetNumPoints();
2022  int qc = m_base[2]->GetNumPoints();
2023  int nmodes_a = m_base[0]->GetNumModes();
2024  int nmodes_b = m_base[1]->GetNumModes();
2025  int nmodes_c = m_base[2]->GetNumModes();
2026  // Declare orthogonal basis.
2027  LibUtilities::PointsKey pa(qa, m_base[0]->GetPointsType());
2028  LibUtilities::PointsKey pb(qb, m_base[1]->GetPointsType());
2029  LibUtilities::PointsKey pc(qc, m_base[2]->GetPointsType());
2030 
2031  LibUtilities::BasisKey Ba(LibUtilities::eOrtho_A, nmodes_a, pa);
2032  LibUtilities::BasisKey Bb(LibUtilities::eOrtho_A, nmodes_b, pb);
2033  LibUtilities::BasisKey Bc(LibUtilities::eOrtho_B, nmodes_c, pc);
2034  StdPrismExp OrthoExp(Ba, Bb, Bc);
2035 
2036  Array<OneD, NekDouble> orthocoeffs(OrthoExp.GetNcoeffs());
2037  int i, j, k, cnt = 0;
2038 
2039  // project onto modal space.
2040  OrthoExp.FwdTrans(array, orthocoeffs);
2041 
2042  if (mkey.ConstFactorExists(eFactorSVVPowerKerDiffCoeff))
2043  {
2044  // Rodrigo's power kernel
2045  NekDouble cutoff = mkey.GetConstFactor(eFactorSVVCutoffRatio);
2046  NekDouble SvvDiffCoeff =
2047  mkey.GetConstFactor(eFactorSVVPowerKerDiffCoeff) *
2048  mkey.GetConstFactor(eFactorSVVDiffCoeff);
2049 
2050  for (int i = 0; i < nmodes_a; ++i)
2051  {
2052  for (int j = 0; j < nmodes_b; ++j)
2053  {
2054  NekDouble fac1 = std::max(
2055  pow((1.0 * i) / (nmodes_a - 1), cutoff * nmodes_a),
2056  pow((1.0 * j) / (nmodes_b - 1), cutoff * nmodes_b));
2057 
2058  for (int k = 0; k < nmodes_c - i; ++k)
2059  {
2060  NekDouble fac =
2061  std::max(fac1, pow((1.0 * k) / (nmodes_c - 1),
2062  cutoff * nmodes_c));
2063 
2064  orthocoeffs[cnt] *= SvvDiffCoeff * fac;
2065  cnt++;
2066  }
2067  }
2068  }
2069  }
2070  else if (mkey.ConstFactorExists(
2071  eFactorSVVDGKerDiffCoeff)) // Rodrigo/Mansoor's DG Kernel
2072  {
2073  NekDouble SvvDiffCoeff = mkey.GetConstFactor(eFactorSVVDGKerDiffCoeff) *
2074  mkey.GetConstFactor(eFactorSVVDiffCoeff);
2075 
2076  int max_abc = max(nmodes_a - kSVVDGFiltermodesmin,
2077  nmodes_b - kSVVDGFiltermodesmin);
2078  max_abc = max(max_abc, nmodes_c - kSVVDGFiltermodesmin);
2079  // clamp max_abc
2080  max_abc = max(max_abc, 0);
2081  max_abc = min(max_abc, kSVVDGFiltermodesmax - kSVVDGFiltermodesmin);
2082 
2083  for (int i = 0; i < nmodes_a; ++i)
2084  {
2085  for (int j = 0; j < nmodes_b; ++j)
2086  {
2087  int maxij = max(i, j);
2088 
2089  for (int k = 0; k < nmodes_c - i; ++k)
2090  {
2091  int maxijk = max(maxij, k);
2092  maxijk = min(maxijk, kSVVDGFiltermodesmax - 1);
2093 
2094  orthocoeffs[cnt] *=
2095  SvvDiffCoeff * kSVVDGFilter[max_abc][maxijk];
2096  cnt++;
2097  }
2098  }
2099  }
2100  }
2101  else
2102  {
2103  // SVV filter paramaters (how much added diffusion relative
2104  // to physical one and fraction of modes from which you
2105  // start applying this added diffusion)
2106  //
2107  NekDouble SvvDiffCoeff =
2108  mkey.GetConstFactor(StdRegions::eFactorSVVDiffCoeff);
2109  NekDouble SVVCutOff =
2110  mkey.GetConstFactor(StdRegions::eFactorSVVCutoffRatio);
2111 
2112  // Defining the cut of mode
2113  int cutoff_a = (int)(SVVCutOff * nmodes_a);
2114  int cutoff_b = (int)(SVVCutOff * nmodes_b);
2115  int cutoff_c = (int)(SVVCutOff * nmodes_c);
2116  // To avoid the fac[j] from blowing up
2117  NekDouble epsilon = 1;
2118 
2119  int nmodes = min(min(nmodes_a, nmodes_b), nmodes_c);
2120  NekDouble cutoff = min(min(cutoff_a, cutoff_b), cutoff_c);
2121 
2122  //------"New" Version August 22nd '13--------------------
2123  for (i = 0; i < nmodes_a; ++i) // P
2124  {
2125  for (j = 0; j < nmodes_b; ++j) // Q
2126  {
2127  for (k = 0; k < nmodes_c - i; ++k) // R
2128  {
2129  if (j >= cutoff || i + k >= cutoff)
2130  {
2131  orthocoeffs[cnt] *=
2132  (SvvDiffCoeff *
2133  exp(-(i + k - nmodes) * (i + k - nmodes) /
2134  ((NekDouble)((i + k - cutoff + epsilon) *
2135  (i + k - cutoff + epsilon)))) *
2136  exp(-(j - nmodes) * (j - nmodes) /
2137  ((NekDouble)((j - cutoff + epsilon) *
2138  (j - cutoff + epsilon)))));
2139  }
2140  else
2141  {
2142  orthocoeffs[cnt] *= 0.0;
2143  }
2144  cnt++;
2145  }
2146  }
2147  }
2148  }
2149 
2150  // backward transform to physical space
2151  OrthoExp.BwdTrans(orthocoeffs, array);
2152 }
Nektar::StdRegions::kSVVDGFiltermodesmin
const int kSVVDGFiltermodesmin
Definition: StdRegions.hpp:469
Nektar::StdRegions::kSVVDGFiltermodesmax
const int kSVVDGFiltermodesmax
Definition: StdRegions.hpp:470
Nektar::StdRegions::kSVVDGFilter
const NekDouble kSVVDGFilter[9][11]
Definition: StdRegions.hpp:472

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::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.

Generated on Sat Mar 25 2023 12:36:01 for Nektar++ by doxygen 1.9.1