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

#include <TriExp.h>

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

Public Member Functions

 TriExp (const LibUtilities::BasisKey &Ba, const LibUtilities::BasisKey &Bb, const SpatialDomains::Geometry2DSharedPtr &geom)
 Constructor using BasisKey class for quadrature points and order definition. More...
 
 TriExp (const TriExp &T)
 
 ~TriExp ()
 
- Public Member Functions inherited from Nektar::StdRegions::StdTriExp
 StdTriExp ()
 
 StdTriExp (const LibUtilities::BasisKey &Ba, const LibUtilities::BasisKey &Bb)
 
 StdTriExp (const StdTriExp &T)
 
 ~StdTriExp ()
 
- Public Member Functions inherited from Nektar::StdRegions::StdExpansion2D
 StdExpansion2D ()
 
 StdExpansion2D (int numcoeffs, const LibUtilities::BasisKey &Ba, const LibUtilities::BasisKey &Bb)
 
 StdExpansion2D (const StdExpansion2D &T)
 
virtual ~StdExpansion2D ()
 
void PhysTensorDeriv (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray_d0, Array< OneD, NekDouble > &outarray_d1)
 Calculate the 2D derivative in the local tensor/collapsed coordinate at the physical points. More...
 
NekDouble Integral (const Array< OneD, const NekDouble > &inarray, const Array< OneD, const NekDouble > &w0, const Array< OneD, const NekDouble > &w1)
 
void BwdTrans_SumFacKernel (const Array< OneD, const NekDouble > &base0, const Array< OneD, const NekDouble > &base1, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, Array< OneD, NekDouble > &wsp, bool doCheckCollDir0=true, bool doCheckCollDir1=true)
 
void IProductWRTBase_SumFacKernel (const Array< OneD, const NekDouble > &base0, const Array< OneD, const NekDouble > &base1, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, Array< OneD, NekDouble > &wsp, bool doCheckCollDir0=true, bool doCheckCollDir1=true)
 
- 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 (void) const
 
std::shared_ptr< StdExpansion > GetLinStdExp (void) const
 
int GetShapeDimension () const
 
bool IsBoundaryInteriorExpansion ()
 
bool IsNodalNonTensorialExp ()
 
void BwdTrans (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 This function performs the Backward transformation from coefficient space to physical space. More...
 
void FwdTrans (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 This function performs the Forward transformation from physical space to coefficient space. More...
 
void FwdTransBndConstrained (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
NekDouble Integral (const Array< OneD, const NekDouble > &inarray)
 This function integrates the specified function over the domain. More...
 
void FillMode (const int mode, Array< OneD, NekDouble > &outarray)
 This function fills the array outarray with the mode-th mode of the expansion. More...
 
void IProductWRTBase (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 this function calculates the inner product of a given function f with the different modes of the expansion More...
 
void IProductWRTBase (const Array< OneD, const NekDouble > &base, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, int coll_check)
 
void IProductWRTDerivBase (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
void IProductWRTDirectionalDerivBase (const Array< OneD, const NekDouble > &direction, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
int GetElmtId ()
 Get the element id of this expansion when used in a list by returning value of m_elmt_id. More...
 
void SetElmtId (const int id)
 Set the element id of this expansion when used in a list by returning value of m_elmt_id. More...
 
void GetCoords (Array< OneD, NekDouble > &coords_1, Array< OneD, NekDouble > &coords_2=NullNekDouble1DArray, Array< OneD, NekDouble > &coords_3=NullNekDouble1DArray)
 this function returns the physical coordinates of the quadrature points of the expansion More...
 
void GetCoord (const Array< OneD, const NekDouble > &Lcoord, Array< OneD, NekDouble > &coord)
 given the coordinates of a point of the element in the local collapsed coordinate system, this function calculates the physical coordinates of the point More...
 
DNekMatSharedPtr GetStdMatrix (const StdMatrixKey &mkey)
 
DNekBlkMatSharedPtr GetStdStaticCondMatrix (const StdMatrixKey &mkey)
 
void NormVectorIProductWRTBase (const Array< OneD, const NekDouble > &Fx, Array< OneD, NekDouble > &outarray)
 
void NormVectorIProductWRTBase (const Array< OneD, const NekDouble > &Fx, const Array< OneD, NekDouble > &Fy, Array< OneD, NekDouble > &outarray)
 
void NormVectorIProductWRTBase (const Array< OneD, const NekDouble > &Fx, const Array< OneD, const NekDouble > &Fy, const Array< OneD, const NekDouble > &Fz, Array< OneD, NekDouble > &outarray)
 
void NormVectorIProductWRTBase (const Array< OneD, const Array< OneD, NekDouble >> &Fvec, Array< OneD, NekDouble > &outarray)
 
DNekScalBlkMatSharedPtr GetLocStaticCondMatrix (const LocalRegions::MatrixKey &mkey)
 
void DropLocStaticCondMatrix (const LocalRegions::MatrixKey &mkey)
 
int CalcNumberOfCoefficients (const std::vector< unsigned int > &nummodes, int &modes_offset)
 
NekDouble StdPhysEvaluate (const Array< OneD, const NekDouble > &Lcoord, const Array< OneD, const NekDouble > &physvals)
 
int GetCoordim ()
 
void GetBoundaryMap (Array< OneD, unsigned int > &outarray)
 
void GetInteriorMap (Array< OneD, unsigned int > &outarray)
 
int GetVertexMap (const int localVertexId, bool useCoeffPacking=false)
 
void GetTraceToElementMap (const int tid, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray, Orientation traceOrient=eForwards, int P=-1, int Q=-1)
 
void GetTraceCoeffMap (const unsigned int traceid, Array< OneD, unsigned int > &maparray)
 
void GetElmtTraceToTraceMap (const unsigned int tid, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray, Orientation traceOrient=eForwards, int P=-1, int Q=-1)
 
void GetTraceInteriorToElementMap (const int tid, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray, const Orientation traceOrient=eForwards)
 
void GetTraceNumModes (const int tid, int &numModes0, int &numModes1, const Orientation traceOrient=eDir1FwdDir1_Dir2FwdDir2)
 
void MultiplyByQuadratureMetric (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
void MultiplyByStdQuadratureMetric (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
DNekMatSharedPtr CreateGeneralMatrix (const StdMatrixKey &mkey)
 this function generates the mass matrix \(\mathbf{M}[i][j] = \int \phi_i(\mathbf{x}) \phi_j(\mathbf{x}) d\mathbf{x}\) More...
 
void GeneralMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void MassMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void LaplacianMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void ReduceOrderCoeffs (int numMin, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
void SVVLaplacianFilter (Array< OneD, NekDouble > &array, const StdMatrixKey &mkey)
 
void ExponentialFilter (Array< OneD, NekDouble > &array, const NekDouble alpha, const NekDouble exponent, const NekDouble cutoff)
 
void LaplacianMatrixOp (const int k1, const int k2, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void WeakDerivMatrixOp (const int i, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void WeakDirectionalDerivMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void MassLevelCurvatureMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void LinearAdvectionDiffusionReactionMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey, bool addDiffusionTerm=true)
 
void HelmholtzMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
DNekMatSharedPtr GenMatrix (const StdMatrixKey &mkey)
 
void PhysDeriv (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_d0, Array< OneD, NekDouble > &out_d1=NullNekDouble1DArray, Array< OneD, NekDouble > &out_d2=NullNekDouble1DArray)
 
void PhysDeriv (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
void PhysDeriv_s (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_ds)
 
void PhysDeriv_n (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_dn)
 
void PhysDirectionalDeriv (const Array< OneD, const NekDouble > &inarray, const Array< OneD, const NekDouble > &direction, Array< OneD, NekDouble > &outarray)
 
void StdPhysDeriv (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_d0, Array< OneD, NekDouble > &out_d1=NullNekDouble1DArray, Array< OneD, NekDouble > &out_d2=NullNekDouble1DArray)
 
void StdPhysDeriv (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
NekDouble PhysEvaluate (const Array< OneD, const NekDouble > &coords, const Array< OneD, const NekDouble > &physvals)
 This function evaluates the expansion at a single (arbitrary) point of the domain. More...
 
NekDouble PhysEvaluate (const Array< OneD, DNekMatSharedPtr > &I, const Array< OneD, const NekDouble > &physvals)
 This function evaluates the expansion at a single (arbitrary) point of the domain. More...
 
NekDouble PhysEvaluateBasis (const Array< OneD, const NekDouble > &coords, int mode)
 This function evaluates the basis function mode mode at a point coords of the domain. More...
 
void LocCoordToLocCollapsed (const Array< OneD, const NekDouble > &xi, Array< OneD, NekDouble > &eta)
 Convert local cartesian coordinate xi into local collapsed coordinates eta. More...
 
void LocCollapsedToLocCoord (const Array< OneD, const NekDouble > &eta, Array< OneD, NekDouble > &xi)
 Convert local collapsed coordinates eta into local cartesian coordinate xi. More...
 
virtual void v_NormVectorIProductWRTBase (const Array< OneD, const NekDouble > &Fx, Array< OneD, NekDouble > &outarray)
 
virtual void v_NormVectorIProductWRTBase (const Array< OneD, const NekDouble > &Fx, const Array< OneD, const NekDouble > &Fy, Array< OneD, NekDouble > &outarray)
 
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::Expansion2D
 Expansion2D (SpatialDomains::Geometry2DSharedPtr pGeom)
 
virtual ~Expansion2D ()
 
DNekScalMatSharedPtr CreateMatrix (const MatrixKey &mkey)
 
void SetTraceToGeomOrientation (Array< OneD, ExpansionSharedPtr > &EdgeExp, Array< OneD, NekDouble > &inout)
 
Array< OneD, unsigned int > GetTraceInverseBoundaryMap (int eid)
 
void AddNormTraceInt (const int dir, Array< OneD, ExpansionSharedPtr > &EdgeExp, Array< OneD, Array< OneD, NekDouble >> &edgeCoeffs, Array< OneD, NekDouble > &outarray)
 
void AddNormTraceInt (const int dir, Array< OneD, const NekDouble > &inarray, Array< OneD, ExpansionSharedPtr > &EdgeExp, Array< OneD, NekDouble > &outarray, const StdRegions::VarCoeffMap &varcoeffs)
 
void AddEdgeBoundaryInt (const int edge, ExpansionSharedPtr &EdgeExp, Array< OneD, NekDouble > &edgePhys, Array< OneD, NekDouble > &outarray, const StdRegions::VarCoeffMap &varcoeffs=StdRegions::NullVarCoeffMap)
 
void AddHDGHelmholtzEdgeTerms (const NekDouble tau, const int edge, Array< OneD, ExpansionSharedPtr > &EdgeExp, Array< OneD, NekDouble > &edgePhys, const StdRegions::VarCoeffMap &dirForcing, Array< OneD, NekDouble > &outarray)
 
void AddHDGHelmholtzTraceTerms (const NekDouble tau, const Array< OneD, const NekDouble > &inarray, Array< OneD, ExpansionSharedPtr > &EdgeExp, const StdRegions::VarCoeffMap &dirForcing, Array< OneD, NekDouble > &outarray)
 
SpatialDomains::Geometry2DSharedPtr GetGeom2D () const
 
void ReOrientEdgePhysMap (const int nvert, const StdRegions::Orientation orient, const int nq0, Array< OneD, int > &idmap)
 
virtual void v_GenTraceExp (const int traceid, ExpansionSharedPtr &exp)
 
- 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)
 
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)
 
virtual 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)
 Integrates the specified function over the domain. 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=NullNekDouble1DArray)
 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)
 Calculate the derivative of the physical points in a given direction. More...
 
virtual void v_PhysDirectionalDeriv (const Array< OneD, const NekDouble > &inarray, const Array< OneD, const NekDouble > &direction, Array< OneD, NekDouble > &out)
 Physical derivative along a direction vector. More...
 
virtual void v_FwdTrans (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 Transform a given function from physical quadrature space to coefficient space. More...
 
virtual void v_FwdTransBndConstrained (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
virtual void v_IProductWRTBase (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 Calculate the inner product of inarray with respect to the basis B=base0[p]*base1[pq] and put into outarray. More...
 
virtual void v_IProductWRTDerivBase (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
virtual void v_IProductWRTBase_SumFac (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, bool multiplybyweights=true)
 
virtual void v_IProductWRTBase_MatOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
virtual void v_IProductWRTDerivBase_SumFac (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
virtual void v_AlignVectorToCollapsedDir (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, Array< OneD, NekDouble >> &outarray)
 
virtual void v_IProductWRTDerivBase_MatOp (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
virtual void v_IProductWRTDirectionalDerivBase (const Array< OneD, const NekDouble > &direction, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
virtual void v_IProductWRTDirectionalDerivBase_SumFac (const Array< OneD, const NekDouble > &direction, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 Directinoal Derivative in the modal space in the dir direction of varcoeffs. More...
 
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 StdRegions::StdExpansionSharedPtr v_GetStdExp (void) const
 
virtual StdRegions::StdExpansionSharedPtr v_GetLinStdExp (void) const
 
virtual void v_GetCoord (const Array< OneD, const NekDouble > &Lcoords, Array< OneD, NekDouble > &coords)
 
virtual void v_GetCoords (Array< OneD, NekDouble > &coords_1, Array< OneD, NekDouble > &coords_2, Array< OneD, NekDouble > &coords_3)
 
virtual NekDouble v_StdPhysEvaluate (const Array< OneD, const NekDouble > &Lcoord, const Array< OneD, const NekDouble > &physvals)
 
virtual NekDouble v_PhysEvaluate (const Array< OneD, const NekDouble > &coord, const Array< OneD, const NekDouble > &physvals)
 This function evaluates the expansion at a single (arbitrary) point of the domain. More...
 
virtual void v_GetTracePhysVals (const int edge, const StdRegions::StdExpansionSharedPtr &EdgeExp, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, StdRegions::Orientation orient)
 
virtual void v_GetEdgeInterpVals (const int edge, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
virtual void v_GetTraceQFactors (const int edge, Array< OneD, NekDouble > &outarray)
 
virtual void v_ComputeTraceNormal (const int edge)
 
virtual int v_GetCoordim ()
 
virtual void v_ExtractDataToCoeffs (const NekDouble *data, const std::vector< unsigned int > &nummodes, const int mode_offset, NekDouble *coeffs, std::vector< LibUtilities::BasisType > &fromType)
 
virtual StdRegions::Orientation v_GetTraceOrient (int edge)
 
virtual const LibUtilities::BasisSharedPtr & v_GetBasis (int dir) const
 
virtual int v_GetNumPoints (const int dir) const
 
virtual void v_GetTracePhysMap (const int edge, Array< OneD, int > &outarray)
 
virtual DNekMatSharedPtr v_GenMatrix (const StdRegions::StdMatrixKey &mkey)
 
virtual DNekMatSharedPtr v_CreateStdMatrix (const StdRegions::StdMatrixKey &mkey)
 
virtual DNekScalMatSharedPtr v_GetLocMatrix (const MatrixKey &mkey)
 
virtual DNekScalBlkMatSharedPtr v_GetLocStaticCondMatrix (const MatrixKey &mkey)
 
void v_DropLocStaticCondMatrix (const MatrixKey &mkey)
 
virtual void v_MassMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey)
 
virtual void v_LaplacianMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey)
 
virtual void v_LaplacianMatrixOp (const int k1, const int k2, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey)
 
virtual void v_WeakDerivMatrixOp (const int i, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey)
 
virtual void v_WeakDirectionalDerivMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey)
 
virtual void v_MassLevelCurvatureMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey)
 
virtual void v_HelmholtzMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey)
 
virtual void v_GeneralMatrixOp_MatOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey)
 
virtual void v_LaplacianMatrixOp_MatFree_Kernel (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, Array< OneD, NekDouble > &wsp)
 
virtual void v_ReduceOrderCoeffs (int numMin, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
virtual void v_ComputeLaplacianMetric ()
 
virtual void v_SVVLaplacianFilter (Array< OneD, NekDouble > &array, const StdRegions::StdMatrixKey &mkey)
 
virtual void v_NormalTraceDerivFactors (Array< OneD, Array< OneD, NekDouble >> &factors, Array< OneD, Array< OneD, NekDouble >> &d0factors, Array< OneD, Array< OneD, NekDouble >> &d1factors)
 : 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::StdTriExp
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=NullNekDouble1DArray)
 
virtual void v_StdPhysDeriv (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
virtual void v_BwdTrans (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 Backward tranform for triangular elements. More...
 
virtual void v_BwdTrans_SumFac (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
virtual void v_BwdTrans_SumFacKernel (const Array< OneD, const NekDouble > &base0, const Array< OneD, const NekDouble > &base1, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, Array< OneD, NekDouble > &wsp, bool doCheckCollDir0, bool doCheckCollDir1)
 
virtual void v_IProductWRTBase_SumFacKernel (const Array< OneD, const NekDouble > &base0, const Array< OneD, const NekDouble > &base1, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, Array< OneD, NekDouble > &wsp, bool doCheckCollDir0, bool doCheckCollDir1)
 
virtual void v_LocCoordToLocCollapsed (const Array< OneD, const NekDouble > &xi, Array< OneD, NekDouble > &eta)
 
virtual void v_LocCollapsedToLocCoord (const Array< OneD, const NekDouble > &eta, Array< OneD, NekDouble > &xi)
 
virtual void v_FillMode (const int mode, Array< OneD, NekDouble > &outarray)
 
NekDouble v_PhysEvaluateBasis (const Array< OneD, const NekDouble > &coords, int mode) final
 
virtual int v_GetNverts () const
 
virtual int v_GetNtraces () const
 
virtual LibUtilities::ShapeType v_DetShapeType () const
 
virtual int v_NumBndryCoeffs () const
 
virtual int v_NumDGBndryCoeffs () const
 
virtual int v_GetTraceNcoeffs (const int i) const
 
virtual int v_GetTraceNumPoints (const int i) const
 
virtual int v_CalcNumberOfCoefficients (const std::vector< unsigned int > &nummodes, int &modes_offset)
 
virtual bool v_IsBoundaryInteriorExpansion ()
 
virtual const LibUtilities::BasisKey v_GetTraceBasisKey (const int i, const int j) const
 
virtual int v_GetVertexMap (int localVertexId, bool useCoeffPacking=false)
 
virtual void v_GetInteriorMap (Array< OneD, unsigned int > &outarray)
 
virtual void v_GetBoundaryMap (Array< OneD, unsigned int > &outarray)
 
virtual void v_GetTraceCoeffMap (const unsigned int traceid, Array< OneD, unsigned int > &maparray)
 
virtual void v_GetTraceInteriorToElementMap (const int eid, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray, const Orientation edgeOrient=eForwards)
 
virtual void v_MultiplyByStdQuadratureMetric (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
virtual void v_GetSimplexEquiSpacedConnectivity (Array< OneD, int > &conn, bool standard=true)
 
- Protected Member Functions inherited from Nektar::StdRegions::StdExpansion2D
virtual NekDouble v_PhysEvaluate (const Array< OneD, DNekMatSharedPtr > &I, const Array< OneD, const NekDouble > &physvals)
 
virtual void v_LaplacianMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey)
 
virtual void v_HelmholtzMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey)
 
virtual void v_GetElmtTraceToTraceMap (const unsigned int eid, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray, Orientation edgeOrient, int P, int Q)
 Determine the mapping to re-orientate the coefficients along the element trace (assumed to align with the standard element) into the orientation of the local trace given by edgeOrient. More...
 
virtual void v_GetTraceToElementMap (const int eid, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray, Orientation edgeOrient=eForwards, int P=-1, int Q=-1)
 
virtual void v_GenStdMatBwdDeriv (const int dir, DNekMatSharedPtr &mat)
 
- 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_MatOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
void BwdTrans_SumFac (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
void IProductWRTDerivBase_SumFac (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
void IProductWRTDirectionalDerivBase_SumFac (const Array< OneD, const NekDouble > &direction, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
void GeneralMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void MassMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void LaplacianMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void LaplacianMatrixOp_MatFree_Kernel (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, Array< OneD, NekDouble > &wsp)
 
void LaplacianMatrixOp_MatFree_GenericImpl (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void LaplacianMatrixOp_MatFree (const int k1, const int k2, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void WeakDerivMatrixOp_MatFree (const int i, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void WeakDirectionalDerivMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void MassLevelCurvatureMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void LinearAdvectionDiffusionReactionMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey, bool addDiffusionTerm=true)
 
void HelmholtzMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void HelmholtzMatrixOp_MatFree_GenericImpl (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
virtual void v_SetCoeffsToOrientation (Array< OneD, NekDouble > &coeffs, StdRegions::Orientation dir)
 
template<int DIR>
NekDouble BaryEvaluate (const NekDouble &coord, const NekDouble *physvals)
 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)
 
- Protected Member Functions inherited from Nektar::LocalRegions::Expansion2D
virtual Array< OneD, NekDouble > v_GetMF (const int dir, const int shapedim, const StdRegions::VarCoeffMap &varcoeffs)
 
virtual Array< OneD, NekDouble > v_GetMFDiv (const int dir, const StdRegions::VarCoeffMap &varcoeffs)
 
virtual Array< OneD, NekDouble > v_GetMFMag (const int dir, const StdRegions::VarCoeffMap &varcoeffs)
 
virtual void v_DGDeriv (const int dir, const Array< OneD, const NekDouble > &incoeffs, Array< OneD, ExpansionSharedPtr > &EdgeExp, Array< OneD, Array< OneD, NekDouble >> &edgeCoeffs, Array< OneD, NekDouble > &out_d)
 
virtual void v_AddEdgeNormBoundaryInt (const int edge, const ExpansionSharedPtr &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 ExpansionSharedPtr &EdgeExp, const Array< OneD, const NekDouble > &Fn, Array< OneD, NekDouble > &outarray)
 
virtual void v_AddRobinMassMatrix (const int edgeid, 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 DNekMatSharedPtr v_BuildVertexMatrix (const DNekScalMatSharedPtr &r_bnd)
 
void GetPhysEdgeVarCoeffsFromElement (const int edge, ExpansionSharedPtr &EdgeExp, const Array< OneD, const NekDouble > &varcoeff, Array< OneD, NekDouble > &outarray)
 
Array< OneD, NekDouble > v_GetnEdgecdotMF (const int dir, const int edge, ExpansionSharedPtr &EdgeExp_e, const Array< OneD, const Array< OneD, NekDouble >> &normals, const StdRegions::VarCoeffMap &varcoeffs)
 
void v_ReOrientTracePhysMap (const StdRegions::Orientation orient, Array< OneD, int > &idmap, const int nq0, const int nq1)
 
virtual void v_SetUpPhysNormals (const int edge)
 
virtual NekDouble v_VectorFlux (const Array< OneD, Array< OneD, NekDouble >> &vec)
 
virtual void v_TraceNormLen (const int traceid, NekDouble &h, NekDouble &p)
 
- 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)
 
virtual void v_MultiplyByQuadratureMetric (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
virtual void v_DivideByQuadratureMetric (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
Array< OneD, NekDouble > v_GetMF (const int dir, const int shapedim, const StdRegions::VarCoeffMap &varcoeffs)
 
Array< OneD, NekDouble > v_GetMFDiv (const int dir, const StdRegions::VarCoeffMap &varcoeffs)
 
Array< OneD, NekDouble > v_GetMFMag (const int dir, const StdRegions::VarCoeffMap &varcoeffs)
 
virtual DNekMatSharedPtr v_BuildTransformationMatrix (const DNekScalMatSharedPtr &r_bnd, const StdRegions::MatrixType matrixType)
 
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_SetCoeffsToOrientation (StdRegions::Orientation dir, Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
virtual const Array< OneD, const NekDouble > & v_GetPhysNormals (void)
 
virtual void v_SetPhysNormals (Array< OneD, const NekDouble > &normal)
 

Private Member Functions

 TriExp ()
 

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::Expansion2D
std::vector< bool > m_requireNeg
 
- 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 50 of file TriExp.h.

Constructor & Destructor Documentation

◆ TriExp() [1/3]

Nektar::LocalRegions::TriExp::TriExp ( const LibUtilities::BasisKey &  Ba,
const LibUtilities::BasisKey &  Bb,
const SpatialDomains::Geometry2DSharedPtr &  geom 
)

Constructor using BasisKey class for quadrature points and order definition.

Definition at line 49 of file TriExp.cpp.

52  : StdExpansion(LibUtilities::StdTriData::getNumberOfCoefficients(
53  Ba.GetNumModes(), (Bb.GetNumModes())),
54  2, Ba, Bb),
55  StdExpansion2D(LibUtilities::StdTriData::getNumberOfCoefficients(
56  Ba.GetNumModes(), (Bb.GetNumModes())),
57  Ba, Bb),
58  StdTriExp(Ba, Bb), Expansion(geom), Expansion2D(geom),
59  m_matrixManager(
60  std::bind(&Expansion2D::CreateMatrix, this, std::placeholders::_1),
61  std::string("TriExpMatrix")),
62  m_staticCondMatrixManager(std::bind(&Expansion::CreateStaticCondMatrix,
63  this, std::placeholders::_1),
64  std::string("TriExpStaticCondMatrix"))
65 {
66 }
Nektar::LocalRegions::Expansion2D::CreateMatrix
DNekScalMatSharedPtr CreateMatrix(const MatrixKey &mkey)
Definition: Expansion2D.cpp:59
Nektar::LocalRegions::Expansion2D::Expansion2D
Expansion2D(SpatialDomains::Geometry2DSharedPtr pGeom)
Definition: Expansion2D.cpp:54
Nektar::LocalRegions::Expansion::CreateStaticCondMatrix
DNekScalBlkMatSharedPtr CreateStaticCondMatrix(const MatrixKey &mkey)
Definition: Expansion.cpp:272
Nektar::LocalRegions::Expansion::Expansion
Expansion(SpatialDomains::GeometrySharedPtr pGeom)
Definition: Expansion.cpp:47
Nektar::LocalRegions::TriExp::m_matrixManager
LibUtilities::NekManager< MatrixKey, DNekScalMat, MatrixKey::opLess > m_matrixManager
Definition: TriExp.h:249
Nektar::LocalRegions::TriExp::m_staticCondMatrixManager
LibUtilities::NekManager< MatrixKey, DNekScalBlkMat, MatrixKey::opLess > m_staticCondMatrixManager
Definition: TriExp.h:251
Nektar::StdRegions::StdExpansion::StdExpansion
StdExpansion()
Default Constructor.
Definition: StdExpansion.cpp:45
Nektar::LibUtilities::StdTriData::getNumberOfCoefficients
int getNumberOfCoefficients(int Na, int Nb)
Definition: ShapeType.hpp:112

◆ TriExp() [2/3]

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

Definition at line 68 of file TriExp.cpp.

69  : StdExpansion(T), StdExpansion2D(T), StdTriExp(T), Expansion(T),
70  Expansion2D(T), m_matrixManager(T.m_matrixManager),
71  m_staticCondMatrixManager(T.m_staticCondMatrixManager)
72 {
73 }

◆ ~TriExp()

Nektar::LocalRegions::TriExp::~TriExp ( )

Definition at line 75 of file TriExp.cpp.

76 {
77 }

◆ TriExp() [3/3]

Nektar::LocalRegions::TriExp::TriExp ( )
private

Member Function Documentation

◆ v_AlignVectorToCollapsedDir()

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

Reimplemented from Nektar::LocalRegions::Expansion.

Definition at line 484 of file TriExp.cpp.

487 {
488  ASSERTL1((dir == 0) || (dir == 1) || (dir == 2), "Invalid direction.");
489  ASSERTL1((dir == 2) ? (m_geom->GetCoordim() == 3) : true,
490  "Invalid direction.");
491 
492  int nquad0 = m_base[0]->GetNumPoints();
493  int nquad1 = m_base[1]->GetNumPoints();
494  int nqtot = nquad0 * nquad1;
495  int nmodes0 = m_base[0]->GetNumModes();
496  int wspsize = max(max(nqtot, m_ncoeffs), nquad1 * nmodes0);
497 
498  const Array<TwoD, const NekDouble> &df =
499  m_metricinfo->GetDerivFactors(GetPointsKeys());
500 
501  Array<OneD, NekDouble> tmp0(wspsize);
502  Array<OneD, NekDouble> tmp3(wspsize);
503  Array<OneD, NekDouble> gfac0(wspsize);
504  Array<OneD, NekDouble> gfac1(wspsize);
505 
506  Array<OneD, NekDouble> tmp1 = outarray[0];
507  Array<OneD, NekDouble> tmp2 = outarray[1];
508 
509  const Array<OneD, const NekDouble> &z0 = m_base[0]->GetZ();
510  const Array<OneD, const NekDouble> &z1 = m_base[1]->GetZ();
511 
512  // set up geometric factor: 2/(1-z1)
513  for (int i = 0; i < nquad1; ++i)
514  {
515  gfac0[i] = 2.0 / (1 - z1[i]);
516  }
517  for (int i = 0; i < nquad0; ++i)
518  {
519  gfac1[i] = 0.5 * (1 + z0[i]);
520  }
521 
522  for (int i = 0; i < nquad1; ++i)
523  {
524  Vmath::Smul(nquad0, gfac0[i], &inarray[0] + i * nquad0, 1,
525  &tmp0[0] + i * nquad0, 1);
526  }
527 
528  for (int i = 0; i < nquad1; ++i)
529  {
530  Vmath::Vmul(nquad0, &gfac1[0], 1, &tmp0[0] + i * nquad0, 1,
531  &tmp1[0] + i * nquad0, 1);
532  }
533 
534  if (m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
535  {
536  Vmath::Vmul(nqtot, &df[2 * dir][0], 1, &tmp0[0], 1, &tmp0[0], 1);
537  Vmath::Vmul(nqtot, &df[2 * dir + 1][0], 1, &tmp1[0], 1, &tmp1[0], 1);
538  Vmath::Vmul(nqtot, &df[2 * dir + 1][0], 1, &inarray[0], 1, &tmp2[0], 1);
539  }
540  else
541  {
542  Vmath::Smul(nqtot, df[2 * dir][0], tmp0, 1, tmp0, 1);
543  Vmath::Smul(nqtot, df[2 * dir + 1][0], tmp1, 1, tmp1, 1);
544  Vmath::Smul(nqtot, df[2 * dir + 1][0], inarray, 1, tmp2, 1);
545  }
546  Vmath::Vadd(nqtot, tmp0, 1, tmp1, 1, tmp1, 1);
547 }
ASSERTL1
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode....
Definition: ErrorUtil.hpp:249
Nektar::LocalRegions::Expansion::m_geom
SpatialDomains::GeometrySharedPtr m_geom
Definition: Expansion.h:272
Nektar::LocalRegions::Expansion::m_metricinfo
SpatialDomains::GeomFactorsSharedPtr m_metricinfo
Definition: Expansion.h:273
Nektar::StdRegions::StdExpansion::GetPointsKeys
const LibUtilities::PointsKeyVector GetPointsKeys() const
Definition: StdExpansion.h:1067
Nektar::StdRegions::StdExpansion::m_base
Array< OneD, LibUtilities::BasisSharedPtr > m_base
Definition: StdExpansion.h:1145
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:209
Vmath::Vadd
void Vadd(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Add vector z = x+y.
Definition: Vmath.cpp:359
Vmath::Smul
void Smul(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Scalar multiply y = alpha*x.
Definition: Vmath.cpp:248

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

Referenced by v_IProductWRTDerivBase_SumFac().

◆ v_ComputeLaplacianMetric()

void Nektar::LocalRegions::TriExp::v_ComputeLaplacianMetric ( )
protectedvirtual

Reimplemented from Nektar::LocalRegions::Expansion.

Definition at line 1300 of file TriExp.cpp.

1301 {
1302  if (m_metrics.count(eMetricQuadrature) == 0)
1303  {
1304  ComputeQuadratureMetric();
1305  }
1306 
1307  unsigned int i, j;
1308  const SpatialDomains::GeomType type = m_metricinfo->GetGtype();
1309  const unsigned int nqtot = GetTotPoints();
1310  const unsigned int dim = 2;
1311  const MetricType m[3][3] = {
1312  {eMetricLaplacian00, eMetricLaplacian01, eMetricLaplacian02},
1313  {eMetricLaplacian01, eMetricLaplacian11, eMetricLaplacian12},
1314  {eMetricLaplacian02, eMetricLaplacian12, eMetricLaplacian22}};
1315 
1316  Array<OneD, NekDouble> dEta_dXi[2] = {Array<OneD, NekDouble>(nqtot, 1.0),
1317  Array<OneD, NekDouble>(nqtot, 1.0)};
1318 
1319  for (i = 0; i < dim; ++i)
1320  {
1321  for (j = i; j < dim; ++j)
1322  {
1323  m_metrics[m[i][j]] = Array<OneD, NekDouble>(nqtot);
1324  }
1325  }
1326 
1327  const Array<OneD, const NekDouble> &z0 = m_base[0]->GetZ();
1328  const Array<OneD, const NekDouble> &z1 = m_base[1]->GetZ();
1329  const unsigned int nquad0 = m_base[0]->GetNumPoints();
1330  const unsigned int nquad1 = m_base[1]->GetNumPoints();
1331  const Array<TwoD, const NekDouble> &df =
1332  m_metricinfo->GetDerivFactors(GetPointsKeys());
1333 
1334  for (i = 0; i < nquad1; i++)
1335  {
1336  Blas::Dscal(nquad0, 2.0 / (1 - z1[i]), &dEta_dXi[0][0] + i * nquad0, 1);
1337  Blas::Dscal(nquad0, 2.0 / (1 - z1[i]), &dEta_dXi[1][0] + i * nquad0, 1);
1338  }
1339  for (i = 0; i < nquad0; i++)
1340  {
1341  Blas::Dscal(nquad1, 0.5 * (1 + z0[i]), &dEta_dXi[1][0] + i, nquad0);
1342  }
1343 
1344  Array<OneD, NekDouble> tmp(nqtot);
1345  if ((type == SpatialDomains::eRegular ||
1346  type == SpatialDomains::eMovingRegular))
1347  {
1348  Vmath::Smul(nqtot, df[0][0], &dEta_dXi[0][0], 1, &tmp[0], 1);
1349  Vmath::Svtvp(nqtot, df[1][0], &dEta_dXi[1][0], 1, &tmp[0], 1, &tmp[0],
1350  1);
1351 
1352  Vmath::Vmul(nqtot, &tmp[0], 1, &tmp[0], 1,
1353  &m_metrics[eMetricLaplacian00][0], 1);
1354  Vmath::Smul(nqtot, df[1][0], &tmp[0], 1,
1355  &m_metrics[eMetricLaplacian01][0], 1);
1356 
1357  Vmath::Smul(nqtot, df[2][0], &dEta_dXi[0][0], 1, &tmp[0], 1);
1358  Vmath::Svtvp(nqtot, df[3][0], &dEta_dXi[1][0], 1, &tmp[0], 1, &tmp[0],
1359  1);
1360 
1361  Vmath::Vvtvp(nqtot, &tmp[0], 1, &tmp[0], 1,
1362  &m_metrics[eMetricLaplacian00][0], 1,
1363  &m_metrics[eMetricLaplacian00][0], 1);
1364  Vmath::Svtvp(nqtot, df[3][0], &tmp[0], 1,
1365  &m_metrics[eMetricLaplacian01][0], 1,
1366  &m_metrics[eMetricLaplacian01][0], 1);
1367 
1368  if (GetCoordim() == 3)
1369  {
1370  Vmath::Smul(nqtot, df[4][0], &dEta_dXi[0][0], 1, &tmp[0], 1);
1371  Vmath::Svtvp(nqtot, df[5][0], &dEta_dXi[1][0], 1, &tmp[0], 1,
1372  &tmp[0], 1);
1373 
1374  Vmath::Vvtvp(nqtot, &tmp[0], 1, &tmp[0], 1,
1375  &m_metrics[eMetricLaplacian00][0], 1,
1376  &m_metrics[eMetricLaplacian00][0], 1);
1377  Vmath::Svtvp(nqtot, df[5][0], &tmp[0], 1,
1378  &m_metrics[eMetricLaplacian01][0], 1,
1379  &m_metrics[eMetricLaplacian01][0], 1);
1380  }
1381 
1382  NekDouble g2 = df[1][0] * df[1][0] + df[3][0] * df[3][0];
1383  if (GetCoordim() == 3)
1384  {
1385  g2 += df[5][0] * df[5][0];
1386  }
1387  Vmath::Fill(nqtot, g2, &m_metrics[eMetricLaplacian11][0], 1);
1388  }
1389  else
1390  {
1391 
1392  Vmath::Vmul(nqtot, &df[0][0], 1, &dEta_dXi[0][0], 1, &tmp[0], 1);
1393  Vmath::Vvtvp(nqtot, &df[1][0], 1, &dEta_dXi[1][0], 1, &tmp[0], 1,
1394  &tmp[0], 1);
1395 
1396  Vmath::Vmul(nqtot, &tmp[0], 1, &tmp[0], 1,
1397  &m_metrics[eMetricLaplacian00][0], 1);
1398  Vmath::Vmul(nqtot, &df[1][0], 1, &tmp[0], 1,
1399  &m_metrics[eMetricLaplacian01][0], 1);
1400  Vmath::Vmul(nqtot, &df[1][0], 1, &df[1][0], 1,
1401  &m_metrics[eMetricLaplacian11][0], 1);
1402 
1403  Vmath::Vmul(nqtot, &df[2][0], 1, &dEta_dXi[0][0], 1, &tmp[0], 1);
1404  Vmath::Vvtvp(nqtot, &df[3][0], 1, &dEta_dXi[1][0], 1, &tmp[0], 1,
1405  &tmp[0], 1);
1406 
1407  Vmath::Vvtvp(nqtot, &tmp[0], 1, &tmp[0], 1,
1408  &m_metrics[eMetricLaplacian00][0], 1,
1409  &m_metrics[eMetricLaplacian00][0], 1);
1410  Vmath::Vvtvp(nqtot, &df[3][0], 1, &tmp[0], 1,
1411  &m_metrics[eMetricLaplacian01][0], 1,
1412  &m_metrics[eMetricLaplacian01][0], 1);
1413  Vmath::Vvtvp(nqtot, &df[3][0], 1, &df[3][0], 1,
1414  &m_metrics[eMetricLaplacian11][0], 1,
1415  &m_metrics[eMetricLaplacian11][0], 1);
1416 
1417  if (GetCoordim() == 3)
1418  {
1419  Vmath::Vmul(nqtot, &df[4][0], 1, &dEta_dXi[0][0], 1, &tmp[0], 1);
1420  Vmath::Vvtvp(nqtot, &df[5][0], 1, &dEta_dXi[1][0], 1, &tmp[0], 1,
1421  &tmp[0], 1);
1422 
1423  Vmath::Vvtvp(nqtot, &tmp[0], 1, &tmp[0], 1,
1424  &m_metrics[eMetricLaplacian00][0], 1,
1425  &m_metrics[eMetricLaplacian00][0], 1);
1426  Vmath::Vvtvp(nqtot, &df[5][0], 1, &tmp[0], 1,
1427  &m_metrics[eMetricLaplacian01][0], 1,
1428  &m_metrics[eMetricLaplacian01][0], 1);
1429  Vmath::Vvtvp(nqtot, &df[5][0], 1, &df[5][0], 1,
1430  &m_metrics[eMetricLaplacian11][0], 1,
1431  &m_metrics[eMetricLaplacian11][0], 1);
1432  }
1433  }
1434 
1435  for (unsigned int i = 0; i < dim; ++i)
1436  {
1437  for (unsigned int j = i; j < dim; ++j)
1438  {
1439  MultiplyByQuadratureMetric(m_metrics[m[i][j]], m_metrics[m[i][j]]);
1440  }
1441  }
1442 }
Nektar::StdRegions::StdExpansion::GetTotPoints
int GetTotPoints() const
This function returns the total number of quadrature points used in the element.
Definition: StdExpansion.h:140
Nektar::StdRegions::StdExpansion::MultiplyByQuadratureMetric
void MultiplyByQuadratureMetric(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
Definition: StdExpansion.h:731
Blas::Dscal
static void Dscal(const int &n, const double &alpha, double *x, const int &incx)
BLAS level 1: x = alpha x.
Definition: Blas.hpp:168
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::Svtvp
void Svtvp(int n, const T alpha, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
svtvp (scalar times vector plus vector): z = alpha*x + y
Definition: Vmath.cpp:622
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:574
Vmath::Fill
void Fill(int n, const T alpha, T *x, const int incx)
Fill a vector with a constant value.
Definition: Vmath.cpp:45

References Nektar::LocalRegions::Expansion::ComputeQuadratureMetric(), Blas::Dscal(), Nektar::LocalRegions::eMetricLaplacian00, Nektar::LocalRegions::eMetricLaplacian01, Nektar::LocalRegions::eMetricLaplacian02, Nektar::LocalRegions::eMetricLaplacian11, Nektar::LocalRegions::eMetricLaplacian12, Nektar::LocalRegions::eMetricLaplacian22, Nektar::LocalRegions::eMetricQuadrature, Nektar::SpatialDomains::eMovingRegular, Nektar::SpatialDomains::eRegular, Vmath::Fill(), Nektar::StdRegions::StdExpansion::GetCoordim(), Nektar::StdRegions::StdExpansion::GetPointsKeys(), Nektar::StdRegions::StdExpansion::GetTotPoints(), Nektar::StdRegions::StdExpansion::m_base, Nektar::LocalRegions::Expansion::m_metricinfo, Nektar::LocalRegions::Expansion::m_metrics, Nektar::StdRegions::StdExpansion::MultiplyByQuadratureMetric(), Vmath::Smul(), Vmath::Svtvp(), Vmath::Vmul(), and Vmath::Vvtvp().

◆ v_ComputeTraceNormal()

void Nektar::LocalRegions::TriExp::v_ComputeTraceNormal ( const int  edge)
protectedvirtual

Reimplemented from Nektar::LocalRegions::Expansion.

Definition at line 876 of file TriExp.cpp.

877 {
878  int i;
879  const SpatialDomains::GeomFactorsSharedPtr &geomFactors =
880  GetGeom()->GetMetricInfo();
881 
882  LibUtilities::PointsKeyVector ptsKeys = GetPointsKeys();
883  for (i = 0; i < ptsKeys.size(); ++i)
884  {
885  // Need at least 2 points for computing normals
886  if (ptsKeys[i].GetNumPoints() == 1)
887  {
888  LibUtilities::PointsKey pKey(2, ptsKeys[i].GetPointsType());
889  ptsKeys[i] = pKey;
890  }
891  }
892 
893  const SpatialDomains::GeomType type = geomFactors->GetGtype();
894  const Array<TwoD, const NekDouble> &df =
895  geomFactors->GetDerivFactors(ptsKeys);
896  const Array<OneD, const NekDouble> &jac = geomFactors->GetJac(ptsKeys);
897  int nqe = m_base[0]->GetNumPoints();
898  int dim = GetCoordim();
899 
900  m_traceNormals[edge] = Array<OneD, Array<OneD, NekDouble>>(dim);
901  Array<OneD, Array<OneD, NekDouble>> &normal = m_traceNormals[edge];
902  for (i = 0; i < dim; ++i)
903  {
904  normal[i] = Array<OneD, NekDouble>(nqe);
905  }
906 
907  size_t nqb = nqe;
908  size_t nbnd = edge;
909  m_elmtBndNormDirElmtLen[nbnd] = Array<OneD, NekDouble>{nqb, 0.0};
910  Array<OneD, NekDouble> &length = m_elmtBndNormDirElmtLen[nbnd];
911 
912  // Regular geometry case
913  if ((type == SpatialDomains::eRegular) ||
914  (type == SpatialDomains::eMovingRegular))
915  {
916  NekDouble fac;
917  // Set up normals
918  switch (edge)
919  {
920  case 0:
921  for (i = 0; i < GetCoordim(); ++i)
922  {
923  Vmath::Fill(nqe, -df[2 * i + 1][0], normal[i], 1);
924  }
925  break;
926  case 1:
927  for (i = 0; i < GetCoordim(); ++i)
928  {
929  Vmath::Fill(nqe, df[2 * i + 1][0] + df[2 * i][0], normal[i],
930  1);
931  }
932  break;
933  case 2:
934  for (i = 0; i < GetCoordim(); ++i)
935  {
936  Vmath::Fill(nqe, -df[2 * i][0], normal[i], 1);
937  }
938  break;
939  default:
940  ASSERTL0(false, "Edge is out of range (edge < 3)");
941  }
942 
943  // normalise
944  fac = 0.0;
945  for (i = 0; i < GetCoordim(); ++i)
946  {
947  fac += normal[i][0] * normal[i][0];
948  }
949  fac = 1.0 / sqrt(fac);
950 
951  Vmath::Fill(nqb, fac, length, 1);
952 
953  for (i = 0; i < GetCoordim(); ++i)
954  {
955  Vmath::Smul(nqe, fac, normal[i], 1, normal[i], 1);
956  }
957  }
958  else // Set up deformed normals
959  {
960  int j;
961 
962  int nquad0 = ptsKeys[0].GetNumPoints();
963  int nquad1 = ptsKeys[1].GetNumPoints();
964 
965  LibUtilities::PointsKey from_key;
966 
967  Array<OneD, NekDouble> normals(GetCoordim() * max(nquad0, nquad1), 0.0);
968  Array<OneD, NekDouble> edgejac(GetCoordim() * max(nquad0, nquad1), 0.0);
969 
970  // Extract Jacobian along edges and recover local
971  // derivates (dx/dr) for polynomial interpolation by
972  // multiplying m_gmat by jacobian
973  switch (edge)
974  {
975  case 0:
976  for (j = 0; j < nquad0; ++j)
977  {
978  edgejac[j] = jac[j];
979  for (i = 0; i < GetCoordim(); ++i)
980  {
981  normals[i * nquad0 + j] =
982  -df[2 * i + 1][j] * edgejac[j];
983  }
984  }
985  from_key = ptsKeys[0];
986  break;
987  case 1:
988  for (j = 0; j < nquad1; ++j)
989  {
990  edgejac[j] = jac[nquad0 * j + nquad0 - 1];
991  for (i = 0; i < GetCoordim(); ++i)
992  {
993  normals[i * nquad1 + j] =
994  (df[2 * i][nquad0 * j + nquad0 - 1] +
995  df[2 * i + 1][nquad0 * j + nquad0 - 1]) *
996  edgejac[j];
997  }
998  }
999  from_key = ptsKeys[1];
1000  break;
1001  case 2:
1002  for (j = 0; j < nquad1; ++j)
1003  {
1004  edgejac[j] = jac[nquad0 * j];
1005  for (i = 0; i < GetCoordim(); ++i)
1006  {
1007  normals[i * nquad1 + j] =
1008  -df[2 * i][nquad0 * j] * edgejac[j];
1009  }
1010  }
1011  from_key = ptsKeys[1];
1012  break;
1013  default:
1014  ASSERTL0(false, "edge is out of range (edge < 3)");
1015  }
1016 
1017  int nq = from_key.GetNumPoints();
1018  Array<OneD, NekDouble> work(nqe, 0.0);
1019 
1020  // interpolate Jacobian and invert
1021  LibUtilities::Interp1D(from_key, jac, m_base[0]->GetPointsKey(), work);
1022  Vmath::Sdiv(nqe, 1.0, &work[0], 1, &work[0], 1);
1023 
1024  // interpolate
1025  for (i = 0; i < GetCoordim(); ++i)
1026  {
1027  LibUtilities::Interp1D(from_key, &normals[i * nq],
1028  m_base[0]->GetPointsKey(), &normal[i][0]);
1029  Vmath::Vmul(nqe, work, 1, normal[i], 1, normal[i], 1);
1030  }
1031 
1032  // normalise normal vectors
1033  Vmath::Zero(nqe, work, 1);
1034  for (i = 0; i < GetCoordim(); ++i)
1035  {
1036  Vmath::Vvtvp(nqe, normal[i], 1, normal[i], 1, work, 1, work, 1);
1037  }
1038 
1039  Vmath::Vsqrt(nqe, work, 1, work, 1);
1040  Vmath::Sdiv(nqe, 1.0, work, 1, work, 1);
1041 
1042  Vmath::Vcopy(nqb, work, 1, length, 1);
1043 
1044  for (i = 0; i < GetCoordim(); ++i)
1045  {
1046  Vmath::Vmul(nqe, normal[i], 1, work, 1, normal[i], 1);
1047  }
1048  }
1049 
1050  if (GetGeom()->GetEorient(edge) == StdRegions::eBackwards)
1051  {
1052  for (i = 0; i < GetCoordim(); ++i)
1053  {
1054  if (geomFactors->GetGtype() == SpatialDomains::eDeformed)
1055  {
1056  Vmath::Reverse(nqe, normal[i], 1, normal[i], 1);
1057  }
1058  }
1059  }
1060 }
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:215
Nektar::LocalRegions::Expansion::m_traceNormals
std::map< int, NormalVector > m_traceNormals
Definition: Expansion.h:275
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:285
Nektar::LocalRegions::Expansion::GetGeom
SpatialDomains::GeometrySharedPtr GetGeom() const
Definition: Expansion.cpp:166
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:213
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:226
Nektar::LibUtilities::Interp1D
void Interp1D(const BasisKey &fbasis0, const Array< OneD, const NekDouble > &from, const BasisKey &tbasis0, Array< OneD, NekDouble > &to)
this function interpolates a 1D function evaluated at the quadrature points of the basis fbasis0 to ...
Definition: Interp.cpp:52
Nektar::LibUtilities::PointsKeyVector
std::vector< PointsKey > PointsKeyVector
Definition: Points.h:250
Nektar::SpatialDomains::GeomFactorsSharedPtr
std::shared_ptr< GeomFactors > GeomFactorsSharedPtr
Pointer to a GeomFactors object.
Definition: GeomFactors.h:62
Vmath::Vsqrt
void Vsqrt(int n, const T *x, const int incx, T *y, const int incy)
sqrt y = sqrt(x)
Definition: Vmath.cpp:534
Vmath::Sdiv
void Sdiv(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Scalar multiply y = alpha/y.
Definition: Vmath.cpp:324
Vmath::Zero
void Zero(int n, T *x, const int incx)
Zero vector.
Definition: Vmath.cpp:492
Vmath::Reverse
void Reverse(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1286
Vmath::Vcopy
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1255
tinysimd::sqrt
scalarT< T > sqrt(scalarT< T > in)
Definition: scalar.hpp:291

References ASSERTL0, Nektar::StdRegions::eBackwards, Nektar::SpatialDomains::eDeformed, Nektar::SpatialDomains::eMovingRegular, Nektar::SpatialDomains::eRegular, Vmath::Fill(), Nektar::StdRegions::StdExpansion::GetCoordim(), Nektar::LocalRegions::Expansion::GetGeom(), Nektar::LibUtilities::PointsKey::GetNumPoints(), Nektar::StdRegions::StdExpansion::GetNumPoints(), Nektar::StdRegions::StdExpansion::GetPointsKeys(), Nektar::StdRegions::StdExpansion::GetPointsType(), Nektar::LibUtilities::Interp1D(), Nektar::StdRegions::StdExpansion::m_base, Nektar::LocalRegions::Expansion::m_elmtBndNormDirElmtLen, Nektar::LocalRegions::Expansion::m_traceNormals, Vmath::Reverse(), Vmath::Sdiv(), Vmath::Smul(), tinysimd::sqrt(), Vmath::Vcopy(), Vmath::Vmul(), Vmath::Vsqrt(), Vmath::Vvtvp(), and Vmath::Zero().

◆ v_CreateStdMatrix()

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

Reimplemented from Nektar::StdRegions::StdTriExp.

Definition at line 1145 of file TriExp.cpp.

1146 {
1147  LibUtilities::BasisKey bkey0 = m_base[0]->GetBasisKey();
1148  LibUtilities::BasisKey bkey1 = m_base[1]->GetBasisKey();
1149  StdRegions::StdTriExpSharedPtr tmp =
1150  MemoryManager<StdTriExp>::AllocateSharedPtr(bkey0, bkey1);
1151 
1152  return tmp->GetStdMatrix(mkey);
1153 }
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::StdTriExpSharedPtr
std::shared_ptr< StdTriExp > StdTriExpSharedPtr
Definition: StdTriExp.h:235

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

◆ v_DropLocStaticCondMatrix()

void Nektar::LocalRegions::TriExp::v_DropLocStaticCondMatrix ( const MatrixKey &  mkey)
protectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 1165 of file TriExp.cpp.

1166 {
1167  m_staticCondMatrixManager.DeleteObject(mkey);
1168 }

References m_staticCondMatrixManager.

◆ v_ExtractDataToCoeffs()

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

Reimplemented from Nektar::LocalRegions::Expansion.

Definition at line 1067 of file TriExp.cpp.

1071 {
1072  boost::ignore_unused(fromType);
1073 
1074  int data_order0 = nummodes[mode_offset];
1075  int fillorder0 = min(m_base[0]->GetNumModes(), data_order0);
1076  int data_order1 = nummodes[mode_offset + 1];
1077  int order1 = m_base[1]->GetNumModes();
1078  int fillorder1 = min(order1, data_order1);
1079 
1080  switch (m_base[0]->GetBasisType())
1081  {
1082  case LibUtilities::eModified_A:
1083  case LibUtilities::eOrtho_A:
1084  {
1085  int i;
1086  int cnt = 0;
1087  int cnt1 = 0;
1088 
1089  ASSERTL1(m_base[1]->GetBasisType() == LibUtilities::eModified_B ||
1090  m_base[1]->GetBasisType() == LibUtilities::eOrtho_B,
1091  "Extraction routine not set up for this basis");
1092 
1093  Vmath::Zero(m_ncoeffs, coeffs, 1);
1094  for (i = 0; i < fillorder0; ++i)
1095  {
1096  Vmath::Vcopy(fillorder1 - i, &data[cnt], 1, &coeffs[cnt1], 1);
1097  cnt += data_order1 - i;
1098  cnt1 += order1 - i;
1099  }
1100  }
1101  break;
1102  default:
1103  ASSERTL0(false, "basis is either not set up or not hierarchicial");
1104  }
1105 }
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:163
Nektar::LibUtilities::eModified_B
@ eModified_B
Principle Modified Functions .
Definition: BasisType.h:51
Nektar::LibUtilities::eOrtho_A
@ eOrtho_A
Principle Orthogonal Functions .
Definition: BasisType.h:44
Nektar::LibUtilities::eOrtho_B
@ eOrtho_B
Principle Orthogonal Functions .
Definition: BasisType.h:46
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::LibUtilities::eOrtho_A, Nektar::LibUtilities::eOrtho_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::TriExp::v_FwdTrans ( const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray 
)
protectedvirtual

Transform a given function from physical quadrature space to coefficient space.

See also
StdExpansion::FwdTrans

Reimplemented from Nektar::StdRegions::StdTriExp.

Definition at line 257 of file TriExp.cpp.

259 {
260  IProductWRTBase(inarray, outarray);
261 
262  // get Mass matrix inverse
263  MatrixKey masskey(StdRegions::eInvMass, DetShapeType(), *this);
264  DNekScalMatSharedPtr matsys = m_matrixManager[masskey];
265 
266  // copy inarray in case inarray == outarray
267  NekVector<NekDouble> in(m_ncoeffs, outarray, eCopy);
268  NekVector<NekDouble> out(m_ncoeffs, outarray, eWrapper);
269 
270  out = (*matsys) * in;
271 }
Nektar::StdRegions::StdExpansion::IProductWRTBase
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 expa...
Definition: StdExpansion.h:536
Nektar::StdRegions::StdExpansion::DetShapeType
LibUtilities::ShapeType DetShapeType() const
This function returns the shape of the expansion domain.
Definition: StdExpansion.h:375
Nektar::DNekScalMatSharedPtr
std::shared_ptr< DNekScalMat > DNekScalMatSharedPtr
Definition: NekMatrixFwd.hpp:68

References Nektar::StdRegions::StdExpansion::DetShapeType(), Nektar::eCopy, Nektar::StdRegions::eInvMass, Nektar::eWrapper, Nektar::StdRegions::StdExpansion::IProductWRTBase(), m_matrixManager, and Nektar::StdRegions::StdExpansion::m_ncoeffs.

◆ v_FwdTransBndConstrained()

void Nektar::LocalRegions::TriExp::v_FwdTransBndConstrained ( const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray 
)
protectedvirtual

Reimplemented from Nektar::StdRegions::StdTriExp.

Definition at line 273 of file TriExp.cpp.

276 {
277  int i, j;
278  int npoints[2] = {m_base[0]->GetNumPoints(), m_base[1]->GetNumPoints()};
279  int nmodes[2] = {m_base[0]->GetNumModes(), m_base[1]->GetNumModes()};
280 
281  fill(outarray.get(), outarray.get() + m_ncoeffs, 0.0);
282 
283  if (nmodes[0] == 1 && nmodes[1] == 1)
284  {
285  outarray[0] = inarray[0];
286  return;
287  }
288 
289  Array<OneD, NekDouble> physEdge[3];
290  Array<OneD, NekDouble> coeffEdge[3];
291  for (i = 0; i < 3; i++)
292  {
293  // define physEdge and add 1 so can interpolate grl10 points if
294  // necessary
295  physEdge[i] = Array<OneD, NekDouble>(max(npoints[i != 0], npoints[0]));
296  coeffEdge[i] = Array<OneD, NekDouble>(nmodes[i != 0]);
297  }
298 
299  for (i = 0; i < npoints[0]; i++)
300  {
301  physEdge[0][i] = inarray[i];
302  }
303 
304  // extract data in cartesian directions
305  for (i = 0; i < npoints[1]; i++)
306  {
307  physEdge[1][i] = inarray[npoints[0] - 1 + i * npoints[0]];
308  physEdge[2][i] = inarray[i * npoints[0]];
309  }
310 
311  SegExpSharedPtr segexp[3];
312  segexp[0] = MemoryManager<LocalRegions::SegExp>::AllocateSharedPtr(
313  m_base[0]->GetBasisKey(), GetGeom2D()->GetEdge(0));
314 
315  if (m_base[1]->GetPointsType() == LibUtilities::eGaussLobattoLegendre)
316  {
317  for (i = 1; i < 3; i++)
318  {
319  segexp[i] = MemoryManager<LocalRegions::SegExp>::AllocateSharedPtr(
320  m_base[i != 0]->GetBasisKey(), GetGeom2D()->GetEdge(i));
321  }
322  }
323  else // interploate using edge 0 GLL distribution
324  {
325  for (i = 1; i < 3; i++)
326  {
327  segexp[i] = MemoryManager<LocalRegions::SegExp>::AllocateSharedPtr(
328  m_base[0]->GetBasisKey(), GetGeom2D()->GetEdge(i));
329 
330  LibUtilities::Interp1D(m_base[1]->GetPointsKey(), physEdge[i],
331  m_base[0]->GetPointsKey(), physEdge[i]);
332  }
333  npoints[1] = npoints[0];
334  }
335 
336  Array<OneD, unsigned int> mapArray;
337  Array<OneD, int> signArray;
338  NekDouble sign;
339  // define an orientation to get EdgeToElmtMapping from Cartesian data
340  StdRegions::Orientation orient[3] = {
341  StdRegions::eForwards, StdRegions::eForwards, StdRegions::eForwards};
342 
343  for (i = 0; i < 3; i++)
344  {
345  segexp[i]->FwdTransBndConstrained(physEdge[i], coeffEdge[i]);
346 
347  // this orient goes with the one above and so could
348  // probably set both to eForwards
349  GetTraceToElementMap(i, mapArray, signArray, orient[i]);
350  for (j = 0; j < nmodes[i != 0]; j++)
351  {
352  sign = (NekDouble)signArray[j];
353  outarray[mapArray[j]] = sign * coeffEdge[i][j];
354  }
355  }
356 
357  int nBoundaryDofs = NumBndryCoeffs();
358  int nInteriorDofs = m_ncoeffs - nBoundaryDofs;
359 
360  if (nInteriorDofs > 0)
361  {
362  Array<OneD, NekDouble> tmp0(m_ncoeffs);
363  Array<OneD, NekDouble> tmp1(m_ncoeffs);
364 
365  StdRegions::StdMatrixKey stdmasskey(StdRegions::eMass, DetShapeType(),
366  *this);
367  MassMatrixOp(outarray, tmp0, stdmasskey);
368  IProductWRTBase(inarray, tmp1);
369 
370  Vmath::Vsub(m_ncoeffs, tmp1, 1, tmp0, 1, tmp1, 1);
371 
372  // get Mass matrix inverse (only of interior DOF)
373  // use block (1,1) of the static condensed system
374  // note: this block alreay contains the inverse matrix
375  MatrixKey masskey(StdRegions::eMass, DetShapeType(), *this);
376  DNekScalMatSharedPtr matsys =
377  (m_staticCondMatrixManager[masskey])->GetBlock(1, 1);
378 
379  Array<OneD, NekDouble> rhs(nInteriorDofs);
380  Array<OneD, NekDouble> result(nInteriorDofs);
381 
382  GetInteriorMap(mapArray);
383 
384  for (i = 0; i < nInteriorDofs; i++)
385  {
386  rhs[i] = tmp1[mapArray[i]];
387  }
388 
389  Blas::Dgemv('N', nInteriorDofs, nInteriorDofs, matsys->Scale(),
390  &((matsys->GetOwnedMatrix())->GetPtr())[0], nInteriorDofs,
391  rhs.get(), 1, 0.0, result.get(), 1);
392 
393  for (i = 0; i < nInteriorDofs; i++)
394  {
395  outarray[mapArray[i]] = result[i];
396  }
397  }
398 }
sign
#define sign(a, b)
return the sign(b)*a
Definition: Polylib.cpp:15
Nektar::LocalRegions::Expansion2D::GetGeom2D
SpatialDomains::Geometry2DSharedPtr GetGeom2D() const
Definition: Expansion2D.h:180
Nektar::StdRegions::StdExpansion::MassMatrixOp
void MassMatrixOp(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
Definition: StdExpansion.h:760
Nektar::StdRegions::StdExpansion::GetTraceToElementMap
void GetTraceToElementMap(const int tid, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray, Orientation traceOrient=eForwards, int P=-1, int Q=-1)
Definition: StdExpansion.h:692
Nektar::StdRegions::StdExpansion::GetInteriorMap
void GetInteriorMap(Array< OneD, unsigned int > &outarray)
Definition: StdExpansion.h:682
Blas::Dgemv
static void Dgemv(const char &trans, const int &m, const int &n, const double &alpha, const double *a, const int &lda, const double *x, const int &incx, const double &beta, double *y, const int &incy)
BLAS level 2: Matrix vector multiply y = A x where A[m x n].
Definition: Blas.hpp:246
Nektar::LibUtilities::eGaussLobattoLegendre
@ eGaussLobattoLegendre
1D Gauss-Lobatto-Legendre quadrature points
Definition: PointsType.h:53
Nektar::LocalRegions::SegExpSharedPtr
std::shared_ptr< SegExp > SegExpSharedPtr
Definition: SegExp.h:255
Vmath::Vsub
void Vsub(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Subtract vector z = x-y.
Definition: Vmath.cpp:419

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::StdRegions::StdExpansion::DetShapeType(), Blas::Dgemv(), Nektar::StdRegions::eForwards, Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::StdRegions::eMass, Nektar::LocalRegions::Expansion2D::GetGeom2D(), Nektar::StdRegions::StdExpansion::GetInteriorMap(), Nektar::StdRegions::StdExpansion::GetPointsType(), Nektar::StdRegions::StdExpansion::GetTraceToElementMap(), Nektar::LibUtilities::Interp1D(), Nektar::StdRegions::StdExpansion::IProductWRTBase(), Nektar::StdRegions::StdExpansion::m_base, Nektar::StdRegions::StdExpansion::m_ncoeffs, m_staticCondMatrixManager, Nektar::StdRegions::StdExpansion::MassMatrixOp(), Nektar::StdRegions::StdExpansion::NumBndryCoeffs(), sign, and Vmath::Vsub().

◆ v_GeneralMatrixOp_MatOp()

void Nektar::LocalRegions::TriExp::v_GeneralMatrixOp_MatOp ( const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray,
const StdRegions::StdMatrixKey &  mkey 
)
protectedvirtual

Reimplemented from Nektar::StdRegions::StdTriExp.

Definition at line 1221 of file TriExp.cpp.

1224 {
1225  DNekScalMatSharedPtr mat = GetLocMatrix(mkey);
1226 
1227  if (inarray.get() == outarray.get())
1228  {
1229  Array<OneD, NekDouble> tmp(m_ncoeffs);
1230  Vmath::Vcopy(m_ncoeffs, inarray.get(), 1, tmp.get(), 1);
1231 
1232  Blas::Dgemv('N', m_ncoeffs, m_ncoeffs, mat->Scale(),
1233  (mat->GetOwnedMatrix())->GetPtr().get(), m_ncoeffs,
1234  tmp.get(), 1, 0.0, outarray.get(), 1);
1235  }
1236  else
1237  {
1238  Blas::Dgemv('N', m_ncoeffs, m_ncoeffs, mat->Scale(),
1239  (mat->GetOwnedMatrix())->GetPtr().get(), m_ncoeffs,
1240  inarray.get(), 1, 0.0, outarray.get(), 1);
1241  }
1242 }
Nektar::LocalRegions::Expansion::GetLocMatrix
DNekScalMatSharedPtr GetLocMatrix(const LocalRegions::MatrixKey &mkey)
Definition: Expansion.cpp:88

References Blas::Dgemv(), Nektar::LocalRegions::Expansion::GetLocMatrix(), Nektar::StdRegions::StdExpansion::m_ncoeffs, and Vmath::Vcopy().

◆ v_GenMatrix()

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

Reimplemented from Nektar::StdRegions::StdTriExp.

Definition at line 1123 of file TriExp.cpp.

1124 {
1125  DNekMatSharedPtr returnval;
1126  switch (mkey.GetMatrixType())
1127  {
1128  case StdRegions::eHybridDGHelmholtz:
1129  case StdRegions::eHybridDGLamToU:
1130  case StdRegions::eHybridDGLamToQ0:
1131  case StdRegions::eHybridDGLamToQ1:
1132  case StdRegions::eHybridDGLamToQ2:
1133  case StdRegions::eHybridDGHelmBndLam:
1134  case StdRegions::eInvLaplacianWithUnityMean:
1135  returnval = Expansion2D::v_GenMatrix(mkey);
1136  break;
1137  default:
1138  returnval = StdTriExp::v_GenMatrix(mkey);
1139  break;
1140  }
1141 
1142  return returnval;
1143 }
Nektar::LocalRegions::Expansion2D::v_GenMatrix
virtual DNekMatSharedPtr v_GenMatrix(const StdRegions::StdMatrixKey &mkey)
Definition: Expansion2D.cpp:1085
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::Expansion2D::v_GenMatrix().

◆ v_GetBasis()

const LibUtilities::BasisSharedPtr & Nektar::LocalRegions::TriExp::v_GetBasis ( int  dir) const
protectedvirtual

Definition at line 1112 of file TriExp.cpp.

1113 {
1114  ASSERTL1(dir >= 0 && dir <= 1, "input dir is out of range");
1115  return m_base[dir];
1116 }

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

◆ v_GetCoord()

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 719 of file TriExp.cpp.

721 {
722  int i;
723 
724  ASSERTL1(Lcoords[0] >= -1.0 && Lcoords[1] <= 1.0 && Lcoords[1] >= -1.0 &&
725  Lcoords[1] <= 1.0,
726  "Local coordinates are not in region [-1,1]");
727 
728  m_geom->FillGeom();
729 
730  for (i = 0; i < m_geom->GetCoordim(); ++i)
731  {
732  coords[i] = m_geom->GetCoord(i, Lcoords);
733  }
734 }

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

◆ v_GetCoordim()

int Nektar::LocalRegions::TriExp::v_GetCoordim ( void  )
protectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion2D.

Definition at line 1062 of file TriExp.cpp.

1063 {
1064  return m_geom->GetCoordim();
1065 }

References Nektar::LocalRegions::Expansion::m_geom.

◆ v_GetCoords()

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

Reimplemented from Nektar::StdRegions::StdTriExp.

Definition at line 736 of file TriExp.cpp.

739 {
740  Expansion::v_GetCoords(coords_0, coords_1, coords_2);
741 }
Nektar::LocalRegions::Expansion::v_GetCoords
virtual void v_GetCoords(Array< OneD, NekDouble > &coords_1, Array< OneD, NekDouble > &coords_2, Array< OneD, NekDouble > &coords_3)
Definition: Expansion.cpp:524

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

◆ v_GetEdgeInterpVals()

void Nektar::LocalRegions::TriExp::v_GetEdgeInterpVals ( const int  edge,
const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray 
)
protectedvirtual

Definition at line 826 of file TriExp.cpp.

829 {
830  boost::ignore_unused(edge, inarray, outarray);
831  ASSERTL0(false, "Routine not implemented for triangular elements");
832 }

References ASSERTL0.

◆ v_GetLinStdExp()

StdRegions::StdExpansionSharedPtr Nektar::LocalRegions::TriExp::v_GetLinStdExp ( void  ) const
protectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 708 of file TriExp.cpp.

709 {
710  LibUtilities::BasisKey bkey0(m_base[0]->GetBasisType(), 2,
711  m_base[0]->GetPointsKey());
712  LibUtilities::BasisKey bkey1(m_base[1]->GetBasisType(), 2,
713  m_base[1]->GetPointsKey());
714 
715  return MemoryManager<StdRegions::StdTriExp>::AllocateSharedPtr(bkey0,
716  bkey1);
717 }

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

◆ v_GetLocMatrix()

DNekScalMatSharedPtr Nektar::LocalRegions::TriExp::v_GetLocMatrix ( const MatrixKey &  mkey)
protectedvirtual

Reimplemented from Nektar::LocalRegions::Expansion.

Definition at line 1155 of file TriExp.cpp.

1156 {
1157  return m_matrixManager[mkey];
1158 }

References m_matrixManager.

◆ v_GetLocStaticCondMatrix()

DNekScalBlkMatSharedPtr Nektar::LocalRegions::TriExp::v_GetLocStaticCondMatrix ( const MatrixKey &  mkey)
protectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 1160 of file TriExp.cpp.

1161 {
1162  return m_staticCondMatrixManager[mkey];
1163 }

References m_staticCondMatrixManager.

◆ v_GetNumPoints()

int Nektar::LocalRegions::TriExp::v_GetNumPoints ( const int  dir) const
protectedvirtual

Definition at line 1118 of file TriExp.cpp.

1119 {
1120  return GetNumPoints(dir);
1121 }

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

◆ v_GetStdExp()

StdRegions::StdExpansionSharedPtr Nektar::LocalRegions::TriExp::v_GetStdExp ( void  ) const
protectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 701 of file TriExp.cpp.

702 {
703 
704  return MemoryManager<StdRegions::StdTriExp>::AllocateSharedPtr(
705  m_base[0]->GetBasisKey(), m_base[1]->GetBasisKey());
706 }

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

◆ v_GetTraceOrient()

StdRegions::Orientation Nektar::LocalRegions::TriExp::v_GetTraceOrient ( int  edge)
protectedvirtual

Reimplemented from Nektar::LocalRegions::Expansion.

Definition at line 1107 of file TriExp.cpp.

1108 {
1109  return GetGeom2D()->GetEorient(edge);
1110 }

References Nektar::LocalRegions::Expansion2D::GetGeom2D().

◆ v_GetTracePhysMap()

void Nektar::LocalRegions::TriExp::v_GetTracePhysMap ( const int  edge,
Array< OneD, int > &  outarray 
)
protectedvirtual

Reimplemented from Nektar::LocalRegions::Expansion.

Definition at line 841 of file TriExp.cpp.

842 {
843  int nquad0 = m_base[0]->GetNumPoints();
844  int nquad1 = m_base[1]->GetNumPoints();
845 
846  // Get points in Cartesian orientation
847  switch (edge)
848  {
849  case 0:
850  outarray = Array<OneD, int>(nquad0);
851  for (int i = 0; i < nquad0; ++i)
852  {
853  outarray[i] = i;
854  }
855  break;
856  case 1:
857  outarray = Array<OneD, int>(nquad1);
858  for (int i = 0; i < nquad1; ++i)
859  {
860  outarray[i] = (nquad0 - 1) + i * nquad0;
861  }
862  break;
863  case 2:
864  outarray = Array<OneD, int>(nquad1);
865  for (int i = 0; i < nquad1; ++i)
866  {
867  outarray[i] = i * nquad0;
868  }
869  break;
870  default:
871  ASSERTL0(false, "edge value (< 3) is out of range");
872  break;
873  }
874 }

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

◆ v_GetTracePhysVals()

void Nektar::LocalRegions::TriExp::v_GetTracePhysVals ( const int  edge,
const StdRegions::StdExpansionSharedPtr &  EdgeExp,
const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray,
StdRegions::Orientation  orient 
)
protectedvirtual

Reimplemented from Nektar::LocalRegions::Expansion.

Definition at line 767 of file TriExp.cpp.

771 {
772  int nquad0 = m_base[0]->GetNumPoints();
773  int nquad1 = m_base[1]->GetNumPoints();
774  int nt = 0;
775  // Extract in Cartesian direction because we have to deal with
776  // e.g. Gauss-Radau points.
777  switch (edge)
778  {
779  case 0:
780  Vmath::Vcopy(nquad0, &(inarray[0]), 1, &(outarray[0]), 1);
781  nt = nquad0;
782  break;
783  case 1:
784  Vmath::Vcopy(nquad1, &(inarray[0]) + (nquad0 - 1), nquad0,
785  &(outarray[0]), 1);
786  nt = nquad1;
787  break;
788  case 2:
789  Vmath::Vcopy(nquad1, &(inarray[0]), nquad0, &(outarray[0]), 1);
790  nt = nquad1;
791  break;
792  default:
793  ASSERTL0(false, "edge value (< 3) is out of range");
794  break;
795  }
796 
797  ASSERTL1(EdgeExp->GetBasis(0)->GetPointsType() ==
798  LibUtilities::eGaussLobattoLegendre,
799  "Edge expansion should be GLL");
800 
801  // Interpolate if required
802  if (m_base[edge ? 1 : 0]->GetPointsKey() !=
803  EdgeExp->GetBasis(0)->GetPointsKey())
804  {
805  Array<OneD, NekDouble> outtmp(max(nquad0, nquad1));
806 
807  Vmath::Vcopy(nt, outarray, 1, outtmp, 1);
808 
809  LibUtilities::Interp1D(m_base[edge ? 1 : 0]->GetPointsKey(), outtmp,
810  EdgeExp->GetBasis(0)->GetPointsKey(), outarray);
811  }
812 
813  if (orient == StdRegions::eNoOrientation)
814  {
815  orient = GetTraceOrient(edge);
816  }
817 
818  // Reverse data if necessary
819  if (orient == StdRegions::eBackwards)
820  {
821  Vmath::Reverse(EdgeExp->GetNumPoints(0), &outarray[0], 1, &outarray[0],
822  1);
823  }
824 }
Nektar::LocalRegions::Expansion::GetTraceOrient
StdRegions::Orientation GetTraceOrient(int trace)
Definition: Expansion.h:167

References ASSERTL0, ASSERTL1, Nektar::StdRegions::eBackwards, Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::StdRegions::eNoOrientation, Nektar::LocalRegions::Expansion::GetTraceOrient(), Nektar::LibUtilities::Interp1D(), Nektar::StdRegions::StdExpansion::m_base, Vmath::Reverse(), and Vmath::Vcopy().

◆ v_GetTraceQFactors()

void Nektar::LocalRegions::TriExp::v_GetTraceQFactors ( const int  edge,
Array< OneD, NekDouble > &  outarray 
)
protectedvirtual

Reimplemented from Nektar::LocalRegions::Expansion.

Definition at line 834 of file TriExp.cpp.

836 {
837  boost::ignore_unused(edge, outarray);
838  ASSERTL0(false, "Routine not implemented for triangular elements");
839 }

References ASSERTL0.

◆ v_HelmholtzMatrixOp()

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

Reimplemented from Nektar::StdRegions::StdTriExp.

Definition at line 1214 of file TriExp.cpp.

1217 {
1218  TriExp::HelmholtzMatrixOp_MatFree(inarray, outarray, mkey);
1219 }
Nektar::StdRegions::StdExpansion::HelmholtzMatrixOp_MatFree
void HelmholtzMatrixOp_MatFree(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
Definition: StdExpansion.h:1256

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

◆ v_Integral()

NekDouble Nektar::LocalRegions::TriExp::v_Integral ( const Array< OneD, const NekDouble > &  inarray)
protectedvirtual

Integrates the specified function over the domain.

See also
StdRegions::StdExpansion::Integral.

Reimplemented from Nektar::StdRegions::StdTriExp.

Definition at line 79 of file TriExp.cpp.

80 {
81  int nquad0 = m_base[0]->GetNumPoints();
82  int nquad1 = m_base[1]->GetNumPoints();
83  Array<OneD, const NekDouble> jac = m_metricinfo->GetJac(GetPointsKeys());
84  NekDouble ival;
85  Array<OneD, NekDouble> tmp(nquad0 * nquad1);
86 
87  // multiply inarray with Jacobian
88  if (m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
89  {
90  Vmath::Vmul(nquad0 * nquad1, jac, 1, inarray, 1, tmp, 1);
91  }
92  else
93  {
94  Vmath::Smul(nquad0 * nquad1, jac[0], inarray, 1, tmp, 1);
95  }
96 
97  // call StdQuadExp version;
98  ival = StdTriExp::v_Integral(tmp);
99  return ival;
100 }

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::TriExp::v_IProductWRTBase ( const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray 
)
protectedvirtual

Calculate the inner product of inarray with respect to the basis B=base0[p]*base1[pq] and put into outarray.

\( \begin{array}{rcl} I_{pq} = (\phi^A_q \phi^B_{pq}, u) &=& \sum_{i=0}^{nq_0}\sum_{j=0}^{nq_1} \phi^A_p(\eta_{0,i})\phi^B_{pq}(\eta_{1,j}) w^0_i w^1_j u(\xi_{0,i} \xi_{1,j}) \\ & = & \sum_{i=0}^{nq_0} \phi^A_p(\eta_{0,i}) \sum_{j=0}^{nq_1} \phi^B_{pq}(\eta_{1,j}) \tilde{u}_{i,j} \end{array} \)

where

\( \tilde{u}_{i,j} = w^0_i w^1_j u(\xi_{0,i},\xi_{1,j}) \)

which can be implemented as

\( f_{pj} = \sum_{i=0}^{nq_0} \phi^A_p(\eta_{0,i}) \tilde{u}_{i,j} \rightarrow {\bf B_1 U} \) \( I_{pq} = \sum_{j=0}^{nq_1} \phi^B_{pq}(\eta_{1,j}) f_{pj} \rightarrow {\bf B_2[p*skip] f[skip]} \)

Recall: \( \eta_{1} = \frac{2(1+\xi_1)}{(1-\xi_2)}-1, \, \eta_2 = \xi_2\)

Note: For the orthgonality of this expansion to be realised the 'q' ordering must run fastest in contrast to the Quad and Hex ordering where 'p' index runs fastest to be consistent with the quadrature ordering.

In the triangular space the i (i.e. \(\eta_1\) direction) ordering still runs fastest by convention.

Reimplemented from Nektar::StdRegions::StdTriExp.

Definition at line 400 of file TriExp.cpp.

402 {
403  IProductWRTBase_SumFac(inarray, outarray);
404 }
Nektar::StdRegions::StdExpansion::IProductWRTBase_SumFac
void IProductWRTBase_SumFac(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, bool multiplybyweights=true)
Definition: StdExpansion.h:1130

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

◆ v_IProductWRTBase_MatOp()

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

Reimplemented from Nektar::StdRegions::StdTriExp.

Definition at line 440 of file TriExp.cpp.

443 {
444  int nq = GetTotPoints();
445  MatrixKey iprodmatkey(StdRegions::eIProductWRTBase, DetShapeType(), *this);
446  DNekScalMatSharedPtr iprodmat = m_matrixManager[iprodmatkey];
447 
448  Blas::Dgemv('N', m_ncoeffs, nq, iprodmat->Scale(),
449  (iprodmat->GetOwnedMatrix())->GetPtr().get(), m_ncoeffs,
450  inarray.get(), 1, 0.0, outarray.get(), 1);
451 }

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

◆ v_IProductWRTBase_SumFac()

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

Reimplemented from Nektar::StdRegions::StdTriExp.

Definition at line 413 of file TriExp.cpp.

416 {
417  int nquad0 = m_base[0]->GetNumPoints();
418  int nquad1 = m_base[1]->GetNumPoints();
419  int order0 = m_base[0]->GetNumModes();
420 
421  if (multiplybyweights)
422  {
423  Array<OneD, NekDouble> tmp(nquad0 * nquad1 + nquad1 * order0);
424  Array<OneD, NekDouble> wsp(tmp + nquad0 * nquad1);
425 
426  MultiplyByQuadratureMetric(inarray, tmp);
427  IProductWRTBase_SumFacKernel(m_base[0]->GetBdata(),
428  m_base[1]->GetBdata(), tmp, outarray, wsp);
429  }
430  else
431  {
432  Array<OneD, NekDouble> wsp(+nquad1 * order0);
433 
434  IProductWRTBase_SumFacKernel(m_base[0]->GetBdata(),
435  m_base[1]->GetBdata(), inarray, outarray,
436  wsp);
437  }
438 }
Nektar::StdRegions::StdExpansion2D::IProductWRTBase_SumFacKernel
void IProductWRTBase_SumFacKernel(const Array< OneD, const NekDouble > &base0, const Array< OneD, const NekDouble > &base1, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, Array< OneD, NekDouble > &wsp, bool doCheckCollDir0=true, bool doCheckCollDir1=true)
Definition: StdExpansion2D.cpp:204

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

◆ v_IProductWRTDerivBase()

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

Reimplemented from Nektar::StdRegions::StdTriExp.

Definition at line 406 of file TriExp.cpp.

409 {
410  IProductWRTDerivBase_SumFac(dir, inarray, outarray);
411 }
Nektar::StdRegions::StdExpansion::IProductWRTDerivBase_SumFac
void IProductWRTDerivBase_SumFac(const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
Definition: StdExpansion.h:1185

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

◆ v_IProductWRTDerivBase_MatOp()

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

Reimplemented from Nektar::StdRegions::StdTriExp.

Definition at line 549 of file TriExp.cpp.

552 {
553  int nq = GetTotPoints();
554  StdRegions::MatrixType mtype = StdRegions::eIProductWRTDerivBase0;
555 
556  switch (dir)
557  {
558  case 0:
559  {
560  mtype = StdRegions::eIProductWRTDerivBase0;
561  }
562  break;
563  case 1:
564  {
565  mtype = StdRegions::eIProductWRTDerivBase1;
566  }
567  break;
568  case 2:
569  {
570  mtype = StdRegions::eIProductWRTDerivBase2;
571  }
572  break;
573  default:
574  {
575  ASSERTL1(false, "input dir is out of range");
576  }
577  break;
578  }
579 
580  MatrixKey iprodmatkey(mtype, DetShapeType(), *this);
581  DNekScalMatSharedPtr iprodmat = m_matrixManager[iprodmatkey];
582 
583  Blas::Dgemv('N', m_ncoeffs, nq, iprodmat->Scale(),
584  (iprodmat->GetOwnedMatrix())->GetPtr().get(), m_ncoeffs,
585  inarray.get(), 1, 0.0, outarray.get(), 1);
586 }

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

◆ v_IProductWRTDerivBase_SumFac()

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

Reimplemented from Nektar::StdRegions::StdTriExp.

Definition at line 453 of file TriExp.cpp.

456 {
457  int nquad0 = m_base[0]->GetNumPoints();
458  int nquad1 = m_base[1]->GetNumPoints();
459  int nqtot = nquad0 * nquad1;
460  int nmodes0 = m_base[0]->GetNumModes();
461  int wspsize = max(max(nqtot, m_ncoeffs), nquad1 * nmodes0);
462 
463  Array<OneD, NekDouble> tmp0(4 * wspsize);
464  Array<OneD, NekDouble> tmp1(tmp0 + wspsize);
465  Array<OneD, NekDouble> tmp2(tmp0 + 2 * wspsize);
466  Array<OneD, NekDouble> tmp3(tmp0 + 3 * wspsize);
467 
468  Array<OneD, Array<OneD, NekDouble>> tmp2D{2};
469  tmp2D[0] = tmp1;
470  tmp2D[1] = tmp2;
471 
472  TriExp::v_AlignVectorToCollapsedDir(dir, inarray, tmp2D);
473 
474  MultiplyByQuadratureMetric(tmp1, tmp1);
475  MultiplyByQuadratureMetric(tmp2, tmp2);
476 
477  IProductWRTBase_SumFacKernel(m_base[0]->GetDbdata(), m_base[1]->GetBdata(),
478  tmp1, tmp3, tmp0);
479  IProductWRTBase_SumFacKernel(m_base[0]->GetBdata(), m_base[1]->GetDbdata(),
480  tmp2, outarray, tmp0);
481  Vmath::Vadd(m_ncoeffs, tmp3, 1, outarray, 1, outarray, 1);
482 }
Nektar::LocalRegions::TriExp::v_AlignVectorToCollapsedDir
virtual void v_AlignVectorToCollapsedDir(const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, Array< OneD, NekDouble >> &outarray)
Definition: TriExp.cpp:484

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

◆ v_IProductWRTDirectionalDerivBase()

void Nektar::LocalRegions::TriExp::v_IProductWRTDirectionalDerivBase ( const Array< OneD, const NekDouble > &  direction,
const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray 
)
protectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 588 of file TriExp.cpp.

592 {
593  IProductWRTDirectionalDerivBase_SumFac(direction, inarray, outarray);
594 }
Nektar::StdRegions::StdExpansion::IProductWRTDirectionalDerivBase_SumFac
void IProductWRTDirectionalDerivBase_SumFac(const Array< OneD, const NekDouble > &direction, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
Definition: StdExpansion.h:1192

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

◆ v_IProductWRTDirectionalDerivBase_SumFac()

void Nektar::LocalRegions::TriExp::v_IProductWRTDirectionalDerivBase_SumFac ( const Array< OneD, const NekDouble > &  direction,
const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray 
)
protectedvirtual

Directinoal Derivative in the modal space in the dir direction of varcoeffs.

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 600 of file TriExp.cpp.

604 {
605  int i;
606  int shapedim = 2;
607  int nquad0 = m_base[0]->GetNumPoints();
608  int nquad1 = m_base[1]->GetNumPoints();
609  int nqtot = nquad0 * nquad1;
610  int nmodes0 = m_base[0]->GetNumModes();
611  int wspsize = max(max(nqtot, m_ncoeffs), nquad1 * nmodes0);
612 
613  const Array<TwoD, const NekDouble> &df =
614  m_metricinfo->GetDerivFactors(GetPointsKeys());
615 
616  Array<OneD, NekDouble> tmp0(6 * wspsize);
617  Array<OneD, NekDouble> tmp1(tmp0 + wspsize);
618  Array<OneD, NekDouble> tmp2(tmp0 + 2 * wspsize);
619  Array<OneD, NekDouble> tmp3(tmp0 + 3 * wspsize);
620  Array<OneD, NekDouble> gfac0(tmp0 + 4 * wspsize);
621  Array<OneD, NekDouble> gfac1(tmp0 + 5 * wspsize);
622 
623  const Array<OneD, const NekDouble> &z0 = m_base[0]->GetZ();
624  const Array<OneD, const NekDouble> &z1 = m_base[1]->GetZ();
625 
626  // set up geometric factor: 2/(1-z1)
627  for (i = 0; i < nquad1; ++i)
628  {
629  gfac0[i] = 2.0 / (1 - z1[i]);
630  }
631  for (i = 0; i < nquad0; ++i)
632  {
633  gfac1[i] = 0.5 * (1 + z0[i]);
634  }
635  for (i = 0; i < nquad1; ++i)
636  {
637  Vmath::Smul(nquad0, gfac0[i], &inarray[0] + i * nquad0, 1,
638  &tmp0[0] + i * nquad0, 1);
639  }
640  for (i = 0; i < nquad1; ++i)
641  {
642  Vmath::Vmul(nquad0, &gfac1[0], 1, &tmp0[0] + i * nquad0, 1,
643  &tmp1[0] + i * nquad0, 1);
644  }
645 
646  // Compute gmat \cdot e^j
647  Array<OneD, Array<OneD, NekDouble>> dfdir(shapedim);
648  Expansion::ComputeGmatcdotMF(df, direction, dfdir);
649 
650  Vmath::Vmul(nqtot, &dfdir[0][0], 1, &tmp0[0], 1, &tmp0[0], 1);
651  Vmath::Vmul(nqtot, &dfdir[1][0], 1, &tmp1[0], 1, &tmp1[0], 1);
652  Vmath::Vmul(nqtot, &dfdir[1][0], 1, &inarray[0], 1, &tmp2[0], 1);
653 
654  Vmath::Vadd(nqtot, &tmp0[0], 1, &tmp1[0], 1, &tmp1[0], 1);
655 
656  MultiplyByQuadratureMetric(tmp1, tmp1);
657  MultiplyByQuadratureMetric(tmp2, tmp2);
658 
659  IProductWRTBase_SumFacKernel(m_base[0]->GetDbdata(), m_base[1]->GetBdata(),
660  tmp1, tmp3, tmp0);
661  IProductWRTBase_SumFacKernel(m_base[0]->GetBdata(), m_base[1]->GetDbdata(),
662  tmp2, outarray, tmp0);
663  Vmath::Vadd(m_ncoeffs, tmp3, 1, outarray, 1, outarray, 1);
664 }
Nektar::LocalRegions::Expansion::ComputeGmatcdotMF
void ComputeGmatcdotMF(const Array< TwoD, const NekDouble > &df, const Array< OneD, const NekDouble > &direction, Array< OneD, Array< OneD, NekDouble >> &dfdir)
Definition: Expansion.cpp:597

References Nektar::LocalRegions::Expansion::ComputeGmatcdotMF(), Nektar::StdRegions::StdExpansion::GetPointsKeys(), Nektar::StdRegions::StdExpansion2D::IProductWRTBase_SumFacKernel(), Nektar::StdRegions::StdExpansion::m_base, Nektar::LocalRegions::Expansion::m_metricinfo, Nektar::StdRegions::StdExpansion::m_ncoeffs, Nektar::StdRegions::StdExpansion::MultiplyByQuadratureMetric(), Vmath::Smul(), Vmath::Vadd(), and Vmath::Vmul().

◆ v_LaplacianMatrixOp() [1/2]

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

Reimplemented from Nektar::StdRegions::StdTriExp.

Definition at line 1177 of file TriExp.cpp.

1180 {
1181  TriExp::LaplacianMatrixOp_MatFree(inarray, outarray, mkey);
1182 }
Nektar::StdRegions::StdExpansion::LaplacianMatrixOp_MatFree
void LaplacianMatrixOp_MatFree(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
Definition: StdExpansion.h:1217

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

◆ v_LaplacianMatrixOp() [2/2]

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

Reimplemented from Nektar::StdRegions::StdTriExp.

Definition at line 1184 of file TriExp.cpp.

1188 {
1189  StdExpansion::LaplacianMatrixOp_MatFree(k1, k2, inarray, outarray, mkey);
1190 }

◆ v_LaplacianMatrixOp_MatFree_Kernel()

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 1244 of file TriExp.cpp.

1247 {
1248  if (m_metrics.count(eMetricLaplacian00) == 0)
1249  {
1250  ComputeLaplacianMetric();
1251  }
1252 
1253  int nquad0 = m_base[0]->GetNumPoints();
1254  int nquad1 = m_base[1]->GetNumPoints();
1255  int nqtot = nquad0 * nquad1;
1256  int nmodes0 = m_base[0]->GetNumModes();
1257  int nmodes1 = m_base[1]->GetNumModes();
1258  int wspsize =
1259  max(max(max(nqtot, m_ncoeffs), nquad1 * nmodes0), nquad0 * nmodes1);
1260 
1261  ASSERTL1(wsp.size() >= 3 * wspsize, "Workspace is of insufficient size.");
1262 
1263  const Array<OneD, const NekDouble> &base0 = m_base[0]->GetBdata();
1264  const Array<OneD, const NekDouble> &base1 = m_base[1]->GetBdata();
1265  const Array<OneD, const NekDouble> &dbase0 = m_base[0]->GetDbdata();
1266  const Array<OneD, const NekDouble> &dbase1 = m_base[1]->GetDbdata();
1267  const Array<OneD, const NekDouble> &metric00 =
1268  m_metrics[eMetricLaplacian00];
1269  const Array<OneD, const NekDouble> &metric01 =
1270  m_metrics[eMetricLaplacian01];
1271  const Array<OneD, const NekDouble> &metric11 =
1272  m_metrics[eMetricLaplacian11];
1273 
1274  // Allocate temporary storage
1275  Array<OneD, NekDouble> wsp0(wsp);
1276  Array<OneD, NekDouble> wsp1(wsp + wspsize);
1277  Array<OneD, NekDouble> wsp2(wsp + 2 * wspsize);
1278 
1279  StdExpansion2D::PhysTensorDeriv(inarray, wsp1, wsp2);
1280 
1281  // wsp0 = k = g0 * wsp1 + g1 * wsp2 = g0 * du_dxi1 + g1 * du_dxi2
1282  // wsp2 = l = g1 * wsp1 + g2 * wsp2 = g0 * du_dxi1 + g1 * du_dxi2
1283  // where g0, g1 and g2 are the metric terms set up in the GeomFactors class
1284  // especially for this purpose
1285  Vmath::Vvtvvtp(nqtot, &metric00[0], 1, &wsp1[0], 1, &metric01[0], 1,
1286  &wsp2[0], 1, &wsp0[0], 1);
1287  Vmath::Vvtvvtp(nqtot, &metric01[0], 1, &wsp1[0], 1, &metric11[0], 1,
1288  &wsp2[0], 1, &wsp2[0], 1);
1289 
1290  // outarray = m = (D_xi1 * B)^T * k
1291  // wsp1 = n = (D_xi2 * B)^T * l
1292  IProductWRTBase_SumFacKernel(dbase0, base1, wsp0, outarray, wsp1);
1293  IProductWRTBase_SumFacKernel(base0, dbase1, wsp2, wsp1, wsp0);
1294 
1295  // outarray = outarray + wsp1
1296  // = L * u_hat
1297  Vmath::Vadd(m_ncoeffs, wsp1.get(), 1, outarray.get(), 1, outarray.get(), 1);
1298 }
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:692

References ASSERTL1, Nektar::LocalRegions::Expansion::ComputeLaplacianMetric(), Nektar::LocalRegions::eMetricLaplacian00, Nektar::LocalRegions::eMetricLaplacian01, Nektar::LocalRegions::eMetricLaplacian11, Nektar::StdRegions::StdExpansion2D::IProductWRTBase_SumFacKernel(), Nektar::StdRegions::StdExpansion::m_base, Nektar::LocalRegions::Expansion::m_metrics, Nektar::StdRegions::StdExpansion::m_ncoeffs, Vmath::Vadd(), and Vmath::Vvtvvtp().

◆ v_MassLevelCurvatureMatrixOp()

void Nektar::LocalRegions::TriExp::v_MassLevelCurvatureMatrixOp ( const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray,
const StdRegions::StdMatrixKey &  mkey 
)
protectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 1207 of file TriExp.cpp.

1210 {
1211  StdExpansion::MassLevelCurvatureMatrixOp_MatFree(inarray, outarray, mkey);
1212 }

◆ v_MassMatrixOp()

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

Reimplemented from Nektar::StdRegions::StdTriExp.

Definition at line 1170 of file TriExp.cpp.

1173 {
1174  StdExpansion::MassMatrixOp_MatFree(inarray, outarray, mkey);
1175 }

◆ v_NormalTraceDerivFactors()

void Nektar::LocalRegions::TriExp::v_NormalTraceDerivFactors ( Array< OneD, Array< OneD, NekDouble >> &  factors,
Array< OneD, Array< OneD, NekDouble >> &  d0factors,
Array< OneD, Array< OneD, NekDouble >> &  d1factors 
)
protectedvirtual

: 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 1544 of file TriExp.cpp.

1548 {
1549  boost::ignore_unused(d2factors); // for 3D shapes
1550  int nquad0 = GetNumPoints(0);
1551  int nquad1 = GetNumPoints(1);
1552 
1553  const Array<TwoD, const NekDouble> &df =
1554  m_metricinfo->GetDerivFactors(GetPointsKeys());
1555 
1556  if (d0factors.size() != 3)
1557  {
1558  d0factors = Array<OneD, Array<OneD, NekDouble>>(3);
1559  d1factors = Array<OneD, Array<OneD, NekDouble>>(3);
1560  }
1561 
1562  if (d0factors[0].size() != nquad0)
1563  {
1564  d0factors[0] = Array<OneD, NekDouble>(nquad0);
1565  d1factors[0] = Array<OneD, NekDouble>(nquad0);
1566  }
1567 
1568  if (d0factors[1].size() != nquad1)
1569  {
1570  d0factors[1] = Array<OneD, NekDouble>(nquad1);
1571  d0factors[2] = Array<OneD, NekDouble>(nquad1);
1572  d1factors[1] = Array<OneD, NekDouble>(nquad1);
1573  d1factors[2] = Array<OneD, NekDouble>(nquad1);
1574  }
1575 
1576  // Outwards normals
1577  const Array<OneD, const Array<OneD, NekDouble>> &normal_0 =
1578  GetTraceNormal(0);
1579  const Array<OneD, const Array<OneD, NekDouble>> &normal_1 =
1580  GetTraceNormal(1);
1581  const Array<OneD, const Array<OneD, NekDouble>> &normal_2 =
1582  GetTraceNormal(2);
1583 
1584  int ncoords = normal_0.size();
1585 
1586  if (m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
1587  {
1588 
1589  // d xi_2/dx n_x
1590  for (int i = 0; i < nquad0; ++i)
1591  {
1592  d1factors[0][i] = df[1][i] * normal_0[0][i];
1593  }
1594 
1595  // d xi_1/dx n_x
1596  for (int i = 0; i < nquad1; ++i)
1597  {
1598  d0factors[1][i] = df[0][(i + 1) * nquad0 - 1] * normal_1[0][i];
1599  d0factors[2][i] = df[0][i * nquad0] * normal_2[0][i];
1600  }
1601 
1602  for (int n = 1; n < ncoords; ++n)
1603  {
1604  // d xi_2/dy n_y
1605  // needs checking for 3D coords
1606  for (int i = 0; i < nquad0; ++i)
1607  {
1608  d1factors[0][i] += df[2 * n + 1][i] * normal_0[n][i];
1609  }
1610 
1611  // d xi_1/dy n_y
1612  // needs checking for 3D coords
1613  for (int i = 0; i < nquad1; ++i)
1614  {
1615  d0factors[1][i] +=
1616  df[2 * n][(i + 1) * nquad0 - 1] * normal_1[n][i];
1617  d0factors[2][i] += df[2 * n][i * nquad0] * normal_2[n][i];
1618  }
1619  }
1620 
1621  // d0 factors
1622  // d xi_1/dx n_x
1623  for (int i = 0; i < nquad0; ++i)
1624  {
1625  d0factors[0][i] = df[0][i] * normal_0[0][i];
1626  }
1627 
1628  // d xi_2/dx n_x
1629  for (int i = 0; i < nquad1; ++i)
1630  {
1631  d1factors[1][i] = df[1][(i + 1) * nquad0 - 1] * normal_1[0][i];
1632  d1factors[2][i] = df[1][i * nquad0] * normal_2[0][i];
1633  }
1634 
1635  for (int n = 1; n < ncoords; ++n)
1636  {
1637  // d xi_1/dy n_y
1638  // needs checking for 3D coords
1639  for (int i = 0; i < nquad0; ++i)
1640  {
1641  d0factors[0][i] += df[2 * n][i] * normal_0[n][i];
1642  }
1643 
1644  // d xi_2/dy n_y
1645  // needs checking for 3D coords
1646  for (int i = 0; i < nquad1; ++i)
1647  {
1648  d1factors[1][i] +=
1649  df[2 * n + 1][(i + 1) * nquad0 - 1] * normal_1[n][i];
1650  d1factors[2][i] += df[2 * n + 1][i * nquad0] * normal_2[n][i];
1651  }
1652  }
1653  }
1654  else
1655  {
1656  // d xi_2/dx n_x
1657  for (int i = 0; i < nquad0; ++i)
1658  {
1659  d1factors[0][i] = df[1][0] * normal_0[0][i];
1660  }
1661 
1662  // d xi_1/dx n_x
1663  for (int i = 0; i < nquad1; ++i)
1664  {
1665  d0factors[1][i] = df[0][0] * normal_1[0][i];
1666  d0factors[2][i] = df[0][0] * normal_2[0][i];
1667  }
1668 
1669  for (int n = 1; n < ncoords; ++n)
1670  {
1671  // d xi_2/dy n_y
1672  // needs checking for 3D coords
1673  for (int i = 0; i < nquad0; ++i)
1674  {
1675  d1factors[0][i] += df[2 * n + 1][0] * normal_0[n][i];
1676  }
1677 
1678  // d xi_1/dy n_y
1679  // needs checking for 3D coords
1680  for (int i = 0; i < nquad1; ++i)
1681  {
1682  d0factors[1][i] += df[2 * n][0] * normal_1[n][i];
1683  d0factors[2][i] += df[2 * n][0] * normal_2[n][i];
1684  }
1685  }
1686 
1687  // d1factors
1688  // d xi_1/dx n_x
1689  for (int i = 0; i < nquad0; ++i)
1690  {
1691  d0factors[0][i] = df[0][0] * normal_0[0][i];
1692  }
1693 
1694  // d xi_2/dx n_x
1695  for (int i = 0; i < nquad1; ++i)
1696  {
1697  d1factors[1][i] = df[1][0] * normal_1[0][i];
1698  d1factors[2][i] = df[1][0] * normal_2[0][i];
1699  }
1700 
1701  for (int n = 1; n < ncoords; ++n)
1702  {
1703  // d xi_1/dy n_y
1704  // needs checking for 3D coords
1705  for (int i = 0; i < nquad0; ++i)
1706  {
1707  d0factors[0][i] += df[2 * n][0] * normal_0[n][i];
1708  }
1709 
1710  // d xi_2/dy n_y
1711  // needs checking for 3D coords
1712  for (int i = 0; i < nquad1; ++i)
1713  {
1714  d1factors[1][i] += df[2 * n + 1][0] * normal_1[n][i];
1715  d1factors[2][i] += df[2 * n + 1][0] * normal_2[n][i];
1716  }
1717  }
1718  }
1719 }
Nektar::LocalRegions::Expansion::GetTraceNormal
const NormalVector & GetTraceNormal(const int id)
Definition: Expansion.cpp:250

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

◆ v_NormVectorIProductWRTBase() [1/2]

void Nektar::LocalRegions::TriExp::v_NormVectorIProductWRTBase ( const Array< OneD, const Array< OneD, NekDouble >> &  Fvec,
Array< OneD, NekDouble > &  outarray 
)
protectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 694 of file TriExp.cpp.

697 {
698  NormVectorIProductWRTBase(Fvec[0], Fvec[1], Fvec[2], outarray);
699 }
Nektar::StdRegions::StdExpansion::NormVectorIProductWRTBase
void NormVectorIProductWRTBase(const Array< OneD, const NekDouble > &Fx, Array< OneD, NekDouble > &outarray)
Definition: StdExpansion.h:621

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

◆ v_NormVectorIProductWRTBase() [2/2]

void Nektar::LocalRegions::TriExp::v_NormVectorIProductWRTBase ( const Array< OneD, const NekDouble > &  Fx,
const Array< OneD, const NekDouble > &  Fy,
const Array< OneD, const NekDouble > &  Fz,
Array< OneD, NekDouble > &  outarray 
)
protectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 666 of file TriExp.cpp.

670 {
671  int nq = m_base[0]->GetNumPoints() * m_base[1]->GetNumPoints();
672  Array<OneD, NekDouble> Fn(nq);
673 
674  const Array<OneD, const Array<OneD, NekDouble>> &normals =
675  GetLeftAdjacentElementExp()->GetTraceNormal(
676  GetLeftAdjacentElementTrace());
677 
678  if (m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
679  {
680  Vmath::Vvtvvtp(nq, &normals[0][0], 1, &Fx[0], 1, &normals[1][0], 1,
681  &Fy[0], 1, &Fn[0], 1);
682  Vmath::Vvtvp(nq, &normals[2][0], 1, &Fz[0], 1, &Fn[0], 1, &Fn[0], 1);
683  }
684  else
685  {
686  Vmath::Svtsvtp(nq, normals[0][0], &Fx[0], 1, normals[1][0], &Fy[0], 1,
687  &Fn[0], 1);
688  Vmath::Svtvp(nq, normals[2][0], &Fz[0], 1, &Fn[0], 1, &Fn[0], 1);
689  }
690 
691  IProductWRTBase(Fn, outarray);
692 }
Nektar::LocalRegions::Expansion::GetLeftAdjacentElementExp
ExpansionSharedPtr GetLeftAdjacentElementExp() const
Definition: Expansion.h:433
Nektar::LocalRegions::Expansion::GetLeftAdjacentElementTrace
int GetLeftAdjacentElementTrace() const
Definition: Expansion.h:446
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)
vvtvvtp (scalar times vector plus scalar times vector):
Definition: Vmath.cpp:751

References Nektar::SpatialDomains::eDeformed, Nektar::LocalRegions::Expansion::GetLeftAdjacentElementExp(), Nektar::LocalRegions::Expansion::GetLeftAdjacentElementTrace(), Nektar::StdRegions::StdExpansion::IProductWRTBase(), Nektar::StdRegions::StdExpansion::m_base, Nektar::LocalRegions::Expansion::m_metricinfo, Vmath::Svtsvtp(), Vmath::Svtvp(), Vmath::Vvtvp(), and Vmath::Vvtvvtp().

◆ v_PhysDeriv() [1/2]

void Nektar::LocalRegions::TriExp::v_PhysDeriv ( const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  out_d0,
Array< OneD, NekDouble > &  out_d1,
Array< OneD, NekDouble > &  out_d2 = NullNekDouble1DArray 
)
protectedvirtual

Calculate the derivative of the physical points.

\( \frac{\partial u}{\partial x_1} = \left . \frac{2.0}{1-\eta_2} \frac{\partial u}{\partial d\eta_1} \right |_{\eta_2}\)

\( \frac{\partial u}{\partial x_2} = \left . \frac{1+\eta_1}{1-\eta_2} \frac{\partial u}{\partial d\eta_1} \right |_{\eta_2} + \left . \frac{\partial u}{\partial d\eta_2} \right |_{\eta_1} \)

Reimplemented from Nektar::StdRegions::StdTriExp.

Definition at line 102 of file TriExp.cpp.

106 {
107  int nquad0 = m_base[0]->GetNumPoints();
108  int nquad1 = m_base[1]->GetNumPoints();
109  int nqtot = nquad0 * nquad1;
110  const Array<TwoD, const NekDouble> &df =
111  m_metricinfo->GetDerivFactors(GetPointsKeys());
112 
113  Array<OneD, NekDouble> diff0(2 * nqtot);
114  Array<OneD, NekDouble> diff1(diff0 + nqtot);
115 
116  StdTriExp::v_PhysDeriv(inarray, diff0, diff1);
117 
118  if (m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
119  {
120  if (out_d0.size())
121  {
122  Vmath::Vmul(nqtot, df[0], 1, diff0, 1, out_d0, 1);
123  Vmath::Vvtvp(nqtot, df[1], 1, diff1, 1, out_d0, 1, out_d0, 1);
124  }
125 
126  if (out_d1.size())
127  {
128  Vmath::Vmul(nqtot, df[2], 1, diff0, 1, out_d1, 1);
129  Vmath::Vvtvp(nqtot, df[3], 1, diff1, 1, out_d1, 1, out_d1, 1);
130  }
131 
132  if (out_d2.size())
133  {
134  Vmath::Vmul(nqtot, df[4], 1, diff0, 1, out_d2, 1);
135  Vmath::Vvtvp(nqtot, df[5], 1, diff1, 1, out_d2, 1, out_d2, 1);
136  }
137  }
138  else // regular geometry
139  {
140  if (out_d0.size())
141  {
142  Vmath::Smul(nqtot, df[0][0], diff0, 1, out_d0, 1);
143  Blas::Daxpy(nqtot, df[1][0], diff1, 1, out_d0, 1);
144  }
145 
146  if (out_d1.size())
147  {
148  Vmath::Smul(nqtot, df[2][0], diff0, 1, out_d1, 1);
149  Blas::Daxpy(nqtot, df[3][0], diff1, 1, out_d1, 1);
150  }
151 
152  if (out_d2.size())
153  {
154  Vmath::Smul(nqtot, df[4][0], diff0, 1, out_d2, 1);
155  Blas::Daxpy(nqtot, df[5][0], diff1, 1, out_d2, 1);
156  }
157  }
158 }
Blas::Daxpy
static void Daxpy(const int &n, const double &alpha, const double *x, const int &incx, const double *y, const int &incy)
BLAS level 1: y = alpha x plus y.
Definition: Blas.hpp:154

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

◆ v_PhysDeriv() [2/2]

void Nektar::LocalRegions::TriExp::v_PhysDeriv ( const int  dir,
const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  out_d0 
)
protectedvirtual

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

See also
StdRegions::StdExpansion::PhysDeriv

Reimplemented from Nektar::StdRegions::StdTriExp.

Definition at line 160 of file TriExp.cpp.

163 {
164  switch (dir)
165  {
166  case 0:
167  {
168  PhysDeriv(inarray, outarray, NullNekDouble1DArray,
169  NullNekDouble1DArray);
170  }
171  break;
172  case 1:
173  {
174  PhysDeriv(inarray, NullNekDouble1DArray, outarray,
175  NullNekDouble1DArray);
176  }
177  break;
178  case 2:
179  {
180  PhysDeriv(inarray, NullNekDouble1DArray, NullNekDouble1DArray,
181  outarray);
182  }
183  break;
184  default:
185  {
186  ASSERTL1(false, "input dir is out of range");
187  }
188  break;
189  }
190 }
Nektar::StdRegions::StdExpansion::PhysDeriv
void PhysDeriv(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_d0, Array< OneD, NekDouble > &out_d1=NullNekDouble1DArray, Array< OneD, NekDouble > &out_d2=NullNekDouble1DArray)
Definition: StdExpansion.h:850
Nektar::NullNekDouble1DArray
static Array< OneD, NekDouble > NullNekDouble1DArray
Definition: SharedArray.hpp:883

References ASSERTL1, Nektar::NullNekDouble1DArray, and Nektar::StdRegions::StdExpansion::PhysDeriv().

◆ v_PhysDirectionalDeriv()

void Nektar::LocalRegions::TriExp::v_PhysDirectionalDeriv ( const Array< OneD, const NekDouble > &  inarray,
const Array< OneD, const NekDouble > &  direction,
Array< OneD, NekDouble > &  outarray 
)
protectedvirtual

Physical derivative along a direction vector.

See also
StdRegions::StdExpansion::PhysDirectionalDeriv

D_v = D^v_xi * du/d_xi + D^v_eta * du/d_eta

D_v = D^v_xi * du/d_xi + D^v_eta * du/d_eta

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 192 of file TriExp.cpp.

195 {
196  if (!out.size())
197  {
198  return;
199  }
200 
201  int nquad0 = m_base[0]->GetNumPoints();
202  int nquad1 = m_base[1]->GetNumPoints();
203  int nqtot = nquad0 * nquad1;
204 
205  const Array<TwoD, const NekDouble> &df =
206  m_metricinfo->GetDerivFactors(GetPointsKeys());
207 
208  Array<OneD, NekDouble> diff0(2 * nqtot);
209  Array<OneD, NekDouble> diff1(diff0 + nqtot);
210 
211  // diff0 = du/d_xi, diff1 = du/d_eta
212  StdTriExp::v_PhysDeriv(inarray, diff0, diff1);
213 
214  if (m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
215  {
216  Array<OneD, Array<OneD, NekDouble>> tangmat(2);
217 
218  // D^v_xi = v_x*d_xi/dx + v_y*d_xi/dy + v_z*d_xi/dz
219  // D^v_eta = v_x*d_eta/dx + v_y*d_eta/dy + v_z*d_eta/dz
220  for (int i = 0; i < 2; ++i)
221  {
222  tangmat[i] = Array<OneD, NekDouble>(nqtot, 0.0);
223  for (int k = 0; k < (m_geom->GetCoordim()); ++k)
224  {
225  Vmath::Vvtvp(nqtot, &df[2 * k + i][0], 1, &direction[k * nqtot],
226  1, &tangmat[i][0], 1, &tangmat[i][0], 1);
227  }
228  }
229 
230  /// D_v = D^v_xi * du/d_xi + D^v_eta * du/d_eta
231  Vmath::Vmul(nqtot, &tangmat[0][0], 1, &diff0[0], 1, &out[0], 1);
232  Vmath::Vvtvp(nqtot, &tangmat[1][0], 1, &diff1[0], 1, &out[0], 1,
233  &out[0], 1);
234  }
235  else
236  {
237  Array<OneD, Array<OneD, NekDouble>> tangmat(2);
238 
239  for (int i = 0; i < 2; ++i)
240  {
241  tangmat[i] = Array<OneD, NekDouble>(nqtot, 0.0);
242  for (int k = 0; k < (m_geom->GetCoordim()); ++k)
243  {
244  Vmath::Svtvp(nqtot, df[2 * k + i][0], &direction[k * nqtot], 1,
245  &tangmat[i][0], 1, &tangmat[i][0], 1);
246  }
247  }
248 
249  /// D_v = D^v_xi * du/d_xi + D^v_eta * du/d_eta
250  Vmath::Vmul(nqtot, &tangmat[0][0], 1, &diff0[0], 1, &out[0], 1);
251 
252  Vmath::Vvtvp(nqtot, &tangmat[1][0], 1, &diff1[0], 1, &out[0], 1,
253  &out[0], 1);
254  }
255 }

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

◆ v_PhysEvaluate()

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

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

This function is a wrapper around the virtual function v_PhysEvaluate()

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 #m_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::StdExpansion2D.

Definition at line 756 of file TriExp.cpp.

758 {
759  Array<OneD, NekDouble> Lcoord = Array<OneD, NekDouble>(2);
760 
761  ASSERTL0(m_geom, "m_geom not defined");
762  m_geom->GetLocCoords(coord, Lcoord);
763 
764  return StdTriExp::v_PhysEvaluate(Lcoord, physvals);
765 }

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

◆ v_ReduceOrderCoeffs()

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

Function is used to compute exactly the advective numerical flux on theinterface of two elements with different expansions, hence an appropriate number of Gauss points has to be used. The number of Gauss points has to be equal to the number used by the highest polynomial degree of the two adjacent elements. Furthermore, this function is used to compute the sensor value in each element.

Parameters
numMinIs the reduced polynomial order
inarrayInput array of coefficients
dumpVarOutput array of reduced coefficients.

Reimplemented from Nektar::StdRegions::StdTriExp.

Definition at line 1456 of file TriExp.cpp.

1459 {
1460  int n_coeffs = inarray.size();
1461  int nquad0 = m_base[0]->GetNumPoints();
1462  int nquad1 = m_base[1]->GetNumPoints();
1463  int nqtot = nquad0 * nquad1;
1464  int nmodes0 = m_base[0]->GetNumModes();
1465  int nmodes1 = m_base[1]->GetNumModes();
1466  int numMin2 = nmodes0, i;
1467 
1468  Array<OneD, NekDouble> coeff(n_coeffs, 0.0);
1469  Array<OneD, NekDouble> phys_tmp(nqtot, 0.0);
1470  Array<OneD, NekDouble> tmp, tmp2;
1471 
1472  const LibUtilities::PointsKey Pkey0 = m_base[0]->GetPointsKey();
1473  const LibUtilities::PointsKey Pkey1 = m_base[1]->GetPointsKey();
1474 
1475  LibUtilities::BasisKey b0(m_base[0]->GetBasisType(), nmodes0, Pkey0);
1476  LibUtilities::BasisKey b1(m_base[1]->GetBasisType(), nmodes1, Pkey1);
1477  LibUtilities::BasisKey bortho0(LibUtilities::eOrtho_A, nmodes0, Pkey0);
1478  LibUtilities::BasisKey bortho1(LibUtilities::eOrtho_B, nmodes1, Pkey1);
1479 
1480  // Check if it is also possible to use the same InterCoeff routine
1481  // which is also used for Quadrilateral and Hexagonal shaped
1482  // elements
1483 
1484  // For now, set up the used basis on the standard element to
1485  // calculate the phys values, set up the orthogonal basis to do a
1486  // forward transform, to obtain the coefficients in orthogonal
1487  // coefficient space
1488  StdRegions::StdTriExpSharedPtr m_OrthoTriExp;
1489  StdRegions::StdTriExpSharedPtr m_TriExp;
1490 
1491  m_TriExp = MemoryManager<StdRegions::StdTriExp>::AllocateSharedPtr(b0, b1);
1492  m_OrthoTriExp = MemoryManager<StdRegions::StdTriExp>::AllocateSharedPtr(
1493  bortho0, bortho1);
1494 
1495  m_TriExp->BwdTrans(inarray, phys_tmp);
1496  m_OrthoTriExp->FwdTrans(phys_tmp, coeff);
1497 
1498  for (i = 0; i < n_coeffs; i++)
1499  {
1500  if (i == numMin)
1501  {
1502  coeff[i] = 0.0;
1503  numMin += numMin2 - 1;
1504  numMin2 -= 1.0;
1505  }
1506  }
1507 
1508  m_OrthoTriExp->BwdTrans(coeff, phys_tmp);
1509  m_TriExp->FwdTrans(phys_tmp, outarray);
1510 }

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

◆ v_StdPhysEvaluate()

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

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 748 of file TriExp.cpp.

751 {
752  // Evaluate point in local (eta) coordinates.
753  return StdTriExp::v_PhysEvaluate(Lcoord, physvals);
754 }

◆ v_SVVLaplacianFilter()

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

Reimplemented from Nektar::StdRegions::StdTriExp.

Definition at line 1512 of file TriExp.cpp.

1514 {
1515  int nq = GetTotPoints();
1516 
1517  // Calculate sqrt of the Jacobian
1518  Array<OneD, const NekDouble> jac = m_metricinfo->GetJac(GetPointsKeys());
1519  Array<OneD, NekDouble> sqrt_jac(nq);
1520  if (m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
1521  {
1522  Vmath::Vsqrt(nq, jac, 1, sqrt_jac, 1);
1523  }
1524  else
1525  {
1526  Vmath::Fill(nq, sqrt(jac[0]), sqrt_jac, 1);
1527  }
1528 
1529  // Multiply array by sqrt(Jac)
1530  Vmath::Vmul(nq, sqrt_jac, 1, array, 1, array, 1);
1531 
1532  // Apply std region filter
1533  StdTriExp::v_SVVLaplacianFilter(array, mkey);
1534 
1535  // Divide by sqrt(Jac)
1536  Vmath::Vdiv(nq, array, 1, sqrt_jac, 1, array, 1);
1537 }
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:284

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

◆ v_WeakDerivMatrixOp()

void Nektar::LocalRegions::TriExp::v_WeakDerivMatrixOp ( const int  i,
const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray,
const StdRegions::StdMatrixKey &  mkey 
)
protectedvirtual

Reimplemented from Nektar::StdRegions::StdTriExp.

Definition at line 1192 of file TriExp.cpp.

1196 {
1197  StdExpansion::WeakDerivMatrixOp_MatFree(i, inarray, outarray, mkey);
1198 }

◆ v_WeakDirectionalDerivMatrixOp()

void Nektar::LocalRegions::TriExp::v_WeakDirectionalDerivMatrixOp ( const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray,
const StdRegions::StdMatrixKey &  mkey 
)
protectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 1200 of file TriExp.cpp.

1203 {
1204  StdExpansion::WeakDirectionalDerivMatrixOp_MatFree(inarray, outarray, mkey);
1205 }

Member Data Documentation

◆ m_matrixManager

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

Definition at line 249 of file TriExp.h.

Referenced by v_FwdTrans(), v_GetLocMatrix(), v_IProductWRTBase_MatOp(), and v_IProductWRTDerivBase_MatOp().

◆ m_staticCondMatrixManager

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

Definition at line 251 of file TriExp.h.

Referenced by v_DropLocStaticCondMatrix(), v_FwdTransBndConstrained(), and v_GetLocStaticCondMatrix().

Generated on Tue Aug 23 2022 07:27:21 for Nektar++ by doxygen 1.9.1