Nektar++
Public Member Functions | Protected Member Functions | Private Member Functions | Private Attributes | List of all members
Nektar::LocalRegions::PrismExp Class Reference

#include <PrismExp.h>

Inheritance diagram for Nektar::LocalRegions::PrismExp:
[legend]

Public Member Functions

 PrismExp (const LibUtilities::BasisKey &Ba, const LibUtilities::BasisKey &Bb, const LibUtilities::BasisKey &Bc, const SpatialDomains::PrismGeomSharedPtr &geom)
 Constructor using BasisKey class for quadrature points and order definition. More...
 
 PrismExp (const PrismExp &T)
 
virtual ~PrismExp () override=default
 
- Public Member Functions inherited from Nektar::StdRegions::StdPrismExp
 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 LinearAdvectionMatrixOp (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 int v_CalcNumberOfCoefficients (const std::vector< unsigned int > &nummodes, int &modes_offset)
 
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)
 
- Public Member Functions inherited from Nektar::LocalRegions::Expansion3D
 Expansion3D (SpatialDomains::Geometry3DSharedPtr pGeom)
 
virtual ~Expansion3D () override=default
 
void SetTraceToGeomOrientation (Array< OneD, NekDouble > &inout)
 Align trace orientation with the geometry orientation. More...
 
void SetFaceToGeomOrientation (const int face, Array< OneD, NekDouble > &inout)
 Align face orientation with the geometry orientation. More...
 
void AddHDGHelmholtzFaceTerms (const NekDouble tau, const int edge, Array< OneD, NekDouble > &facePhys, const StdRegions::VarCoeffMap &dirForcing, Array< OneD, NekDouble > &outarray)
 
void AddNormTraceInt (const int dir, Array< OneD, ExpansionSharedPtr > &FaceExp, Array< OneD, Array< OneD, NekDouble > > &faceCoeffs, Array< OneD, NekDouble > &outarray)
 
void AddNormTraceInt (const int dir, Array< OneD, const NekDouble > &inarray, Array< OneD, ExpansionSharedPtr > &FaceExp, Array< OneD, NekDouble > &outarray, const StdRegions::VarCoeffMap &varcoeffs)
 
void AddFaceBoundaryInt (const int face, ExpansionSharedPtr &FaceExp, Array< OneD, NekDouble > &facePhys, Array< OneD, NekDouble > &outarray, const StdRegions::VarCoeffMap &varcoeffs=StdRegions::NullVarCoeffMap)
 
SpatialDomains::Geometry3DSharedPtr GetGeom3D () const
 
void v_ReOrientTracePhysMap (const StdRegions::Orientation orient, Array< OneD, int > &idmap, const int nq0, const int nq1) override
 
void v_NormVectorIProductWRTBase (const Array< OneD, const Array< OneD, NekDouble > > &Fvec, Array< OneD, NekDouble > &outarray) override
 
Array< OneD, unsigned int > GetEdgeInverseBoundaryMap (int eid)
 
Array< OneD, unsigned int > GetTraceInverseBoundaryMap (int fid, StdRegions::Orientation faceOrient=StdRegions::eNoOrientation, int P1=-1, int P2=-1)
 
void GetInverseBoundaryMaps (Array< OneD, unsigned int > &vmap, Array< OneD, Array< OneD, unsigned int > > &emap, Array< OneD, Array< OneD, unsigned int > > &fmap)
 
DNekScalMatSharedPtr CreateMatrix (const MatrixKey &mkey)
 
- Public Member Functions inherited from Nektar::LocalRegions::Expansion
 Expansion (SpatialDomains::GeometrySharedPtr pGeom)
 
 Expansion (const Expansion &pSrc)
 
virtual ~Expansion ()
 
void SetTraceExp (const int traceid, ExpansionSharedPtr &f)
 
ExpansionSharedPtr GetTraceExp (const int traceid)
 
DNekScalMatSharedPtr GetLocMatrix (const LocalRegions::MatrixKey &mkey)
 
void DropLocMatrix (const LocalRegions::MatrixKey &mkey)
 
DNekScalMatSharedPtr GetLocMatrix (const StdRegions::MatrixType mtype, const StdRegions::ConstFactorMap &factors=StdRegions::NullConstFactorMap, const StdRegions::VarCoeffMap &varcoeffs=StdRegions::NullVarCoeffMap)
 
SpatialDomains::GeometrySharedPtr GetGeom () const
 
void Reset ()
 
IndexMapValuesSharedPtr CreateIndexMap (const IndexMapKey &ikey)
 
DNekScalBlkMatSharedPtr CreateStaticCondMatrix (const MatrixKey &mkey)
 
const SpatialDomains::GeomFactorsSharedPtr & GetMetricInfo () const
 
DNekMatSharedPtr BuildTransformationMatrix (const DNekScalMatSharedPtr &r_bnd, const StdRegions::MatrixType matrixType)
 
DNekMatSharedPtr BuildVertexMatrix (const DNekScalMatSharedPtr &r_bnd)
 
void ExtractDataToCoeffs (const NekDouble *data, const std::vector< unsigned int > &nummodes, const int nmodes_offset, NekDouble *coeffs, std::vector< LibUtilities::BasisType > &fromType)
 
void AddEdgeNormBoundaryInt (const int edge, const std::shared_ptr< Expansion > &EdgeExp, const Array< OneD, const NekDouble > &Fx, const Array< OneD, const NekDouble > &Fy, Array< OneD, NekDouble > &outarray)
 
void AddEdgeNormBoundaryInt (const int edge, const std::shared_ptr< Expansion > &EdgeExp, const Array< OneD, const NekDouble > &Fn, Array< OneD, NekDouble > &outarray)
 
void AddFaceNormBoundaryInt (const int face, const std::shared_ptr< Expansion > &FaceExp, const Array< OneD, const NekDouble > &Fn, Array< OneD, NekDouble > &outarray)
 
void DGDeriv (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, ExpansionSharedPtr > &EdgeExp, Array< OneD, Array< OneD, NekDouble > > &coeffs, Array< OneD, NekDouble > &outarray)
 
NekDouble VectorFlux (const Array< OneD, Array< OneD, NekDouble > > &vec)
 
void NormalTraceDerivFactors (Array< OneD, Array< OneD, NekDouble > > &factors, Array< OneD, Array< OneD, NekDouble > > &d0factors, Array< OneD, Array< OneD, NekDouble > > &d1factors)
 
IndexMapValuesSharedPtr GetIndexMap (const IndexMapKey &ikey)
 
void AlignVectorToCollapsedDir (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)
 
ExpansionSharedPtr GetLeftAdjacentElementExp () const
 
ExpansionSharedPtr GetRightAdjacentElementExp () const
 
int GetLeftAdjacentElementTrace () const
 
int GetRightAdjacentElementTrace () const
 
void SetAdjacentElementExp (int traceid, ExpansionSharedPtr &e)
 
StdRegions::Orientation GetTraceOrient (int trace)
 
void SetCoeffsToOrientation (StdRegions::Orientation dir, Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
void DivideByQuadratureMetric (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 Divided by the metric jacobi and quadrature weights. More...
 
void GetTraceQFactors (const int trace, Array< OneD, NekDouble > &outarray)
 Extract the metric factors to compute the contravariant fluxes along edge edge and stores them into outarray following the local edge orientation (i.e. anticlockwise convention). More...
 
void GetTracePhysVals (const int trace, const StdRegions::StdExpansionSharedPtr &TraceExp, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, StdRegions::Orientation orient=StdRegions::eNoOrientation)
 
void GetTracePhysMap (const int edge, Array< OneD, int > &outarray)
 
void ReOrientTracePhysMap (const StdRegions::Orientation orient, Array< OneD, int > &idmap, const int nq0, const int nq1)
 
const NormalVector & GetTraceNormal (const int id)
 
void ComputeTraceNormal (const int id)
 
const Array< OneD, const NekDouble > & GetPhysNormals (void)
 
void SetPhysNormals (Array< OneD, const NekDouble > &normal)
 
void SetUpPhysNormals (const int trace)
 
void AddRobinMassMatrix (const int traceid, const Array< OneD, const NekDouble > &primCoeffs, DNekMatSharedPtr &inoutmat)
 
void TraceNormLen (const int traceid, NekDouble &h, NekDouble &p)
 
void AddRobinTraceContribution (const int traceid, const Array< OneD, const NekDouble > &primCoeffs, const Array< OneD, NekDouble > &incoeffs, Array< OneD, NekDouble > &coeffs)
 
const Array< OneD, const NekDouble > & GetElmtBndNormDirElmtLen (const int nbnd) const
 
void StdDerivBaseOnTraceMat (Array< OneD, DNekMatSharedPtr > &DerivMat)
 

Protected Member Functions

virtual NekDouble v_Integral (const Array< OneD, const NekDouble > &inarray) override
 Integrate the physical point list inarray over prismatic region and return the value. More...
 
virtual 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_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 (this)->m_coeffs. More...
 
virtual 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
 
void v_IProductWRTDerivBase (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) override
 Calculates the inner product \( I_{pqr} = (u, \partial_{x_i} \phi_{pqr}) \). More...
 
void v_IProductWRTDerivBase_SumFac (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) override
 
virtual void v_AlignVectorToCollapsedDir (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray) override
 
virtual void v_GetCoord (const Array< OneD, const NekDouble > &Lcoords, Array< OneD, NekDouble > &coords) override
 Get the coordinates #coords at the local coordinates #Lcoords. More...
 
virtual void v_GetCoords (Array< OneD, NekDouble > &coords_1, Array< OneD, NekDouble > &coords_2, Array< OneD, NekDouble > &coords_3) override
 
virtual NekDouble v_StdPhysEvaluate (const Array< OneD, const NekDouble > &Lcoord, const Array< OneD, const NekDouble > &physvals) override
 
virtual NekDouble v_PhysEvaluate (const Array< OneD, const NekDouble > &coord, 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, NekDouble > &coord, const Array< OneD, const NekDouble > &inarray, std::array< NekDouble, 3 > &firstOrderDerivs) override
 
virtual StdRegions::StdExpansionSharedPtr v_GetStdExp (void) const override
 
virtual StdRegions::StdExpansionSharedPtr v_GetLinStdExp (void) const override
 
virtual void v_ExtractDataToCoeffs (const NekDouble *data, const std::vector< unsigned int > &nummodes, const int mode_offset, NekDouble *coeffs, std::vector< LibUtilities::BasisType > &fromType) override
 
virtual void v_GetTracePhysMap (const int face, Array< OneD, int > &outarray) override
 
void v_ComputeTraceNormal (const int face) override
 Get the normals along specficied face Get the face normals interplated to a points0 x points 0 type distribution. More...
 
virtual void v_MassMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey) override
 
virtual void v_LaplacianMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey) override
 
virtual void v_LaplacianMatrixOp (const int k1, const int k2, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey) override
 
virtual void v_HelmholtzMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey) override
 
virtual void v_SVVLaplacianFilter (Array< OneD, NekDouble > &array, const StdRegions::StdMatrixKey &mkey) override
 
virtual DNekMatSharedPtr v_GenMatrix (const StdRegions::StdMatrixKey &mkey) override
 
virtual DNekMatSharedPtr v_CreateStdMatrix (const StdRegions::StdMatrixKey &mkey) override
 
virtual DNekScalMatSharedPtr v_GetLocMatrix (const MatrixKey &mkey) override
 
virtual DNekScalBlkMatSharedPtr v_GetLocStaticCondMatrix (const MatrixKey &mkey) override
 
void v_DropLocMatrix (const MatrixKey &mkey) override
 
void v_DropLocStaticCondMatrix (const MatrixKey &mkey) override
 
virtual void v_GetSimplexEquiSpacedConnectivity (Array< OneD, int > &conn, bool standard=true) override
 
virtual void v_NormalTraceDerivFactors (Array< OneD, Array< OneD, NekDouble > > &d0factors, Array< OneD, Array< OneD, NekDouble > > &d1factors, Array< OneD, Array< OneD, NekDouble > > &d2factors) override
 : This method gets all of the factors which are required as part of the Gradient Jump Penalty stabilisation and involves the product of the normal and geometric factors along the element trace. More...
 
- Protected Member Functions inherited from Nektar::StdRegions::StdPrismExp
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 NekDouble v_PhysEvaluate (const Array< OneD, NekDouble > &coord, const Array< OneD, const NekDouble > &inarray, std::array< NekDouble, 3 > &firstOrderDerivs) 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)=0
 
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)=0
 
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...
 
virtual int v_GetNedges (void) const
 
virtual int v_GetEdgeNcoeffs (const int i) const
 
NekDouble BaryTensorDeriv (const Array< OneD, NekDouble > &coord, const Array< OneD, const NekDouble > &inarray, std::array< NekDouble, 3 > &firstOrderDerivs)
 
virtual void v_GetEdgeInteriorToElementMap (const int tid, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray, Orientation traceOrient=eForwards)
 
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 LinearAdvectionMatrixOp_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)
 
virtual void v_GenStdMatBwdDeriv (const int dir, DNekMatSharedPtr &mat)
 
virtual void v_MultiplyByStdQuadratureMetric (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
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)
 
- Protected Member Functions inherited from Nektar::LocalRegions::Expansion3D
virtual void v_DGDeriv (const int dir, const Array< OneD, const NekDouble > &incoeffs, Array< OneD, ExpansionSharedPtr > &FaceExp, Array< OneD, Array< OneD, NekDouble > > &faceCoeffs, Array< OneD, NekDouble > &out_d) override
 Evaluate coefficients of weak deriviative in the direction dir given the input coefficicents incoeffs and the imposed boundary values in EdgeExp (which will have its phys space updated). More...
 
virtual DNekMatSharedPtr v_GenMatrix (const StdRegions::StdMatrixKey &mkey) override
 
virtual void v_AddFaceNormBoundaryInt (const int face, const ExpansionSharedPtr &FaceExp, const Array< OneD, const NekDouble > &Fn, Array< OneD, NekDouble > &outarray) override
 
virtual void v_AddRobinMassMatrix (const int face, const Array< OneD, const NekDouble > &primCoeffs, DNekMatSharedPtr &inoutmat) override
 
virtual StdRegions::Orientation v_GetTraceOrient (int face) override
 
virtual void v_GetTracePhysVals (const int face, const StdRegions::StdExpansionSharedPtr &FaceExp, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, StdRegions::Orientation orient) override
 Extract the physical values along face face from inarray into outarray following the local face orientation and point distribution defined by defined in FaceExp. More...
 
virtual void v_GenTraceExp (const int traceid, ExpansionSharedPtr &exp) override
 
void GetPhysFaceVarCoeffsFromElement (const int face, ExpansionSharedPtr &FaceExp, const Array< OneD, const NekDouble > &varcoeff, Array< OneD, NekDouble > &outarray)
 
virtual DNekMatSharedPtr v_BuildTransformationMatrix (const DNekScalMatSharedPtr &r_bnd, const StdRegions::MatrixType matrixType) override
 
virtual DNekMatSharedPtr v_BuildInverseTransformationMatrix (const DNekScalMatSharedPtr &transformationmatrix) override
 Build inverse and inverse transposed transformation matrix: \(\mathbf{R^{-1}}\) and \(\mathbf{R^{-T}}\). More...
 
virtual DNekMatSharedPtr v_BuildVertexMatrix (const DNekScalMatSharedPtr &r_bnd) override
 
virtual void v_TraceNormLen (const int traceid, NekDouble &h, NekDouble &p) override
 
- Protected Member Functions inherited from Nektar::LocalRegions::Expansion
void ComputeLaplacianMetric ()
 
void ComputeQuadratureMetric ()
 
void ComputeGmatcdotMF (const Array< TwoD, const NekDouble > &df, const Array< OneD, const NekDouble > &direction, Array< OneD, Array< OneD, NekDouble > > &dfdir)
 
Array< OneD, NekDouble > GetMF (const int dir, const int shapedim, const StdRegions::VarCoeffMap &varcoeffs)
 
Array< OneD, NekDouble > GetMFDiv (const int dir, const StdRegions::VarCoeffMap &varcoeffs)
 
Array< OneD, NekDouble > GetMFMag (const int dir, const StdRegions::VarCoeffMap &varcoeffs)
 
virtual void v_MultiplyByQuadratureMetric (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) override
 
virtual void v_DivideByQuadratureMetric (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
virtual void v_ComputeLaplacianMetric ()
 
virtual int v_GetCoordim () const override
 
virtual void v_GetCoords (Array< OneD, NekDouble > &coords_1, Array< OneD, NekDouble > &coords_2, Array< OneD, NekDouble > &coords_3) override
 
virtual DNekScalMatSharedPtr v_GetLocMatrix (const LocalRegions::MatrixKey &mkey)
 
virtual void v_DropLocMatrix (const LocalRegions::MatrixKey &mkey)
 
virtual DNekMatSharedPtr v_BuildTransformationMatrix (const DNekScalMatSharedPtr &r_bnd, const StdRegions::MatrixType matrixType)
 
virtual DNekMatSharedPtr v_BuildVertexMatrix (const DNekScalMatSharedPtr &r_bnd)
 
virtual void v_ExtractDataToCoeffs (const NekDouble *data, const std::vector< unsigned int > &nummodes, const int nmodes_offset, NekDouble *coeffs, std::vector< LibUtilities::BasisType > &fromType)
 
virtual void v_AddEdgeNormBoundaryInt (const int edge, const std::shared_ptr< Expansion > &EdgeExp, const Array< OneD, const NekDouble > &Fx, const Array< OneD, const NekDouble > &Fy, Array< OneD, NekDouble > &outarray)
 
virtual void v_AddEdgeNormBoundaryInt (const int edge, const std::shared_ptr< Expansion > &EdgeExp, const Array< OneD, const NekDouble > &Fn, Array< OneD, NekDouble > &outarray)
 
virtual void v_AddFaceNormBoundaryInt (const int face, const std::shared_ptr< Expansion > &FaceExp, const Array< OneD, const NekDouble > &Fn, Array< OneD, NekDouble > &outarray)
 
virtual void v_DGDeriv (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, ExpansionSharedPtr > &EdgeExp, Array< OneD, Array< OneD, NekDouble > > &coeffs, Array< OneD, NekDouble > &outarray)
 
virtual NekDouble v_VectorFlux (const Array< OneD, Array< OneD, NekDouble > > &vec)
 
virtual void v_NormalTraceDerivFactors (Array< OneD, Array< OneD, NekDouble > > &factors, Array< OneD, Array< OneD, NekDouble > > &d0factors, Array< OneD, Array< OneD, NekDouble > > &d1factors)
 
virtual void v_AlignVectorToCollapsedDir (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)
 
virtual StdRegions::Orientation v_GetTraceOrient (int trace)
 
virtual void v_SetCoeffsToOrientation (StdRegions::Orientation dir, Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) override
 
virtual void v_GetTraceQFactors (const int trace, Array< OneD, NekDouble > &outarray)
 
virtual void v_GetTracePhysVals (const int trace, const StdRegions::StdExpansionSharedPtr &TraceExp, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, StdRegions::Orientation orient)
 
virtual void v_GetTracePhysMap (const int edge, Array< OneD, int > &outarray)
 
virtual void v_ReOrientTracePhysMap (const StdRegions::Orientation orient, Array< OneD, int > &idmap, const int nq0, const int nq1=-1)
 
virtual void v_ComputeTraceNormal (const int id)
 
virtual const Array< OneD, const NekDouble > & v_GetPhysNormals ()
 
virtual void v_SetPhysNormals (Array< OneD, const NekDouble > &normal)
 
virtual void v_SetUpPhysNormals (const int id)
 
virtual void v_AddRobinMassMatrix (const int face, const Array< OneD, const NekDouble > &primCoeffs, DNekMatSharedPtr &inoutmat)
 
virtual void v_AddRobinTraceContribution (const int traceid, const Array< OneD, const NekDouble > &primCoeffs, const Array< OneD, NekDouble > &incoeffs, Array< OneD, NekDouble > &coeffs)
 
virtual void v_TraceNormLen (const int traceid, NekDouble &h, NekDouble &p)
 
virtual void v_GenTraceExp (const int traceid, ExpansionSharedPtr &exp)
 

Private Member Functions

virtual void v_LaplacianMatrixOp_MatFree_Kernel (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, Array< OneD, NekDouble > &wsp) override
 Calculate the Laplacian multiplication in a matrix-free manner. More...
 

Private Attributes

LibUtilities::NekManager< MatrixKey, DNekScalMat, MatrixKey::opLess > m_matrixManager
 
LibUtilities::NekManager< MatrixKey, DNekScalBlkMat, MatrixKey::opLess > m_staticCondMatrixManager
 

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
 
- Protected Attributes inherited from Nektar::LocalRegions::Expansion3D
std::map< int, NormalVector > m_faceNormals
 
- Protected Attributes inherited from Nektar::LocalRegions::Expansion
LibUtilities::NekManager< IndexMapKey, IndexMapValues, IndexMapKey::opLess > m_indexMapManager
 
std::map< int, ExpansionWeakPtr > m_traceExp
 
SpatialDomains::GeometrySharedPtr m_geom
 
SpatialDomains::GeomFactorsSharedPtr m_metricinfo
 
MetricMap m_metrics
 
std::map< int, NormalVector > m_traceNormals
 
ExpansionWeakPtr m_elementLeft
 
ExpansionWeakPtr m_elementRight
 
int m_elementTraceLeft = -1
 
int m_elementTraceRight = -1
 
std::map< int, Array< OneD, NekDouble > > m_elmtBndNormDirElmtLen
 the element length in each element boundary(Vertex, edge or face) normal direction calculated based on the local m_metricinfo times the standard element length (which is 2.0) More...
 

Detailed Description

Definition at line 49 of file PrismExp.h.

Constructor & Destructor Documentation

◆ PrismExp() [1/2]

Nektar::LocalRegions::PrismExp::PrismExp ( const LibUtilities::BasisKey &  Ba,
const LibUtilities::BasisKey &  Bb,
const LibUtilities::BasisKey &  Bc,
const SpatialDomains::PrismGeomSharedPtr &  geom 
)

Constructor using BasisKey class for quadrature points and order definition.

Definition at line 49 of file PrismExp.cpp.

53 : StdExpansion(LibUtilities::StdPrismData::getNumberOfCoefficients(
54 Ba.GetNumModes(), Bb.GetNumModes(), Bc.GetNumModes()),
55 3, Ba, Bb, Bc),
56 StdExpansion3D(LibUtilities::StdPrismData::getNumberOfCoefficients(
57 Ba.GetNumModes(), Bb.GetNumModes(), Bc.GetNumModes()),
58 Ba, Bb, Bc),
59 StdPrismExp(Ba, Bb, Bc), Expansion(geom), Expansion3D(geom),
60 m_matrixManager(
61 std::bind(&Expansion3D::CreateMatrix, this, std::placeholders::_1),
62 std::string("PrismExpMatrix")),
63 m_staticCondMatrixManager(std::bind(&Expansion::CreateStaticCondMatrix,
64 this, std::placeholders::_1),
65 std::string("PrismExpStaticCondMatrix"))
66{
67}
Nektar::LocalRegions::Expansion3D::Expansion3D
Expansion3D(SpatialDomains::Geometry3DSharedPtr pGeom)
Definition: Expansion3D.h:61
Nektar::LocalRegions::Expansion3D::CreateMatrix
DNekScalMatSharedPtr CreateMatrix(const MatrixKey &mkey)
Definition: Expansion3D.cpp:426
Nektar::LocalRegions::Expansion::CreateStaticCondMatrix
DNekScalBlkMatSharedPtr CreateStaticCondMatrix(const MatrixKey &mkey)
Definition: Expansion.cpp:277
Nektar::LocalRegions::Expansion::Expansion
Expansion(SpatialDomains::GeometrySharedPtr pGeom)
Definition: Expansion.cpp:47
Nektar::LocalRegions::PrismExp::m_staticCondMatrixManager
LibUtilities::NekManager< MatrixKey, DNekScalBlkMat, MatrixKey::opLess > m_staticCondMatrixManager
Definition: PrismExp.h:202
Nektar::LocalRegions::PrismExp::m_matrixManager
LibUtilities::NekManager< MatrixKey, DNekScalMat, MatrixKey::opLess > m_matrixManager
Definition: PrismExp.h:200
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

◆ PrismExp() [2/2]

Nektar::LocalRegions::PrismExp::PrismExp ( const PrismExp &  T)

Definition at line 69 of file PrismExp.cpp.

70 : StdExpansion(T), StdExpansion3D(T), StdPrismExp(T), Expansion(T),
71 Expansion3D(T), m_matrixManager(T.m_matrixManager),
72 m_staticCondMatrixManager(T.m_staticCondMatrixManager)
73{
74}

◆ ~PrismExp()

virtual Nektar::LocalRegions::PrismExp::~PrismExp ( )
overridevirtualdefault

Member Function Documentation

◆ v_AlignVectorToCollapsedDir()

void Nektar::LocalRegions::PrismExp::v_AlignVectorToCollapsedDir ( const int  dir,
const Array< OneD, const NekDouble > &  inarray,
Array< OneD, Array< OneD, NekDouble > > &  outarray 
)
overrideprotectedvirtual

Reimplemented from Nektar::LocalRegions::Expansion.

Definition at line 382 of file PrismExp.cpp.

385{
386 const int nquad0 = m_base[0]->GetNumPoints();
387 const int nquad1 = m_base[1]->GetNumPoints();
388 const int nquad2 = m_base[2]->GetNumPoints();
389 const int order0 = m_base[0]->GetNumModes();
390 const int order1 = m_base[1]->GetNumModes();
391 const int nqtot = nquad0 * nquad1 * nquad2;
392
393 const Array<OneD, const NekDouble> &z0 = m_base[0]->GetZ();
394 const Array<OneD, const NekDouble> &z2 = m_base[2]->GetZ();
395
396 Array<OneD, NekDouble> gfac0(nquad0);
397 Array<OneD, NekDouble> gfac2(nquad2);
398 Array<OneD, NekDouble> tmp1(nqtot);
399 Array<OneD, NekDouble> tmp5(nqtot);
400 Array<OneD, NekDouble> tmp6(m_ncoeffs);
401 Array<OneD, NekDouble> wsp(order0 * nquad2 * (nquad1 + order1));
402
403 Array<OneD, NekDouble> tmp2 = outarray[0];
404 Array<OneD, NekDouble> tmp3 = outarray[1];
405 Array<OneD, NekDouble> tmp4 = outarray[2];
406
407 const Array<TwoD, const NekDouble> &df =
408 m_metricinfo->GetDerivFactors(GetPointsKeys());
409
410 Vmath::Vcopy(nqtot, inarray, 1, tmp1, 1); // Dir3 metric
411
412 if (m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
413 {
414 Vmath::Vmul(nqtot, &df[3 * dir][0], 1, tmp1.get(), 1, tmp2.get(), 1);
415 Vmath::Vmul(nqtot, &df[3 * dir + 1][0], 1, tmp1.get(), 1, tmp3.get(),
416 1);
417 Vmath::Vmul(nqtot, &df[3 * dir + 2][0], 1, tmp1.get(), 1, tmp4.get(),
418 1);
419 }
420 else
421 {
422 Vmath::Smul(nqtot, df[3 * dir][0], tmp1.get(), 1, tmp2.get(), 1);
423 Vmath::Smul(nqtot, df[3 * dir + 1][0], tmp1.get(), 1, tmp3.get(), 1);
424 Vmath::Smul(nqtot, df[3 * dir + 2][0], tmp1.get(), 1, tmp4.get(), 1);
425 }
426
427 // set up geometric factor: (1+z0)/2
428 for (int i = 0; i < nquad0; ++i)
429 {
430 gfac0[i] = 0.5 * (1 + z0[i]);
431 }
432
433 // Set up geometric factor: 2/(1-z2)
434 for (int i = 0; i < nquad2; ++i)
435 {
436 gfac2[i] = 2.0 / (1 - z2[i]);
437 }
438
439 const int nq01 = nquad0 * nquad1;
440
441 for (int i = 0; i < nquad2; ++i)
442 {
443 Vmath::Smul(nq01, gfac2[i], &tmp2[0] + i * nq01, 1, &tmp2[0] + i * nq01,
444 1);
445 Vmath::Smul(nq01, gfac2[i], &tmp4[0] + i * nq01, 1, &tmp5[0] + i * nq01,
446 1);
447 }
448
449 for (int i = 0; i < nquad1 * nquad2; ++i)
450 {
451 Vmath::Vmul(nquad0, &gfac0[0], 1, &tmp5[0] + i * nquad0, 1,
452 &tmp5[0] + i * nquad0, 1);
453 }
454
455 Vmath::Vadd(nqtot, &tmp2[0], 1, &tmp5[0], 1, &tmp2[0], 1);
456}
Nektar::LocalRegions::Expansion::m_metricinfo
SpatialDomains::GeomFactorsSharedPtr m_metricinfo
Definition: Expansion.h:276
Nektar::StdRegions::StdExpansion::GetPointsKeys
const LibUtilities::PointsKeyVector GetPointsKeys() const
Definition: StdExpansion.h:1101
Nektar::StdRegions::StdExpansion::m_base
Array< OneD, LibUtilities::BasisSharedPtr > m_base
Definition: StdExpansion.h:1179
Nektar::SpatialDomains::eDeformed
@ eDeformed
Geometry is curved or has non-constant factors.
Definition: SpatialDomains.hpp:56
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:207
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:354
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:245
Vmath::Vcopy
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1191

References Nektar::SpatialDomains::eDeformed, Nektar::StdRegions::StdExpansion::GetPointsKeys(), Nektar::StdRegions::StdExpansion::m_base, Nektar::LocalRegions::Expansion::m_metricinfo, Nektar::StdRegions::StdExpansion::m_ncoeffs, Vmath::Smul(), Vmath::Vadd(), Vmath::Vcopy(), and Vmath::Vmul().

Referenced by v_IProductWRTDerivBase_SumFac().

◆ v_ComputeTraceNormal()

void Nektar::LocalRegions::PrismExp::v_ComputeTraceNormal ( const int  face)
overrideprotectedvirtual

Get the normals along specficied face Get the face normals interplated to a points0 x points 0 type distribution.

Reimplemented from Nektar::LocalRegions::Expansion.

Definition at line 709 of file PrismExp.cpp.

710{
711 const SpatialDomains::GeomFactorsSharedPtr &geomFactors =
712 GetGeom()->GetMetricInfo();
713
714 LibUtilities::PointsKeyVector ptsKeys = GetPointsKeys();
715 for (int i = 0; i < ptsKeys.size(); ++i)
716 {
717 // Need at least 2 points for computing normals
718 if (ptsKeys[i].GetNumPoints() == 1)
719 {
720 LibUtilities::PointsKey pKey(2, ptsKeys[i].GetPointsType());
721 ptsKeys[i] = pKey;
722 }
723 }
724
725 SpatialDomains::GeomType type = geomFactors->GetGtype();
726 const Array<TwoD, const NekDouble> &df =
727 geomFactors->GetDerivFactors(ptsKeys);
728 const Array<OneD, const NekDouble> &jac = geomFactors->GetJac(ptsKeys);
729
730 int nq0 = ptsKeys[0].GetNumPoints();
731 int nq1 = ptsKeys[1].GetNumPoints();
732 int nq2 = ptsKeys[2].GetNumPoints();
733 int nq01 = nq0 * nq1;
734 int nqtot;
735
736 LibUtilities::BasisKey tobasis0 = GetTraceBasisKey(face, 0);
737 LibUtilities::BasisKey tobasis1 = GetTraceBasisKey(face, 1);
738
739 // Number of quadrature points in face expansion.
740 int nq_face = tobasis0.GetNumPoints() * tobasis1.GetNumPoints();
741
742 int vCoordDim = GetCoordim();
743 int i;
744
745 m_traceNormals[face] = Array<OneD, Array<OneD, NekDouble>>(vCoordDim);
746 Array<OneD, Array<OneD, NekDouble>> &normal = m_traceNormals[face];
747 for (i = 0; i < vCoordDim; ++i)
748 {
749 normal[i] = Array<OneD, NekDouble>(nq_face);
750 }
751
752 size_t nqb = nq_face;
753 size_t nbnd = face;
754 m_elmtBndNormDirElmtLen[nbnd] = Array<OneD, NekDouble>{nqb, 0.0};
755 Array<OneD, NekDouble> &length = m_elmtBndNormDirElmtLen[nbnd];
756
757 // Regular geometry case
758 if (type == SpatialDomains::eRegular ||
759 type == SpatialDomains::eMovingRegular)
760 {
761 NekDouble fac;
762 // Set up normals
763 switch (face)
764 {
765 case 0:
766 {
767 for (i = 0; i < vCoordDim; ++i)
768 {
769 normal[i][0] = -df[3 * i + 2][0];
770 ;
771 }
772 break;
773 }
774 case 1:
775 {
776 for (i = 0; i < vCoordDim; ++i)
777 {
778 normal[i][0] = -df[3 * i + 1][0];
779 }
780 break;
781 }
782 case 2:
783 {
784 for (i = 0; i < vCoordDim; ++i)
785 {
786 normal[i][0] = df[3 * i][0] + df[3 * i + 2][0];
787 }
788 break;
789 }
790 case 3:
791 {
792 for (i = 0; i < vCoordDim; ++i)
793 {
794 normal[i][0] = df[3 * i + 1][0];
795 }
796 break;
797 }
798 case 4:
799 {
800 for (i = 0; i < vCoordDim; ++i)
801 {
802 normal[i][0] = -df[3 * i][0];
803 }
804 break;
805 }
806 default:
807 ASSERTL0(false, "face is out of range (face < 4)");
808 }
809
810 // Normalise resulting vector.
811 fac = 0.0;
812 for (i = 0; i < vCoordDim; ++i)
813 {
814 fac += normal[i][0] * normal[i][0];
815 }
816 fac = 1.0 / sqrt(fac);
817
818 Vmath::Fill(nqb, fac, length, 1);
819
820 for (i = 0; i < vCoordDim; ++i)
821 {
822 Vmath::Fill(nq_face, fac * normal[i][0], normal[i], 1);
823 }
824 }
825 else
826 {
827 // Set up deformed normals.
828 int j, k;
829
830 // Determine number of quadrature points on the face of 3D elmt
831 if (face == 0)
832 {
833 nqtot = nq0 * nq1;
834 }
835 else if (face == 1 || face == 3)
836 {
837 nqtot = nq0 * nq2;
838 }
839 else
840 {
841 nqtot = nq1 * nq2;
842 }
843
844 LibUtilities::PointsKey points0;
845 LibUtilities::PointsKey points1;
846
847 Array<OneD, NekDouble> faceJac(nqtot);
848 Array<OneD, NekDouble> normals(vCoordDim * nqtot, 0.0);
849
850 // Extract Jacobian along face and recover local derivatives
851 // (dx/dr) for polynomial interpolation by multiplying m_gmat by
852 // jacobian
853 switch (face)
854 {
855 case 0:
856 {
857 for (j = 0; j < nq01; ++j)
858 {
859 normals[j] = -df[2][j] * jac[j];
860 normals[nqtot + j] = -df[5][j] * jac[j];
861 normals[2 * nqtot + j] = -df[8][j] * jac[j];
862 faceJac[j] = jac[j];
863 }
864
865 points0 = ptsKeys[0];
866 points1 = ptsKeys[1];
867 break;
868 }
869
870 case 1:
871 {
872 for (j = 0; j < nq0; ++j)
873 {
874 for (k = 0; k < nq2; ++k)
875 {
876 int tmp = j + nq01 * k;
877 normals[j + k * nq0] = -df[1][tmp] * jac[tmp];
878 normals[nqtot + j + k * nq0] = -df[4][tmp] * jac[tmp];
879 normals[2 * nqtot + j + k * nq0] =
880 -df[7][tmp] * jac[tmp];
881 faceJac[j + k * nq0] = jac[tmp];
882 }
883 }
884
885 points0 = ptsKeys[0];
886 points1 = ptsKeys[2];
887 break;
888 }
889
890 case 2:
891 {
892 for (j = 0; j < nq1; ++j)
893 {
894 for (k = 0; k < nq2; ++k)
895 {
896 int tmp = nq0 - 1 + nq0 * j + nq01 * k;
897 normals[j + k * nq1] =
898 (df[0][tmp] + df[2][tmp]) * jac[tmp];
899 normals[nqtot + j + k * nq1] =
900 (df[3][tmp] + df[5][tmp]) * jac[tmp];
901 normals[2 * nqtot + j + k * nq1] =
902 (df[6][tmp] + df[8][tmp]) * jac[tmp];
903 faceJac[j + k * nq1] = jac[tmp];
904 }
905 }
906
907 points0 = ptsKeys[1];
908 points1 = ptsKeys[2];
909 break;
910 }
911
912 case 3:
913 {
914 for (j = 0; j < nq0; ++j)
915 {
916 for (k = 0; k < nq2; ++k)
917 {
918 int tmp = nq0 * (nq1 - 1) + j + nq01 * k;
919 normals[j + k * nq0] = df[1][tmp] * jac[tmp];
920 normals[nqtot + j + k * nq0] = df[4][tmp] * jac[tmp];
921 normals[2 * nqtot + j + k * nq0] =
922 df[7][tmp] * jac[tmp];
923 faceJac[j + k * nq0] = jac[tmp];
924 }
925 }
926
927 points0 = ptsKeys[0];
928 points1 = ptsKeys[2];
929 break;
930 }
931
932 case 4:
933 {
934 for (j = 0; j < nq1; ++j)
935 {
936 for (k = 0; k < nq2; ++k)
937 {
938 int tmp = j * nq0 + nq01 * k;
939 normals[j + k * nq1] = -df[0][tmp] * jac[tmp];
940 normals[nqtot + j + k * nq1] = -df[3][tmp] * jac[tmp];
941 normals[2 * nqtot + j + k * nq1] =
942 -df[6][tmp] * jac[tmp];
943 faceJac[j + k * nq1] = jac[tmp];
944 }
945 }
946
947 points0 = ptsKeys[1];
948 points1 = ptsKeys[2];
949 break;
950 }
951
952 default:
953 ASSERTL0(false, "face is out of range (face < 4)");
954 }
955
956 Array<OneD, NekDouble> work(nq_face, 0.0);
957 // Interpolate Jacobian and invert
958 LibUtilities::Interp2D(points0, points1, faceJac,
959 tobasis0.GetPointsKey(), tobasis1.GetPointsKey(),
960 work);
961 Vmath::Sdiv(nq_face, 1.0, &work[0], 1, &work[0], 1);
962
963 // Interpolate normal and multiply by inverse Jacobian.
964 for (i = 0; i < vCoordDim; ++i)
965 {
966 LibUtilities::Interp2D(points0, points1, &normals[i * nqtot],
967 tobasis0.GetPointsKey(),
968 tobasis1.GetPointsKey(), &normal[i][0]);
969 Vmath::Vmul(nq_face, work, 1, normal[i], 1, normal[i], 1);
970 }
971
972 // Normalise to obtain unit normals.
973 Vmath::Zero(nq_face, work, 1);
974 for (i = 0; i < GetCoordim(); ++i)
975 {
976 Vmath::Vvtvp(nq_face, normal[i], 1, normal[i], 1, work, 1, work, 1);
977 }
978
979 Vmath::Vsqrt(nq_face, work, 1, work, 1);
980 Vmath::Sdiv(nq_face, 1.0, work, 1, work, 1);
981
982 Vmath::Vcopy(nqb, work, 1, length, 1);
983
984 for (i = 0; i < GetCoordim(); ++i)
985 {
986 Vmath::Vmul(nq_face, normal[i], 1, work, 1, normal[i], 1);
987 }
988 }
989}
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:215
Nektar::LocalRegions::Expansion::m_traceNormals
std::map< int, NormalVector > m_traceNormals
Definition: Expansion.h:278
Nektar::LocalRegions::Expansion::m_elmtBndNormDirElmtLen
std::map< int, Array< OneD, NekDouble > > m_elmtBndNormDirElmtLen
the element length in each element boundary(Vertex, edge or face) normal direction calculated based o...
Definition: Expansion.h:288
Nektar::LocalRegions::Expansion::GetGeom
SpatialDomains::GeometrySharedPtr GetGeom() const
Definition: Expansion.cpp:171
Nektar::StdRegions::StdExpansion::GetTraceBasisKey
const LibUtilities::BasisKey GetTraceBasisKey(const int i, int k=-1) const
This function returns the basis key belonging to the i-th trace.
Definition: StdExpansion.h:305
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
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::LibUtilities::Interp2D
void Interp2D(const BasisKey &fbasis0, const BasisKey &fbasis1, const Array< OneD, const NekDouble > &from, const BasisKey &tbasis0, const BasisKey &tbasis1, Array< OneD, NekDouble > &to)
this function interpolates a 2D function evaluated at the quadrature points of the 2D basis,...
Definition: Interp.cpp:103
Nektar::LibUtilities::PointsKeyVector
std::vector< PointsKey > PointsKeyVector
Definition: Points.h:236
Nektar::SpatialDomains::GeomFactorsSharedPtr
std::shared_ptr< GeomFactors > GeomFactorsSharedPtr
Pointer to a GeomFactors object.
Definition: GeomFactors.h:62
Nektar::SpatialDomains::GeomType
GeomType
Indicates the type of element geometry.
Definition: SpatialDomains.hpp:52
Nektar::SpatialDomains::eRegular
@ eRegular
Geometry is straight-sided with constant geometric factors.
Definition: SpatialDomains.hpp:54
Nektar::SpatialDomains::eMovingRegular
@ eMovingRegular
Currently unused.
Definition: SpatialDomains.hpp:57
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:43
Vmath::Vsqrt
void Vsqrt(int n, const T *x, const int incx, T *y, const int incy)
sqrt y = sqrt(x)
Definition: Vmath.cpp:529
Vmath::Vvtvp
void Vvtvp(int n, const T *w, const int incw, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
vvtvp (vector times vector plus vector): z = w*x + y
Definition: Vmath.cpp:569
Vmath::Sdiv
void Sdiv(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Scalar multiply y = alpha/x.
Definition: Vmath.cpp:319
Vmath::Zero
void Zero(int n, T *x, const int incx)
Zero vector.
Definition: Vmath.cpp:487
Vmath::Fill
void Fill(int n, const T alpha, T *x, const int incx)
Fill a vector with a constant value.
Definition: Vmath.cpp:43
tinysimd::sqrt
scalarT< T > sqrt(scalarT< T > in)
Definition: scalar.hpp:294

References ASSERTL0, Nektar::SpatialDomains::eMovingRegular, Nektar::SpatialDomains::eRegular, Vmath::Fill(), Nektar::StdRegions::StdExpansion::GetCoordim(), Nektar::LocalRegions::Expansion::GetGeom(), Nektar::LibUtilities::BasisKey::GetNumPoints(), Nektar::StdRegions::StdExpansion::GetNumPoints(), Nektar::LibUtilities::BasisKey::GetPointsKey(), Nektar::StdRegions::StdExpansion::GetPointsKeys(), Nektar::StdRegions::StdExpansion::GetPointsType(), Nektar::StdRegions::StdExpansion::GetTraceBasisKey(), Nektar::LibUtilities::Interp2D(), Nektar::LocalRegions::Expansion::m_elmtBndNormDirElmtLen, Nektar::LocalRegions::Expansion::m_traceNormals, Vmath::Sdiv(), tinysimd::sqrt(), Vmath::Vcopy(), Vmath::Vmul(), Vmath::Vsqrt(), Vmath::Vvtvp(), and Vmath::Zero().

◆ v_CreateStdMatrix()

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

Reimplemented from Nektar::StdRegions::StdPrismExp.

Definition at line 1074 of file PrismExp.cpp.

1076{
1077 LibUtilities::BasisKey bkey0 = m_base[0]->GetBasisKey();
1078 LibUtilities::BasisKey bkey1 = m_base[1]->GetBasisKey();
1079 LibUtilities::BasisKey bkey2 = m_base[2]->GetBasisKey();
1080 StdRegions::StdPrismExpSharedPtr tmp =
1081 MemoryManager<StdPrismExp>::AllocateSharedPtr(bkey0, bkey1, bkey2);
1082
1083 return tmp->GetStdMatrix(mkey);
1084}
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::StdPrismExpSharedPtr
std::shared_ptr< StdPrismExp > StdPrismExpSharedPtr
Definition: StdPrismExp.h:239

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), and Nektar::StdRegions::StdExpansion::m_base.

◆ v_DropLocMatrix()

void Nektar::LocalRegions::PrismExp::v_DropLocMatrix ( const MatrixKey &  mkey)
overrideprotectedvirtual

Reimplemented from Nektar::LocalRegions::Expansion.

Definition at line 1091 of file PrismExp.cpp.

1092{
1093 m_matrixManager.DeleteObject(mkey);
1094}

References m_matrixManager.

◆ v_DropLocStaticCondMatrix()

void Nektar::LocalRegions::PrismExp::v_DropLocStaticCondMatrix ( const MatrixKey &  mkey)
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 1102 of file PrismExp.cpp.

1103{
1104 m_staticCondMatrixManager.DeleteObject(mkey);
1105}

References m_staticCondMatrixManager.

◆ v_ExtractDataToCoeffs()

void Nektar::LocalRegions::PrismExp::v_ExtractDataToCoeffs ( const NekDouble *  data,
const std::vector< unsigned int > &  nummodes,
const int  mode_offset,
NekDouble *  coeffs,
std::vector< LibUtilities::BasisType > &  fromType 
)
overrideprotectedvirtual

Reimplemented from Nektar::LocalRegions::Expansion.

Definition at line 549 of file PrismExp.cpp.

553{
554 boost::ignore_unused(fromType);
555
556 int data_order0 = nummodes[mode_offset];
557 int fillorder0 = min(m_base[0]->GetNumModes(), data_order0);
558 int data_order1 = nummodes[mode_offset + 1];
559 int order1 = m_base[1]->GetNumModes();
560 int fillorder1 = min(order1, data_order1);
561 int data_order2 = nummodes[mode_offset + 2];
562 int order2 = m_base[2]->GetNumModes();
563 int fillorder2 = min(order2, data_order2);
564
565 switch (m_base[0]->GetBasisType())
566 {
567 case LibUtilities::eModified_A:
568 {
569 int i, j;
570 int cnt = 0;
571 int cnt1 = 0;
572
573 ASSERTL1(m_base[1]->GetBasisType() == LibUtilities::eModified_A,
574 "Extraction routine not set up for this basis");
575 ASSERTL1(m_base[2]->GetBasisType() == LibUtilities::eModified_B,
576 "Extraction routine not set up for this basis");
577
578 Vmath::Zero(m_ncoeffs, coeffs, 1);
579 for (j = 0; j < fillorder0; ++j)
580 {
581 for (i = 0; i < fillorder1; ++i)
582 {
583 Vmath::Vcopy(fillorder2 - j, &data[cnt], 1, &coeffs[cnt1],
584 1);
585 cnt += data_order2 - j;
586 cnt1 += order2 - j;
587 }
588
589 // count out data for j iteration
590 for (i = fillorder1; i < data_order1; ++i)
591 {
592 cnt += data_order2 - j;
593 }
594
595 for (i = fillorder1; i < order1; ++i)
596 {
597 cnt1 += order2 - j;
598 }
599 }
600 }
601 break;
602 default:
603 ASSERTL0(false, "basis is either not set up or not "
604 "hierarchicial");
605 }
606}
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::LibUtilities::eModified_B
@ eModified_B
Principle Modified Functions .
Definition: BasisType.h:51
Nektar::LibUtilities::eModified_A
@ eModified_A
Principle Modified Functions .
Definition: BasisType.h:50

References ASSERTL0, ASSERTL1, Nektar::LibUtilities::eModified_A, Nektar::LibUtilities::eModified_B, Nektar::StdRegions::StdExpansion::GetBasisType(), Nektar::StdRegions::StdExpansion::m_base, Nektar::StdRegions::StdExpansion::m_ncoeffs, Vmath::Vcopy(), and Vmath::Zero().

◆ v_FwdTrans()

void Nektar::LocalRegions::PrismExp::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 (this)->m_coeffs.

Inputs:

  • inarray: array of physical quadrature points to be transformed

Outputs:

  • (this)->_coeffs: updated array of expansion coefficients.

Reimplemented from Nektar::StdRegions::StdPrismExp.

Definition at line 213 of file PrismExp.cpp.

215{
216 if (m_base[0]->Collocation() && m_base[1]->Collocation() &&
217 m_base[2]->Collocation())
218 {
219 Vmath::Vcopy(GetNcoeffs(), &inarray[0], 1, &outarray[0], 1);
220 }
221 else
222 {
223 v_IProductWRTBase(inarray, outarray);
224
225 // get Mass matrix inverse
226 MatrixKey masskey(StdRegions::eInvMass, DetShapeType(), *this);
227 DNekScalMatSharedPtr matsys = m_matrixManager[masskey];
228
229 // copy inarray in case inarray == outarray
230 DNekVec in(m_ncoeffs, outarray);
231 DNekVec out(m_ncoeffs, outarray, eWrapper);
232
233 out = (*matsys) * in;
234 }
235}
Nektar::LocalRegions::PrismExp::v_IProductWRTBase
virtual 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: PrismExp.cpp:265
Nektar::StdRegions::StdExpansion::GetNcoeffs
int GetNcoeffs(void) const
This function returns the total number of coefficients used in the expansion.
Definition: StdExpansion.h:130
Nektar::StdRegions::StdExpansion::DetShapeType
LibUtilities::ShapeType DetShapeType() const
This function returns the shape of the expansion domain.
Definition: StdExpansion.h:373
Nektar::DNekScalMatSharedPtr
std::shared_ptr< DNekScalMat > DNekScalMatSharedPtr
Definition: NekMatrixFwd.hpp:68
Nektar::DNekVec
NekVector< NekDouble > DNekVec
Definition: NekTypeDefs.hpp:48

References Nektar::StdRegions::StdExpansion::DetShapeType(), Nektar::StdRegions::eInvMass, Nektar::eWrapper, Nektar::StdRegions::StdExpansion::GetNcoeffs(), Nektar::StdRegions::StdExpansion::m_base, m_matrixManager, Nektar::StdRegions::StdExpansion::m_ncoeffs, v_IProductWRTBase(), and Vmath::Vcopy().

◆ v_GenMatrix()

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

Reimplemented from Nektar::StdRegions::StdPrismExp.

Definition at line 1051 of file PrismExp.cpp.

1052{
1053 DNekMatSharedPtr returnval;
1054
1055 switch (mkey.GetMatrixType())
1056 {
1057 case StdRegions::eHybridDGHelmholtz:
1058 case StdRegions::eHybridDGLamToU:
1059 case StdRegions::eHybridDGLamToQ0:
1060 case StdRegions::eHybridDGLamToQ1:
1061 case StdRegions::eHybridDGLamToQ2:
1062 case StdRegions::eHybridDGHelmBndLam:
1063 case StdRegions::eInvLaplacianWithUnityMean:
1064 returnval = Expansion3D::v_GenMatrix(mkey);
1065 break;
1066 default:
1067 returnval = StdPrismExp::v_GenMatrix(mkey);
1068 break;
1069 }
1070
1071 return returnval;
1072}
Nektar::LocalRegions::Expansion3D::v_GenMatrix
virtual DNekMatSharedPtr v_GenMatrix(const StdRegions::StdMatrixKey &mkey) override
Definition: Expansion3D.cpp:905
Nektar::DNekMatSharedPtr
std::shared_ptr< DNekMat > DNekMatSharedPtr
Definition: NekTypeDefs.hpp:75

References Nektar::StdRegions::eHybridDGHelmBndLam, Nektar::StdRegions::eHybridDGHelmholtz, Nektar::StdRegions::eHybridDGLamToQ0, Nektar::StdRegions::eHybridDGLamToQ1, Nektar::StdRegions::eHybridDGLamToQ2, Nektar::StdRegions::eHybridDGLamToU, Nektar::StdRegions::eInvLaplacianWithUnityMean, Nektar::StdRegions::StdMatrixKey::GetMatrixType(), and Nektar::LocalRegions::Expansion3D::v_GenMatrix().

◆ v_GetCoord()

void Nektar::LocalRegions::PrismExp::v_GetCoord ( const Array< OneD, const NekDouble > &  Lcoords,
Array< OneD, NekDouble > &  coords 
)
overrideprotectedvirtual

Get the coordinates #coords at the local coordinates #Lcoords.

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 486 of file PrismExp.cpp.

488{
489 int i;
490
491 ASSERTL1(Lcoords[0] <= -1.0 && Lcoords[0] >= 1.0 && Lcoords[1] <= -1.0 &&
492 Lcoords[1] >= 1.0 && Lcoords[2] <= -1.0 && Lcoords[2] >= 1.0,
493 "Local coordinates are not in region [-1,1]");
494
495 m_geom->FillGeom();
496
497 for (i = 0; i < m_geom->GetCoordim(); ++i)
498 {
499 coords[i] = m_geom->GetCoord(i, Lcoords);
500 }
501}
Nektar::LocalRegions::Expansion::m_geom
SpatialDomains::GeometrySharedPtr m_geom
Definition: Expansion.h:275

References ASSERTL1, and Nektar::LocalRegions::Expansion::m_geom.

◆ v_GetCoords()

void Nektar::LocalRegions::PrismExp::v_GetCoords ( Array< OneD, NekDouble > &  coords_1,
Array< OneD, NekDouble > &  coords_2,
Array< OneD, NekDouble > &  coords_3 
)
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdPrismExp.

Definition at line 503 of file PrismExp.cpp.

506{
507 Expansion::v_GetCoords(coords_0, coords_1, coords_2);
508}
Nektar::LocalRegions::Expansion::v_GetCoords
virtual void v_GetCoords(Array< OneD, NekDouble > &coords_1, Array< OneD, NekDouble > &coords_2, Array< OneD, NekDouble > &coords_3) override
Definition: Expansion.cpp:535

References Nektar::LocalRegions::Expansion::v_GetCoords().

◆ v_GetLinStdExp()

StdRegions::StdExpansionSharedPtr Nektar::LocalRegions::PrismExp::v_GetLinStdExp ( void  ) const
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 469 of file PrismExp.cpp.

470{
471 LibUtilities::BasisKey bkey0(m_base[0]->GetBasisType(), 2,
472 m_base[0]->GetPointsKey());
473 LibUtilities::BasisKey bkey1(m_base[1]->GetBasisType(), 2,
474 m_base[1]->GetPointsKey());
475 LibUtilities::BasisKey bkey2(m_base[2]->GetBasisType(), 2,
476 m_base[2]->GetPointsKey());
477
478 return MemoryManager<StdRegions::StdPrismExp>::AllocateSharedPtr(
479 bkey0, bkey1, bkey2);
480}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::StdRegions::StdExpansion::GetBasisType(), and Nektar::StdRegions::StdExpansion::m_base.

◆ v_GetLocMatrix()

DNekScalMatSharedPtr Nektar::LocalRegions::PrismExp::v_GetLocMatrix ( const MatrixKey &  mkey)
overrideprotectedvirtual

Reimplemented from Nektar::LocalRegions::Expansion.

Definition at line 1086 of file PrismExp.cpp.

1087{
1088 return m_matrixManager[mkey];
1089}

References m_matrixManager.

◆ v_GetLocStaticCondMatrix()

DNekScalBlkMatSharedPtr Nektar::LocalRegions::PrismExp::v_GetLocStaticCondMatrix ( const MatrixKey &  mkey)
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 1096 of file PrismExp.cpp.

1098{
1099 return m_staticCondMatrixManager[mkey];
1100}

References m_staticCondMatrixManager.

◆ v_GetSimplexEquiSpacedConnectivity()

void Nektar::LocalRegions::PrismExp::v_GetSimplexEquiSpacedConnectivity ( Array< OneD, int > &  conn,
bool  standard = true 
)
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 1311 of file PrismExp.cpp.

1313{
1314 boost::ignore_unused(oldstandard);
1315
1316 int np0 = m_base[0]->GetNumPoints();
1317 int np1 = m_base[1]->GetNumPoints();
1318 int np2 = m_base[2]->GetNumPoints();
1319 int np = max(np0, max(np1, np2));
1320 Array<OneD, int> prismpt(6);
1321 bool standard = true;
1322
1323 int vid0 = m_geom->GetVid(0);
1324 int vid1 = m_geom->GetVid(1);
1325 int vid2 = m_geom->GetVid(4);
1326 int rotate = 0;
1327
1328 // sort out prism rotation according to
1329 if ((vid2 < vid1) && (vid2 < vid0)) // top triangle vertex is lowest id
1330 {
1331 rotate = 0;
1332 if (vid0 > vid1)
1333 {
1334 standard = false; // reverse base direction
1335 }
1336 }
1337 else if ((vid1 < vid2) && (vid1 < vid0))
1338 {
1339 rotate = 1;
1340 if (vid2 > vid0)
1341 {
1342 standard = false; // reverse base direction
1343 }
1344 }
1345 else if ((vid0 < vid2) && (vid0 < vid1))
1346 {
1347 rotate = 2;
1348 if (vid1 > vid2)
1349 {
1350 standard = false; // reverse base direction
1351 }
1352 }
1353
1354 conn = Array<OneD, int>(12 * (np - 1) * (np - 1) * (np - 1));
1355
1356 int row = 0;
1357 int rowp1 = 0;
1358 int plane = 0;
1359 int row1 = 0;
1360 int row1p1 = 0;
1361 int planep1 = 0;
1362 int cnt = 0;
1363
1364 Array<OneD, int> rot(3);
1365
1366 rot[0] = (0 + rotate) % 3;
1367 rot[1] = (1 + rotate) % 3;
1368 rot[2] = (2 + rotate) % 3;
1369
1370 // lower diagonal along 1-3 on base
1371 for (int i = 0; i < np - 1; ++i)
1372 {
1373 planep1 += (np - i) * np;
1374 row = 0; // current plane row offset
1375 rowp1 = 0; // current plane row plus one offset
1376 row1 = 0; // next plane row offset
1377 row1p1 = 0; // nex plane row plus one offset
1378 if (standard == false)
1379 {
1380 for (int j = 0; j < np - 1; ++j)
1381 {
1382 rowp1 += np - i;
1383 row1p1 += np - i - 1;
1384 for (int k = 0; k < np - i - 2; ++k)
1385 {
1386 // bottom prism block
1387 prismpt[rot[0]] = plane + row + k;
1388 prismpt[rot[1]] = plane + row + k + 1;
1389 prismpt[rot[2]] = planep1 + row1 + k;
1390
1391 prismpt[3 + rot[0]] = plane + rowp1 + k;
1392 prismpt[3 + rot[1]] = plane + rowp1 + k + 1;
1393 prismpt[3 + rot[2]] = planep1 + row1p1 + k;
1394
1395 conn[cnt++] = prismpt[0];
1396 conn[cnt++] = prismpt[1];
1397 conn[cnt++] = prismpt[3];
1398 conn[cnt++] = prismpt[2];
1399
1400 conn[cnt++] = prismpt[5];
1401 conn[cnt++] = prismpt[2];
1402 conn[cnt++] = prismpt[3];
1403 conn[cnt++] = prismpt[4];
1404
1405 conn[cnt++] = prismpt[3];
1406 conn[cnt++] = prismpt[1];
1407 conn[cnt++] = prismpt[4];
1408 conn[cnt++] = prismpt[2];
1409
1410 // upper prism block.
1411 prismpt[rot[0]] = planep1 + row1 + k + 1;
1412 prismpt[rot[1]] = planep1 + row1 + k;
1413 prismpt[rot[2]] = plane + row + k + 1;
1414
1415 prismpt[3 + rot[0]] = planep1 + row1p1 + k + 1;
1416 prismpt[3 + rot[1]] = planep1 + row1p1 + k;
1417 prismpt[3 + rot[2]] = plane + rowp1 + k + 1;
1418
1419 conn[cnt++] = prismpt[0];
1420 conn[cnt++] = prismpt[1];
1421 conn[cnt++] = prismpt[2];
1422 conn[cnt++] = prismpt[5];
1423
1424 conn[cnt++] = prismpt[5];
1425 conn[cnt++] = prismpt[0];
1426 conn[cnt++] = prismpt[4];
1427 conn[cnt++] = prismpt[1];
1428
1429 conn[cnt++] = prismpt[3];
1430 conn[cnt++] = prismpt[4];
1431 conn[cnt++] = prismpt[0];
1432 conn[cnt++] = prismpt[5];
1433 }
1434
1435 // bottom prism block
1436 prismpt[rot[0]] = plane + row + np - i - 2;
1437 prismpt[rot[1]] = plane + row + np - i - 1;
1438 prismpt[rot[2]] = planep1 + row1 + np - i - 2;
1439
1440 prismpt[3 + rot[0]] = plane + rowp1 + np - i - 2;
1441 prismpt[3 + rot[1]] = plane + rowp1 + np - i - 1;
1442 prismpt[3 + rot[2]] = planep1 + row1p1 + np - i - 2;
1443
1444 conn[cnt++] = prismpt[0];
1445 conn[cnt++] = prismpt[1];
1446 conn[cnt++] = prismpt[3];
1447 conn[cnt++] = prismpt[2];
1448
1449 conn[cnt++] = prismpt[5];
1450 conn[cnt++] = prismpt[2];
1451 conn[cnt++] = prismpt[3];
1452 conn[cnt++] = prismpt[4];
1453
1454 conn[cnt++] = prismpt[3];
1455 conn[cnt++] = prismpt[1];
1456 conn[cnt++] = prismpt[4];
1457 conn[cnt++] = prismpt[2];
1458
1459 row += np - i;
1460 row1 += np - i - 1;
1461 }
1462 }
1463 else
1464 { // lower diagonal along 0-4 on base
1465 for (int j = 0; j < np - 1; ++j)
1466 {
1467 rowp1 += np - i;
1468 row1p1 += np - i - 1;
1469 for (int k = 0; k < np - i - 2; ++k)
1470 {
1471 // bottom prism block
1472 prismpt[rot[0]] = plane + row + k;
1473 prismpt[rot[1]] = plane + row + k + 1;
1474 prismpt[rot[2]] = planep1 + row1 + k;
1475
1476 prismpt[3 + rot[0]] = plane + rowp1 + k;
1477 prismpt[3 + rot[1]] = plane + rowp1 + k + 1;
1478 prismpt[3 + rot[2]] = planep1 + row1p1 + k;
1479
1480 conn[cnt++] = prismpt[0];
1481 conn[cnt++] = prismpt[1];
1482 conn[cnt++] = prismpt[4];
1483 conn[cnt++] = prismpt[2];
1484
1485 conn[cnt++] = prismpt[4];
1486 conn[cnt++] = prismpt[3];
1487 conn[cnt++] = prismpt[0];
1488 conn[cnt++] = prismpt[2];
1489
1490 conn[cnt++] = prismpt[3];
1491 conn[cnt++] = prismpt[4];
1492 conn[cnt++] = prismpt[5];
1493 conn[cnt++] = prismpt[2];
1494
1495 // upper prism block.
1496 prismpt[rot[0]] = planep1 + row1 + k + 1;
1497 prismpt[rot[1]] = planep1 + row1 + k;
1498 prismpt[rot[2]] = plane + row + k + 1;
1499
1500 prismpt[3 + rot[0]] = planep1 + row1p1 + k + 1;
1501 prismpt[3 + rot[1]] = planep1 + row1p1 + k;
1502 prismpt[3 + rot[2]] = plane + rowp1 + k + 1;
1503
1504 conn[cnt++] = prismpt[0];
1505 conn[cnt++] = prismpt[2];
1506 conn[cnt++] = prismpt[1];
1507 conn[cnt++] = prismpt[5];
1508
1509 conn[cnt++] = prismpt[3];
1510 conn[cnt++] = prismpt[5];
1511 conn[cnt++] = prismpt[0];
1512 conn[cnt++] = prismpt[1];
1513
1514 conn[cnt++] = prismpt[5];
1515 conn[cnt++] = prismpt[3];
1516 conn[cnt++] = prismpt[4];
1517 conn[cnt++] = prismpt[1];
1518 }
1519
1520 // bottom prism block
1521 prismpt[rot[0]] = plane + row + np - i - 2;
1522 prismpt[rot[1]] = plane + row + np - i - 1;
1523 prismpt[rot[2]] = planep1 + row1 + np - i - 2;
1524
1525 prismpt[3 + rot[0]] = plane + rowp1 + np - i - 2;
1526 prismpt[3 + rot[1]] = plane + rowp1 + np - i - 1;
1527 prismpt[3 + rot[2]] = planep1 + row1p1 + np - i - 2;
1528
1529 conn[cnt++] = prismpt[0];
1530 conn[cnt++] = prismpt[1];
1531 conn[cnt++] = prismpt[4];
1532 conn[cnt++] = prismpt[2];
1533
1534 conn[cnt++] = prismpt[4];
1535 conn[cnt++] = prismpt[3];
1536 conn[cnt++] = prismpt[0];
1537 conn[cnt++] = prismpt[2];
1538
1539 conn[cnt++] = prismpt[3];
1540 conn[cnt++] = prismpt[4];
1541 conn[cnt++] = prismpt[5];
1542 conn[cnt++] = prismpt[2];
1543
1544 row += np - i;
1545 row1 += np - i - 1;
1546 }
1547 }
1548 plane += (np - i) * np;
1549 }
1550}

References Nektar::StdRegions::StdExpansion::m_base, and Nektar::LocalRegions::Expansion::m_geom.

◆ v_GetStdExp()

StdRegions::StdExpansionSharedPtr Nektar::LocalRegions::PrismExp::v_GetStdExp ( void  ) const
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 462 of file PrismExp.cpp.

463{
464 return MemoryManager<StdRegions::StdPrismExp>::AllocateSharedPtr(
465 m_base[0]->GetBasisKey(), m_base[1]->GetBasisKey(),
466 m_base[2]->GetBasisKey());
467}

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), and Nektar::StdRegions::StdExpansion::m_base.

◆ v_GetTracePhysMap()

void Nektar::LocalRegions::PrismExp::v_GetTracePhysMap ( const int  face,
Array< OneD, int > &  outarray 
)
overrideprotectedvirtual

Reimplemented from Nektar::LocalRegions::Expansion.

Definition at line 608 of file PrismExp.cpp.

609{
610 int nquad0 = m_base[0]->GetNumPoints();
611 int nquad1 = m_base[1]->GetNumPoints();
612 int nquad2 = m_base[2]->GetNumPoints();
613 int nq0 = 0;
614 int nq1 = 0;
615
616 switch (face)
617 {
618 case 0:
619 nq0 = nquad0;
620 nq1 = nquad1;
621 if (outarray.size() != nq0 * nq1)
622 {
623 outarray = Array<OneD, int>(nq0 * nq1);
624 }
625
626 // Directions A and B positive
627 for (int i = 0; i < nquad0 * nquad1; ++i)
628 {
629 outarray[i] = i;
630 }
631 break;
632 case 1:
633
634 nq0 = nquad0;
635 nq1 = nquad2;
636 if (outarray.size() != nq0 * nq1)
637 {
638 outarray = Array<OneD, int>(nq0 * nq1);
639 }
640
641 // Direction A and B positive
642 for (int k = 0; k < nquad2; k++)
643 {
644 for (int i = 0; i < nquad0; ++i)
645 {
646 outarray[k * nquad0 + i] = (nquad0 * nquad1 * k) + i;
647 }
648 }
649
650 break;
651 case 2:
652
653 nq0 = nquad1;
654 nq1 = nquad2;
655 if (outarray.size() != nq0 * nq1)
656 {
657 outarray = Array<OneD, int>(nq0 * nq1);
658 }
659
660 // Directions A and B positive
661 for (int j = 0; j < nquad1 * nquad2; ++j)
662 {
663 outarray[j] = nquad0 - 1 + j * nquad0;
664 }
665 break;
666 case 3:
667 nq0 = nquad0;
668 nq1 = nquad2;
669 if (outarray.size() != nq0 * nq1)
670 {
671 outarray = Array<OneD, int>(nq0 * nq1);
672 }
673
674 // Direction A and B positive
675 for (int k = 0; k < nquad2; k++)
676 {
677 for (int i = 0; i < nquad0; ++i)
678 {
679 outarray[k * nquad0 + i] =
680 nquad0 * (nquad1 - 1) + (nquad0 * nquad1 * k) + i;
681 }
682 }
683 break;
684 case 4:
685
686 nq0 = nquad1;
687 nq1 = nquad2;
688 if (outarray.size() != nq0 * nq1)
689 {
690 outarray = Array<OneD, int>(nq0 * nq1);
691 }
692
693 // Directions A and B positive
694 for (int j = 0; j < nquad1 * nquad2; ++j)
695 {
696 outarray[j] = j * nquad0;
697 }
698 break;
699 default:
700 ASSERTL0(false, "face value (> 4) is out of range");
701 break;
702 }
703}

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

◆ v_HelmholtzMatrixOp()

void Nektar::LocalRegions::PrismExp::v_HelmholtzMatrixOp ( const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray,
const StdRegions::StdMatrixKey &  mkey 
)
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 1013 of file PrismExp.cpp.

1016{
1017 PrismExp::v_HelmholtzMatrixOp_MatFree(inarray, outarray, mkey);
1018}
Nektar::StdRegions::StdExpansion3D::v_HelmholtzMatrixOp_MatFree
virtual void v_HelmholtzMatrixOp_MatFree(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey) override
Definition: StdExpansion3D.cpp:339

References Nektar::StdRegions::StdExpansion3D::v_HelmholtzMatrixOp_MatFree().

◆ v_Integral()

NekDouble Nektar::LocalRegions::PrismExp::v_Integral ( const Array< OneD, const NekDouble > &  inarray)
overrideprotectedvirtual

Integrate the physical point list inarray over prismatic region and return the value.

Inputs:

  • inarray: definition of function to be returned at quadrature point of expansion.

Outputs:

  • returns \(\int^1_{-1}\int^1_{-1}\int^1_{-1} u(\bar \eta_1, \xi_2, \xi_3) J[i,j,k] d \bar \eta_1 d \xi_2 d \xi_3 \)
    \( = \sum_{i=0}^{Q_1 - 1} \sum_{j=0}^{Q_2 - 1} \sum_{k=0}^{Q_3 - 1} u(\bar \eta_{1i}^{0,0}, \xi_{2j}^{0,0},\xi_{3k}^{1,0})w_{i}^{0,0} w_{j}^{0,0} \hat w_{k}^{1,0} \)
    where \( inarray[i,j, k] = u(\bar \eta_{1i}^{0,0}, \xi_{2j}^{0,0},\xi_{3k}^{1,0}) \),
    \(\hat w_{i}^{1,0} = \frac {w_{j}^{1,0}} {2} \)
    and \( J[i,j,k] \) is the Jacobian evaluated at the quadrature point.

Reimplemented from Nektar::StdRegions::StdExpansion3D.

Definition at line 100 of file PrismExp.cpp.

101{
102 int nquad0 = m_base[0]->GetNumPoints();
103 int nquad1 = m_base[1]->GetNumPoints();
104 int nquad2 = m_base[2]->GetNumPoints();
105 Array<OneD, const NekDouble> jac = m_metricinfo->GetJac(GetPointsKeys());
106 Array<OneD, NekDouble> tmp(nquad0 * nquad1 * nquad2);
107
108 // Multiply inarray with Jacobian
109 if (m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
110 {
111 Vmath::Vmul(nquad0 * nquad1 * nquad2, &jac[0], 1,
112 (NekDouble *)&inarray[0], 1, &tmp[0], 1);
113 }
114 else
115 {
116 Vmath::Smul(nquad0 * nquad1 * nquad2, (NekDouble)jac[0],
117 (NekDouble *)&inarray[0], 1, &tmp[0], 1);
118 }
119
120 // Call StdPrismExp version.
121 return StdPrismExp::v_Integral(tmp);
122}

References Nektar::SpatialDomains::eDeformed, Nektar::StdRegions::StdExpansion::GetPointsKeys(), Nektar::StdRegions::StdExpansion::m_base, Nektar::LocalRegions::Expansion::m_metricinfo, Vmath::Smul(), and Vmath::Vmul().

◆ v_IProductWRTBase()

void Nektar::LocalRegions::PrismExp::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} \)

Reimplemented from Nektar::StdRegions::StdPrismExp.

Definition at line 265 of file PrismExp.cpp.

267{
268 v_IProductWRTBase_SumFac(inarray, outarray);
269}
Nektar::LocalRegions::PrismExp::v_IProductWRTBase_SumFac
virtual void v_IProductWRTBase_SumFac(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, bool multiplybyweights=true) override
Definition: PrismExp.cpp:271

References v_IProductWRTBase_SumFac().

Referenced by v_FwdTrans().

◆ v_IProductWRTBase_SumFac()

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

Reimplemented from Nektar::StdRegions::StdPrismExp.

Definition at line 271 of file PrismExp.cpp.

274{
275 const int nquad0 = m_base[0]->GetNumPoints();
276 const int nquad1 = m_base[1]->GetNumPoints();
277 const int nquad2 = m_base[2]->GetNumPoints();
278 const int order0 = m_base[0]->GetNumModes();
279 const int order1 = m_base[1]->GetNumModes();
280
281 Array<OneD, NekDouble> wsp(order0 * nquad2 * (nquad1 + order1));
282
283 if (multiplybyweights)
284 {
285 Array<OneD, NekDouble> tmp(nquad0 * nquad1 * nquad2);
286
287 MultiplyByQuadratureMetric(inarray, tmp);
288
289 IProductWRTBase_SumFacKernel(
290 m_base[0]->GetBdata(), m_base[1]->GetBdata(), m_base[2]->GetBdata(),
291 tmp, outarray, wsp, true, true, true);
292 }
293 else
294 {
295 IProductWRTBase_SumFacKernel(
296 m_base[0]->GetBdata(), m_base[1]->GetBdata(), m_base[2]->GetBdata(),
297 inarray, outarray, wsp, true, true, true);
298 }
299}
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
Nektar::StdRegions::StdExpansion::MultiplyByQuadratureMetric
void MultiplyByQuadratureMetric(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
Definition: StdExpansion.h:729

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

Referenced by v_IProductWRTBase().

◆ v_IProductWRTDerivBase()

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

Calculates the inner product \( I_{pqr} = (u, \partial_{x_i} \phi_{pqr}) \).

The derivative of the basis functions is performed using the chain rule in order to incorporate the geometric factors. Assuming that the basis functions are a tensor product \(\phi_{pqr}(\eta_1,\eta_2,\eta_3) = \phi_1(\eta_1)\phi_2(\eta_2)\phi_3(\eta_3)\), this yields the result

\[ I_{pqr} = \sum_{j=1}^3 \left(u, \frac{\partial u}{\partial \eta_j} \frac{\partial \eta_j}{\partial x_i}\right) \]

In the tetrahedral element, we must also incorporate a second set of geometric factors which incorporate the collapsed co-ordinate system, so that

\[ \frac{\partial\eta_j}{\partial x_i} = \sum_{k=1}^3 \frac{\partial\eta_j}{\partial\xi_k}\frac{\partial\xi_k}{\partial x_i} \]

These derivatives can be found on p152 of Sherwin & Karniadakis.

Parameters
dirDirection in which to take the derivative.
inarrayThe function \( u \).
outarrayValue of the inner product.

Reimplemented from Nektar::StdRegions::StdPrismExp.

Definition at line 331 of file PrismExp.cpp.

334{
335 v_IProductWRTDerivBase_SumFac(dir, inarray, outarray);
336}
Nektar::LocalRegions::PrismExp::v_IProductWRTDerivBase_SumFac
void v_IProductWRTDerivBase_SumFac(const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) override
Definition: PrismExp.cpp:338

References v_IProductWRTDerivBase_SumFac().

◆ v_IProductWRTDerivBase_SumFac()

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

Reimplemented from Nektar::StdRegions::StdPrismExp.

Definition at line 338 of file PrismExp.cpp.

341{
342 const int nquad0 = m_base[0]->GetNumPoints();
343 const int nquad1 = m_base[1]->GetNumPoints();
344 const int nquad2 = m_base[2]->GetNumPoints();
345 const int order0 = m_base[0]->GetNumModes();
346 const int order1 = m_base[1]->GetNumModes();
347 const int nqtot = nquad0 * nquad1 * nquad2;
348
349 Array<OneD, NekDouble> tmp1(nqtot);
350 Array<OneD, NekDouble> tmp2(nqtot);
351 Array<OneD, NekDouble> tmp3(nqtot);
352 Array<OneD, NekDouble> tmp4(nqtot);
353 Array<OneD, NekDouble> tmp6(m_ncoeffs);
354 Array<OneD, NekDouble> wsp(order0 * nquad2 * (nquad1 + order1));
355
356 MultiplyByQuadratureMetric(inarray, tmp1);
357
358 Array<OneD, Array<OneD, NekDouble>> tmp2D{3};
359 tmp2D[0] = tmp2;
360 tmp2D[1] = tmp3;
361 tmp2D[2] = tmp4;
362
363 PrismExp::v_AlignVectorToCollapsedDir(dir, tmp1, tmp2D);
364
365 IProductWRTBase_SumFacKernel(m_base[0]->GetDbdata(), m_base[1]->GetBdata(),
366 m_base[2]->GetBdata(), tmp2, outarray, wsp,
367 true, true, true);
368
369 IProductWRTBase_SumFacKernel(m_base[0]->GetBdata(), m_base[1]->GetDbdata(),
370 m_base[2]->GetBdata(), tmp3, tmp6, wsp, true,
371 true, true);
372
373 Vmath::Vadd(m_ncoeffs, tmp6, 1, outarray, 1, outarray, 1);
374
375 IProductWRTBase_SumFacKernel(m_base[0]->GetBdata(), m_base[1]->GetBdata(),
376 m_base[2]->GetDbdata(), tmp4, tmp6, wsp, true,
377 true, true);
378
379 Vmath::Vadd(m_ncoeffs, tmp6, 1, outarray, 1, outarray, 1);
380}
Nektar::LocalRegions::PrismExp::v_AlignVectorToCollapsedDir
virtual void v_AlignVectorToCollapsedDir(const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray) override
Definition: PrismExp.cpp:382

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

Referenced by v_IProductWRTDerivBase().

◆ v_LaplacianMatrixOp() [1/2]

void Nektar::LocalRegions::PrismExp::v_LaplacianMatrixOp ( const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray,
const StdRegions::StdMatrixKey &  mkey 
)
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 998 of file PrismExp.cpp.

1001{
1002 PrismExp::LaplacianMatrixOp_MatFree(inarray, outarray, mkey);
1003}
Nektar::StdRegions::StdExpansion::LaplacianMatrixOp_MatFree
void LaplacianMatrixOp_MatFree(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
Definition: StdExpansion.h:1247

References Nektar::StdRegions::StdExpansion::LaplacianMatrixOp_MatFree().

◆ v_LaplacianMatrixOp() [2/2]

void Nektar::LocalRegions::PrismExp::v_LaplacianMatrixOp ( const int  k1,
const int  k2,
const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray,
const StdRegions::StdMatrixKey &  mkey 
)
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 1005 of file PrismExp.cpp.

1009{
1010 StdExpansion::LaplacianMatrixOp_MatFree(k1, k2, inarray, outarray, mkey);
1011}

◆ v_LaplacianMatrixOp_MatFree_Kernel()

void Nektar::LocalRegions::PrismExp::v_LaplacianMatrixOp_MatFree_Kernel ( const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray,
Array< OneD, NekDouble > &  wsp 
)
overrideprivatevirtual

Calculate the Laplacian multiplication in a matrix-free manner.

This function is the kernel of the Laplacian matrix-free operator, and is used in v_HelmholtzMatrixOp_MatFree to determine the effect of the Helmholtz operator in a similar fashion.

The majority of the calculation is precisely the same as in the hexahedral expansion; however the collapsed co-ordinate system must be taken into account when constructing the geometric factors. How this is done is detailed more exactly in the tetrahedral expansion. On entry to this function, the input #inarray must be in its backwards-transformed state (i.e. \(\mathbf{u} = \mathbf{B}\hat{\mathbf{u}}\)). The output is in coefficient space.

See also
TetExp::v_HelmholtzMatrixOp_MatFree

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 1125 of file PrismExp.cpp.

1128{
1129 int nquad0 = m_base[0]->GetNumPoints();
1130 int nquad1 = m_base[1]->GetNumPoints();
1131 int nquad2 = m_base[2]->GetNumPoints();
1132 int nqtot = nquad0 * nquad1 * nquad2;
1133 int i;
1134
1135 // Set up temporary storage.
1136 Array<OneD, NekDouble> alloc(11 * nqtot, 0.0);
1137 Array<OneD, NekDouble> wsp1(alloc); // TensorDeriv 1
1138 Array<OneD, NekDouble> wsp2(alloc + 1 * nqtot); // TensorDeriv 2
1139 Array<OneD, NekDouble> wsp3(alloc + 2 * nqtot); // TensorDeriv 3
1140 Array<OneD, NekDouble> g0(alloc + 3 * nqtot); // g0
1141 Array<OneD, NekDouble> g1(alloc + 4 * nqtot); // g1
1142 Array<OneD, NekDouble> g2(alloc + 5 * nqtot); // g2
1143 Array<OneD, NekDouble> g3(alloc + 6 * nqtot); // g3
1144 Array<OneD, NekDouble> g4(alloc + 7 * nqtot); // g4
1145 Array<OneD, NekDouble> g5(alloc + 8 * nqtot); // g5
1146 Array<OneD, NekDouble> h0(alloc + 3 * nqtot); // h0 == g0
1147 Array<OneD, NekDouble> h1(alloc + 6 * nqtot); // h1 == g3
1148 Array<OneD, NekDouble> wsp4(alloc + 4 * nqtot); // wsp4 == g1
1149 Array<OneD, NekDouble> wsp5(alloc + 5 * nqtot); // wsp5 == g2
1150 Array<OneD, NekDouble> wsp6(alloc + 8 * nqtot); // wsp6 == g5
1151 Array<OneD, NekDouble> wsp7(alloc + 3 * nqtot); // wsp7 == g0
1152 Array<OneD, NekDouble> wsp8(alloc + 9 * nqtot); // wsp8
1153 Array<OneD, NekDouble> wsp9(alloc + 10 * nqtot); // wsp9
1154
1155 const Array<OneD, const NekDouble> &base0 = m_base[0]->GetBdata();
1156 const Array<OneD, const NekDouble> &base1 = m_base[1]->GetBdata();
1157 const Array<OneD, const NekDouble> &base2 = m_base[2]->GetBdata();
1158 const Array<OneD, const NekDouble> &dbase0 = m_base[0]->GetDbdata();
1159 const Array<OneD, const NekDouble> &dbase1 = m_base[1]->GetDbdata();
1160 const Array<OneD, const NekDouble> &dbase2 = m_base[2]->GetDbdata();
1161
1162 // Step 1. LAPLACIAN MATRIX OPERATION
1163 // wsp1 = du_dxi1 = D_xi1 * wsp0 = D_xi1 * u
1164 // wsp2 = du_dxi2 = D_xi2 * wsp0 = D_xi2 * u
1165 // wsp3 = du_dxi3 = D_xi3 * wsp0 = D_xi3 * u
1166 StdExpansion3D::PhysTensorDeriv(inarray, wsp1, wsp2, wsp3);
1167
1168 const Array<TwoD, const NekDouble> &df =
1169 m_metricinfo->GetDerivFactors(GetPointsKeys());
1170 const Array<OneD, const NekDouble> &z0 = m_base[0]->GetZ();
1171 const Array<OneD, const NekDouble> &z2 = m_base[2]->GetZ();
1172
1173 // Step 2. Calculate the metric terms of the collapsed
1174 // coordinate transformation (Spencer's book P152)
1175 for (i = 0; i < nquad2; ++i)
1176 {
1177 Vmath::Fill(nquad0 * nquad1, 2.0 / (1.0 - z2[i]),
1178 &h0[0] + i * nquad0 * nquad1, 1);
1179 Vmath::Fill(nquad0 * nquad1, 2.0 / (1.0 - z2[i]),
1180 &h1[0] + i * nquad0 * nquad1, 1);
1181 }
1182 for (i = 0; i < nquad0; i++)
1183 {
1184 Blas::Dscal(nquad1 * nquad2, 0.5 * (1 + z0[i]), &h1[0] + i, nquad0);
1185 }
1186
1187 // Step 3. Construct combined metric terms for physical space to
1188 // collapsed coordinate system. Order of construction optimised
1189 // to minimise temporary storage
1190 if (m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
1191 {
1192 // wsp4 = d eta_1/d x_1
1193 Vmath::Vvtvvtp(nqtot, &df[0][0], 1, &h0[0], 1, &df[2][0], 1, &h1[0], 1,
1194 &wsp4[0], 1);
1195 // wsp5 = d eta_2/d x_1
1196 Vmath::Vvtvvtp(nqtot, &df[3][0], 1, &h0[0], 1, &df[5][0], 1, &h1[0], 1,
1197 &wsp5[0], 1);
1198 // wsp6 = d eta_3/d x_1d
1199 Vmath::Vvtvvtp(nqtot, &df[6][0], 1, &h0[0], 1, &df[8][0], 1, &h1[0], 1,
1200 &wsp6[0], 1);
1201
1202 // g0 (overwrites h0)
1203 Vmath::Vvtvvtp(nqtot, &wsp4[0], 1, &wsp4[0], 1, &wsp5[0], 1, &wsp5[0],
1204 1, &g0[0], 1);
1205 Vmath::Vvtvp(nqtot, &wsp6[0], 1, &wsp6[0], 1, &g0[0], 1, &g0[0], 1);
1206
1207 // g3 (overwrites h1)
1208 Vmath::Vvtvvtp(nqtot, &df[1][0], 1, &wsp4[0], 1, &df[4][0], 1, &wsp5[0],
1209 1, &g3[0], 1);
1210 Vmath::Vvtvp(nqtot, &df[7][0], 1, &wsp6[0], 1, &g3[0], 1, &g3[0], 1);
1211
1212 // g4
1213 Vmath::Vvtvvtp(nqtot, &df[2][0], 1, &wsp4[0], 1, &df[5][0], 1, &wsp5[0],
1214 1, &g4[0], 1);
1215 Vmath::Vvtvp(nqtot, &df[8][0], 1, &wsp6[0], 1, &g4[0], 1, &g4[0], 1);
1216
1217 // Overwrite wsp4/5/6 with g1/2/5
1218 // g1
1219 Vmath::Vvtvvtp(nqtot, &df[1][0], 1, &df[1][0], 1, &df[4][0], 1,
1220 &df[4][0], 1, &g1[0], 1);
1221 Vmath::Vvtvp(nqtot, &df[7][0], 1, &df[7][0], 1, &g1[0], 1, &g1[0], 1);
1222
1223 // g2
1224 Vmath::Vvtvvtp(nqtot, &df[2][0], 1, &df[2][0], 1, &df[5][0], 1,
1225 &df[5][0], 1, &g2[0], 1);
1226 Vmath::Vvtvp(nqtot, &df[8][0], 1, &df[8][0], 1, &g2[0], 1, &g2[0], 1);
1227
1228 // g5
1229 Vmath::Vvtvvtp(nqtot, &df[1][0], 1, &df[2][0], 1, &df[4][0], 1,
1230 &df[5][0], 1, &g5[0], 1);
1231 Vmath::Vvtvp(nqtot, &df[7][0], 1, &df[8][0], 1, &g5[0], 1, &g5[0], 1);
1232 }
1233 else
1234 {
1235 // wsp4 = d eta_1/d x_1
1236 Vmath::Svtsvtp(nqtot, df[0][0], &h0[0], 1, df[2][0], &h1[0], 1,
1237 &wsp4[0], 1);
1238 // wsp5 = d eta_2/d x_1
1239 Vmath::Svtsvtp(nqtot, df[3][0], &h0[0], 1, df[5][0], &h1[0], 1,
1240 &wsp5[0], 1);
1241 // wsp6 = d eta_3/d x_1
1242 Vmath::Svtsvtp(nqtot, df[6][0], &h0[0], 1, df[8][0], &h1[0], 1,
1243 &wsp6[0], 1);
1244
1245 // g0 (overwrites h0)
1246 Vmath::Vvtvvtp(nqtot, &wsp4[0], 1, &wsp4[0], 1, &wsp5[0], 1, &wsp5[0],
1247 1, &g0[0], 1);
1248 Vmath::Vvtvp(nqtot, &wsp6[0], 1, &wsp6[0], 1, &g0[0], 1, &g0[0], 1);
1249
1250 // g3 (overwrites h1)
1251 Vmath::Svtsvtp(nqtot, df[1][0], &wsp4[0], 1, df[4][0], &wsp5[0], 1,
1252 &g3[0], 1);
1253 Vmath::Svtvp(nqtot, df[7][0], &wsp6[0], 1, &g3[0], 1, &g3[0], 1);
1254
1255 // g4
1256 Vmath::Svtsvtp(nqtot, df[2][0], &wsp4[0], 1, df[5][0], &wsp5[0], 1,
1257 &g4[0], 1);
1258 Vmath::Svtvp(nqtot, df[8][0], &wsp6[0], 1, &g4[0], 1, &g4[0], 1);
1259
1260 // Overwrite wsp4/5/6 with g1/2/5
1261 // g1
1262 Vmath::Fill(nqtot,
1263 df[1][0] * df[1][0] + df[4][0] * df[4][0] +
1264 df[7][0] * df[7][0],
1265 &g1[0], 1);
1266
1267 // g2
1268 Vmath::Fill(nqtot,
1269 df[2][0] * df[2][0] + df[5][0] * df[5][0] +
1270 df[8][0] * df[8][0],
1271 &g2[0], 1);
1272
1273 // g5
1274 Vmath::Fill(nqtot,
1275 df[1][0] * df[2][0] + df[4][0] * df[5][0] +
1276 df[7][0] * df[8][0],
1277 &g5[0], 1);
1278 }
1279 // Compute component derivatives into wsp7, 8, 9 (wsp7 overwrites
1280 // g0).
1281 Vmath::Vvtvvtp(nqtot, &g0[0], 1, &wsp1[0], 1, &g3[0], 1, &wsp2[0], 1,
1282 &wsp7[0], 1);
1283 Vmath::Vvtvp(nqtot, &g4[0], 1, &wsp3[0], 1, &wsp7[0], 1, &wsp7[0], 1);
1284 Vmath::Vvtvvtp(nqtot, &g1[0], 1, &wsp2[0], 1, &g3[0], 1, &wsp1[0], 1,
1285 &wsp8[0], 1);
1286 Vmath::Vvtvp(nqtot, &g5[0], 1, &wsp3[0], 1, &wsp8[0], 1, &wsp8[0], 1);
1287 Vmath::Vvtvvtp(nqtot, &g2[0], 1, &wsp3[0], 1, &g4[0], 1, &wsp1[0], 1,
1288 &wsp9[0], 1);
1289 Vmath::Vvtvp(nqtot, &g5[0], 1, &wsp2[0], 1, &wsp9[0], 1, &wsp9[0], 1);
1290
1291 // Step 4.
1292 // Multiply by quadrature metric
1293 MultiplyByQuadratureMetric(wsp7, wsp7);
1294 MultiplyByQuadratureMetric(wsp8, wsp8);
1295 MultiplyByQuadratureMetric(wsp9, wsp9);
1296
1297 // Perform inner product w.r.t derivative bases.
1298 IProductWRTBase_SumFacKernel(dbase0, base1, base2, wsp7, wsp1, wsp, false,
1299 true, true);
1300 IProductWRTBase_SumFacKernel(base0, dbase1, base2, wsp8, wsp2, wsp, true,
1301 false, true);
1302 IProductWRTBase_SumFacKernel(base0, base1, dbase2, wsp9, outarray, wsp,
1303 true, true, false);
1304
1305 // Step 5.
1306 // Sum contributions from wsp1, wsp2 and outarray.
1307 Vmath::Vadd(m_ncoeffs, wsp1.get(), 1, outarray.get(), 1, outarray.get(), 1);
1308 Vmath::Vadd(m_ncoeffs, wsp2.get(), 1, outarray.get(), 1, outarray.get(), 1);
1309}
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:151
Vmath::Svtsvtp
void Svtsvtp(int n, const T alpha, const T *x, int incx, const T beta, const T *y, int incy, T *z, int incz)
svtvvtp (scalar times vector plus scalar times vector):
Definition: Vmath.cpp:746
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:617
Vmath::Vvtvvtp
void Vvtvvtp(int n, const T *v, int incv, const T *w, int incw, const T *x, int incx, const T *y, int incy, T *z, int incz)
vvtvvtp (vector times vector plus vector times vector):
Definition: Vmath.cpp:687

References Blas::Dscal(), Nektar::SpatialDomains::eDeformed, Vmath::Fill(), Nektar::StdRegions::StdExpansion::GetPointsKeys(), Nektar::StdRegions::StdExpansion3D::IProductWRTBase_SumFacKernel(), Nektar::StdRegions::StdExpansion::m_base, Nektar::LocalRegions::Expansion::m_metricinfo, Nektar::StdRegions::StdExpansion::m_ncoeffs, Nektar::StdRegions::StdExpansion::MultiplyByQuadratureMetric(), Vmath::Svtsvtp(), Vmath::Svtvp(), Vmath::Vadd(), Vmath::Vvtvp(), and Vmath::Vvtvvtp().

◆ v_MassMatrixOp()

void Nektar::LocalRegions::PrismExp::v_MassMatrixOp ( const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray,
const StdRegions::StdMatrixKey &  mkey 
)
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 991 of file PrismExp.cpp.

994{
995 StdExpansion::MassMatrixOp_MatFree(inarray, outarray, mkey);
996}

◆ v_NormalTraceDerivFactors()

void Nektar::LocalRegions::PrismExp::v_NormalTraceDerivFactors ( Array< OneD, Array< OneD, NekDouble > > &  d0factors,
Array< OneD, Array< OneD, NekDouble > > &  d1factors,
Array< OneD, Array< OneD, NekDouble > > &  d2factors 
)
overrideprotectedvirtual

: This method gets all of the factors which are required as part of the Gradient Jump Penalty stabilisation and involves the product of the normal and geometric factors along the element trace.

Reimplemented from Nektar::LocalRegions::Expansion.

Definition at line 1557 of file PrismExp.cpp.

1561{
1562 int nquad0 = GetNumPoints(0);
1563 int nquad1 = GetNumPoints(1);
1564 int nquad2 = GetNumPoints(2);
1565
1566 const Array<TwoD, const NekDouble> &df =
1567 m_metricinfo->GetDerivFactors(GetPointsKeys());
1568
1569 if (d0factors.size() != 5)
1570 {
1571 d0factors = Array<OneD, Array<OneD, NekDouble>>(5);
1572 d1factors = Array<OneD, Array<OneD, NekDouble>>(5);
1573 d2factors = Array<OneD, Array<OneD, NekDouble>>(5);
1574 }
1575
1576 if (d0factors[0].size() != nquad0 * nquad1)
1577 {
1578 d0factors[0] = Array<OneD, NekDouble>(nquad0 * nquad1);
1579 d1factors[0] = Array<OneD, NekDouble>(nquad0 * nquad1);
1580 d2factors[0] = Array<OneD, NekDouble>(nquad0 * nquad1);
1581 }
1582
1583 if (d0factors[1].size() != nquad0 * nquad2)
1584 {
1585 d0factors[1] = Array<OneD, NekDouble>(nquad0 * nquad2);
1586 d0factors[3] = Array<OneD, NekDouble>(nquad0 * nquad2);
1587 d1factors[1] = Array<OneD, NekDouble>(nquad0 * nquad2);
1588 d1factors[3] = Array<OneD, NekDouble>(nquad0 * nquad2);
1589 d2factors[1] = Array<OneD, NekDouble>(nquad0 * nquad2);
1590 d2factors[3] = Array<OneD, NekDouble>(nquad0 * nquad2);
1591 }
1592
1593 if (d0factors[2].size() != nquad1 * nquad2)
1594 {
1595 d0factors[2] = Array<OneD, NekDouble>(nquad1 * nquad2);
1596 d0factors[4] = Array<OneD, NekDouble>(nquad1 * nquad2);
1597 d1factors[2] = Array<OneD, NekDouble>(nquad1 * nquad2);
1598 d1factors[4] = Array<OneD, NekDouble>(nquad1 * nquad2);
1599 d2factors[2] = Array<OneD, NekDouble>(nquad1 * nquad2);
1600 d2factors[4] = Array<OneD, NekDouble>(nquad1 * nquad2);
1601 }
1602
1603 // Outwards normals
1604 const Array<OneD, const Array<OneD, NekDouble>> &normal_0 =
1605 GetTraceNormal(0);
1606 const Array<OneD, const Array<OneD, NekDouble>> &normal_1 =
1607 GetTraceNormal(1);
1608 const Array<OneD, const Array<OneD, NekDouble>> &normal_2 =
1609 GetTraceNormal(2);
1610 const Array<OneD, const Array<OneD, NekDouble>> &normal_3 =
1611 GetTraceNormal(3);
1612 const Array<OneD, const Array<OneD, NekDouble>> &normal_4 =
1613 GetTraceNormal(4);
1614
1615 int ncoords = normal_0.size();
1616
1617 // first gather together standard cartesian inner products
1618 if (m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
1619 {
1620 // face 0
1621 for (int i = 0; i < nquad0 * nquad1; ++i)
1622 {
1623 d0factors[0][i] = df[0][i] * normal_0[0][i];
1624 d1factors[0][i] = df[1][i] * normal_0[0][i];
1625 d2factors[0][i] = df[2][i] * normal_0[0][i];
1626 }
1627
1628 for (int n = 1; n < ncoords; ++n)
1629 {
1630 for (int i = 0; i < nquad0 * nquad1; ++i)
1631 {
1632 d0factors[0][i] += df[3 * n][i] * normal_0[n][i];
1633 d1factors[0][i] += df[3 * n + 1][i] * normal_0[n][i];
1634 d2factors[0][i] += df[3 * n + 2][i] * normal_0[n][i];
1635 }
1636 }
1637
1638 // faces 1 and 3
1639 for (int j = 0; j < nquad2; ++j)
1640 {
1641 for (int i = 0; i < nquad0; ++i)
1642 {
1643 d0factors[1][j * nquad0 + i] = df[0][j * nquad0 * nquad1 + i] *
1644 normal_1[0][j * nquad0 + i];
1645 d1factors[1][j * nquad0 + i] = df[1][j * nquad0 * nquad1 + i] *
1646 normal_1[0][j * nquad0 + i];
1647 d2factors[1][j * nquad0 + i] = df[2][j * nquad0 * nquad1 + i] *
1648 normal_1[0][j * nquad0 + i];
1649
1650 d0factors[3][j * nquad0 + i] =
1651 df[0][(j + 1) * nquad0 * nquad1 - nquad0 + i] *
1652 normal_3[0][j * nquad0 + i];
1653 d1factors[3][j * nquad0 + i] =
1654 df[1][(j + 1) * nquad0 * nquad1 - nquad0 + i] *
1655 normal_3[0][j * nquad0 + i];
1656 d2factors[3][j * nquad0 + i] =
1657 df[2][(j + 1) * nquad0 * nquad1 - nquad0 + i] *
1658 normal_3[0][j * nquad0 + i];
1659 }
1660 }
1661
1662 for (int n = 1; n < ncoords; ++n)
1663 {
1664 for (int j = 0; j < nquad2; ++j)
1665 {
1666 for (int i = 0; i < nquad0; ++i)
1667 {
1668 d0factors[1][j * nquad0 + i] +=
1669 df[3 * n][j * nquad0 * nquad1 + i] *
1670 normal_1[n][j * nquad0 + i];
1671 d1factors[1][j * nquad0 + i] +=
1672 df[3 * n + 1][j * nquad0 * nquad1 + i] *
1673 normal_1[n][j * nquad0 + i];
1674 d2factors[1][j * nquad0 + i] +=
1675 df[3 * n + 2][j * nquad0 * nquad1 + i] *
1676 normal_1[n][j * nquad0 + i];
1677
1678 d0factors[3][j * nquad0 + i] +=
1679 df[3 * n][(j + 1) * nquad0 * nquad1 - nquad0 + i] *
1680 normal_3[n][j * nquad0 + i];
1681 d1factors[3][j * nquad0 + i] +=
1682 df[3 * n + 1][(j + 1) * nquad0 * nquad1 - nquad0 + i] *
1683 normal_3[n][j * nquad0 + i];
1684 d2factors[3][j * nquad0 + i] +=
1685 df[3 * n + 2][(j + 1) * nquad0 * nquad1 - nquad0 + i] *
1686 normal_3[n][j * nquad0 + i];
1687 }
1688 }
1689 }
1690
1691 // faces 2 and 4
1692 for (int j = 0; j < nquad2; ++j)
1693 {
1694 for (int i = 0; i < nquad1; ++i)
1695 {
1696 d0factors[2][j * nquad1 + i] =
1697 df[0][j * nquad0 * nquad1 + (i + 1) * nquad0 - 1] *
1698 normal_2[0][j * nquad1 + i];
1699 d1factors[2][j * nquad1 + i] =
1700 df[1][j * nquad0 * nquad1 + (i + 1) * nquad0 - 1] *
1701 normal_2[0][j * nquad1 + i];
1702 d2factors[2][j * nquad1 + i] =
1703 df[2][j * nquad0 * nquad1 + (i + 1) * nquad0 - 1] *
1704 normal_2[0][j * nquad1 + i];
1705
1706 d0factors[4][j * nquad1 + i] =
1707 df[0][j * nquad0 * nquad1 + i * nquad0] *
1708 normal_4[0][j * nquad1 + i];
1709 d1factors[4][j * nquad1 + i] =
1710 df[1][j * nquad0 * nquad1 + i * nquad0] *
1711 normal_4[0][j * nquad1 + i];
1712 d2factors[4][j * nquad1 + i] =
1713 df[2][j * nquad0 * nquad1 + i * nquad0] *
1714 normal_4[0][j * nquad1 + i];
1715 }
1716 }
1717
1718 for (int n = 1; n < ncoords; ++n)
1719 {
1720 for (int j = 0; j < nquad2; ++j)
1721 {
1722 for (int i = 0; i < nquad1; ++i)
1723 {
1724 d0factors[2][j * nquad1 + i] +=
1725 df[3 * n][j * nquad0 * nquad1 + (i + 1) * nquad0 - 1] *
1726 normal_2[n][j * nquad1 + i];
1727 d1factors[2][j * nquad1 + i] +=
1728 df[3 * n + 1]
1729 [j * nquad0 * nquad1 + (i + 1) * nquad0 - 1] *
1730 normal_2[n][j * nquad1 + i];
1731 d2factors[2][j * nquad1 + i] +=
1732 df[3 * n + 2]
1733 [j * nquad0 * nquad1 + (i + 1) * nquad0 - 1] *
1734 normal_2[n][j * nquad1 + i];
1735
1736 d0factors[4][j * nquad1 + i] +=
1737 df[3 * n][j * nquad0 * nquad1 + i * nquad0] *
1738 normal_4[n][j * nquad1 + i];
1739 d1factors[4][j * nquad1 + i] +=
1740 df[3 * n + 1][j * nquad0 * nquad1 + i * nquad0] *
1741 normal_4[n][j * nquad1 + i];
1742 d2factors[4][j * nquad1 + i] +=
1743 df[3 * n + 2][j * nquad0 * nquad1 + i * nquad0] *
1744 normal_4[n][j * nquad1 + i];
1745 }
1746 }
1747 }
1748 }
1749 else
1750 {
1751 // Face 0
1752 for (int i = 0; i < nquad0 * nquad1; ++i)
1753 {
1754 d0factors[0][i] = df[0][0] * normal_0[0][i];
1755 d1factors[0][i] = df[1][0] * normal_0[0][i];
1756 d2factors[0][i] = df[2][0] * normal_0[0][i];
1757 }
1758
1759 for (int n = 1; n < ncoords; ++n)
1760 {
1761 for (int i = 0; i < nquad0 * nquad1; ++i)
1762 {
1763 d0factors[0][i] += df[3 * n][0] * normal_0[n][i];
1764 d1factors[0][i] += df[3 * n + 1][0] * normal_0[n][i];
1765 d2factors[0][i] += df[3 * n + 2][0] * normal_0[n][i];
1766 }
1767 }
1768
1769 // faces 1 and 3
1770 for (int i = 0; i < nquad0 * nquad2; ++i)
1771 {
1772 d0factors[1][i] = df[0][0] * normal_1[0][i];
1773 d0factors[3][i] = df[0][0] * normal_3[0][i];
1774
1775 d1factors[1][i] = df[1][0] * normal_1[0][i];
1776 d1factors[3][i] = df[1][0] * normal_3[0][i];
1777
1778 d2factors[1][i] = df[2][0] * normal_1[0][i];
1779 d2factors[3][i] = df[2][0] * normal_3[0][i];
1780 }
1781
1782 for (int n = 1; n < ncoords; ++n)
1783 {
1784 for (int i = 0; i < nquad0 * nquad2; ++i)
1785 {
1786 d0factors[1][i] += df[3 * n][0] * normal_1[n][i];
1787 d0factors[3][i] += df[3 * n][0] * normal_3[n][i];
1788
1789 d1factors[1][i] += df[3 * n + 1][0] * normal_1[n][i];
1790 d1factors[3][i] += df[3 * n + 1][0] * normal_3[n][i];
1791
1792 d2factors[1][i] += df[3 * n + 2][0] * normal_1[n][i];
1793 d2factors[3][i] += df[3 * n + 2][0] * normal_3[n][i];
1794 }
1795 }
1796
1797 // faces 2 and 4
1798 for (int i = 0; i < nquad1 * nquad2; ++i)
1799 {
1800 d0factors[2][i] = df[0][0] * normal_2[0][i];
1801 d0factors[4][i] = df[0][0] * normal_4[0][i];
1802
1803 d1factors[2][i] = df[1][0] * normal_2[0][i];
1804 d1factors[4][i] = df[1][0] * normal_4[0][i];
1805
1806 d2factors[2][i] = df[2][0] * normal_2[0][i];
1807 d2factors[4][i] = df[2][0] * normal_4[0][i];
1808 }
1809
1810 for (int n = 1; n < ncoords; ++n)
1811 {
1812 for (int i = 0; i < nquad1 * nquad2; ++i)
1813 {
1814 d0factors[2][i] += df[3 * n][0] * normal_2[n][i];
1815 d0factors[4][i] += df[3 * n][0] * normal_4[n][i];
1816
1817 d1factors[2][i] += df[3 * n + 1][0] * normal_2[n][i];
1818 d1factors[4][i] += df[3 * n + 1][0] * normal_4[n][i];
1819
1820 d2factors[2][i] += df[3 * n + 2][0] * normal_2[n][i];
1821 d2factors[4][i] += df[3 * n + 2][0] * normal_4[n][i];
1822 }
1823 }
1824 }
1825}
Nektar::LocalRegions::Expansion::GetTraceNormal
const NormalVector & GetTraceNormal(const int id)
Definition: Expansion.cpp:255

References Nektar::SpatialDomains::eDeformed, Nektar::StdRegions::StdExpansion::GetNumPoints(), Nektar::StdRegions::StdExpansion::GetPointsKeys(), Nektar::LocalRegions::Expansion::GetTraceNormal(), and Nektar::LocalRegions::Expansion::m_metricinfo.

◆ v_PhysDeriv()

void Nektar::LocalRegions::PrismExp::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::StdPrismExp.

Definition at line 127 of file PrismExp.cpp.

131{
132 int nqtot = GetTotPoints();
133
134 Array<TwoD, const NekDouble> df =
135 m_metricinfo->GetDerivFactors(GetPointsKeys());
136 Array<OneD, NekDouble> diff0(nqtot);
137 Array<OneD, NekDouble> diff1(nqtot);
138 Array<OneD, NekDouble> diff2(nqtot);
139
140 StdPrismExp::v_PhysDeriv(inarray, diff0, diff1, diff2);
141
142 if (m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
143 {
144 if (out_d0.size())
145 {
146 Vmath::Vmul(nqtot, &df[0][0], 1, &diff0[0], 1, &out_d0[0], 1);
147 Vmath::Vvtvp(nqtot, &df[1][0], 1, &diff1[0], 1, &out_d0[0], 1,
148 &out_d0[0], 1);
149 Vmath::Vvtvp(nqtot, &df[2][0], 1, &diff2[0], 1, &out_d0[0], 1,
150 &out_d0[0], 1);
151 }
152
153 if (out_d1.size())
154 {
155 Vmath::Vmul(nqtot, &df[3][0], 1, &diff0[0], 1, &out_d1[0], 1);
156 Vmath::Vvtvp(nqtot, &df[4][0], 1, &diff1[0], 1, &out_d1[0], 1,
157 &out_d1[0], 1);
158 Vmath::Vvtvp(nqtot, &df[5][0], 1, &diff2[0], 1, &out_d1[0], 1,
159 &out_d1[0], 1);
160 }
161
162 if (out_d2.size())
163 {
164 Vmath::Vmul(nqtot, &df[6][0], 1, &diff0[0], 1, &out_d2[0], 1);
165 Vmath::Vvtvp(nqtot, &df[7][0], 1, &diff1[0], 1, &out_d2[0], 1,
166 &out_d2[0], 1);
167 Vmath::Vvtvp(nqtot, &df[8][0], 1, &diff2[0], 1, &out_d2[0], 1,
168 &out_d2[0], 1);
169 }
170 }
171 else // regular geometry
172 {
173 if (out_d0.size())
174 {
175 Vmath::Smul(nqtot, df[0][0], &diff0[0], 1, &out_d0[0], 1);
176 Blas::Daxpy(nqtot, df[1][0], &diff1[0], 1, &out_d0[0], 1);
177 Blas::Daxpy(nqtot, df[2][0], &diff2[0], 1, &out_d0[0], 1);
178 }
179
180 if (out_d1.size())
181 {
182 Vmath::Smul(nqtot, df[3][0], &diff0[0], 1, &out_d1[0], 1);
183 Blas::Daxpy(nqtot, df[4][0], &diff1[0], 1, &out_d1[0], 1);
184 Blas::Daxpy(nqtot, df[5][0], &diff2[0], 1, &out_d1[0], 1);
185 }
186
187 if (out_d2.size())
188 {
189 Vmath::Smul(nqtot, df[6][0], &diff0[0], 1, &out_d2[0], 1);
190 Blas::Daxpy(nqtot, df[7][0], &diff1[0], 1, &out_d2[0], 1);
191 Blas::Daxpy(nqtot, df[8][0], &diff2[0], 1, &out_d2[0], 1);
192 }
193 }
194}
Nektar::StdRegions::StdExpansion::GetTotPoints
int GetTotPoints() const
This function returns the total number of quadrature points used in the element.
Definition: StdExpansion.h:140
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:137

References Blas::Daxpy(), Nektar::SpatialDomains::eDeformed, Nektar::StdRegions::StdExpansion::GetPointsKeys(), Nektar::StdRegions::StdExpansion::GetTotPoints(), Nektar::LocalRegions::Expansion::m_metricinfo, Vmath::Smul(), Vmath::Vmul(), and Vmath::Vvtvp().

◆ v_PhysEvaluate() [1/2]

NekDouble Nektar::LocalRegions::PrismExp::v_PhysEvaluate ( const Array< OneD, const NekDouble > &  coords,
const Array< OneD, const NekDouble > &  physvals 
)
overrideprotectedvirtual

This function evaluates the expansion at a single (arbitrary) point of the domain.

Based on the value of the expansion at the quadrature points, this function calculates the value of the expansion at an arbitrary single points (with coordinates \( \mathbf{x_c}\) given by the pointer coords). This operation, equivalent to

\[ u(\mathbf{x_c}) = \sum_p \phi_p(\mathbf{x_c}) \hat{u}_p \]

is evaluated using Lagrangian interpolants through the quadrature points:

\[ u(\mathbf{x_c}) = \sum_p h_p(\mathbf{x_c}) u_p\]

This function requires that the physical value array \(\mathbf{u}\) (implemented as the attribute #phys) is set.

Parameters
coordsthe coordinates of the single point
Returns
returns the value of the expansion at the single point

Reimplemented from Nektar::StdRegions::StdExpansion3D.

Definition at line 523 of file PrismExp.cpp.

525{
526 Array<OneD, NekDouble> Lcoord(3);
527
528 ASSERTL0(m_geom, "m_geom not defined");
529
530 m_geom->GetLocCoords(coord, Lcoord);
531
532 return StdExpansion3D::v_PhysEvaluate(Lcoord, physvals);
533}

References ASSERTL0, and Nektar::LocalRegions::Expansion::m_geom.

◆ v_PhysEvaluate() [2/2]

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

Reimplemented from Nektar::StdRegions::StdPrismExp.

Definition at line 535 of file PrismExp.cpp.

538{
539 Array<OneD, NekDouble> Lcoord(3);
540 ASSERTL0(m_geom, "m_geom not defined");
541 m_geom->GetLocCoords(coord, Lcoord);
542 return StdPrismExp::v_PhysEvaluate(Lcoord, inarray, firstOrderDerivs);
543}

References ASSERTL0, and Nektar::LocalRegions::Expansion::m_geom.

◆ v_StdPhysEvaluate()

NekDouble Nektar::LocalRegions::PrismExp::v_StdPhysEvaluate ( const Array< OneD, const NekDouble > &  Lcoord,
const Array< OneD, const NekDouble > &  physvals 
)
overrideprotectedvirtual

Given the local cartesian coordinate Lcoord evaluate the value of physvals at this point by calling through to the StdExpansion method

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 515 of file PrismExp.cpp.

518{
519 // Evaluate point in local (eta) coordinates.
520 return StdExpansion3D::v_PhysEvaluate(Lcoord, physvals);
521}

◆ v_SVVLaplacianFilter()

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

Reimplemented from Nektar::StdRegions::StdPrismExp.

Definition at line 1020 of file PrismExp.cpp.

1022{
1023 int nq = GetTotPoints();
1024
1025 // Calculate sqrt of the Jacobian
1026 Array<OneD, const NekDouble> jac = m_metricinfo->GetJac(GetPointsKeys());
1027 Array<OneD, NekDouble> sqrt_jac(nq);
1028 if (m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
1029 {
1030 Vmath::Vsqrt(nq, jac, 1, sqrt_jac, 1);
1031 }
1032 else
1033 {
1034 Vmath::Fill(nq, sqrt(jac[0]), sqrt_jac, 1);
1035 }
1036
1037 // Multiply array by sqrt(Jac)
1038 Vmath::Vmul(nq, sqrt_jac, 1, array, 1, array, 1);
1039
1040 // Apply std region filter
1041 StdPrismExp::v_SVVLaplacianFilter(array, mkey);
1042
1043 // Divide by sqrt(Jac)
1044 Vmath::Vdiv(nq, array, 1, sqrt_jac, 1, array, 1);
1045}
Vmath::Vdiv
void Vdiv(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:280

References Nektar::SpatialDomains::eDeformed, Vmath::Fill(), Nektar::StdRegions::StdExpansion::GetPointsKeys(), Nektar::StdRegions::StdExpansion::GetTotPoints(), Nektar::LocalRegions::Expansion::m_metricinfo, tinysimd::sqrt(), Vmath::Vdiv(), Vmath::Vmul(), and Vmath::Vsqrt().

Member Data Documentation

◆ m_matrixManager

LibUtilities::NekManager<MatrixKey, DNekScalMat, MatrixKey::opLess> Nektar::LocalRegions::PrismExp::m_matrixManager
private

Definition at line 200 of file PrismExp.h.

Referenced by v_DropLocMatrix(), v_FwdTrans(), and v_GetLocMatrix().

◆ m_staticCondMatrixManager

LibUtilities::NekManager<MatrixKey, DNekScalBlkMat, MatrixKey::opLess> Nektar::LocalRegions::PrismExp::m_staticCondMatrixManager
private

Definition at line 202 of file PrismExp.h.

Referenced by v_DropLocStaticCondMatrix(), and v_GetLocStaticCondMatrix().

Generated on Wed Jan 31 2024 08:26:57 for Nektar++ by doxygen 1.9.4