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

#include <QuadExp.h>

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

Public Member Functions

 QuadExp (const LibUtilities::BasisKey &Ba, const LibUtilities::BasisKey &Bb, const SpatialDomains::QuadGeomSharedPtr &geom)
 Constructor using BasisKey class for quadrature points and order definition. More...
 
 QuadExp (const QuadExp &T)
 
virtual ~QuadExp ()
 
- Public Member Functions inherited from Nektar::StdRegions::StdQuadExp
 StdQuadExp ()
 
 StdQuadExp (const LibUtilities::BasisKey &Ba, const LibUtilities::BasisKey &Bb)
 Constructor using BasisKey class for quadrature points and order definition. More...
 
 StdQuadExp (const StdQuadExp &T)
 Copy Constructor. More...
 
 ~StdQuadExp ()
 Destructor. More...
 
- 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 FwdTrans_BndConstrained (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
NekDouble Integral (const Array< OneD, const NekDouble > &inarray)
 This function integrates the specified function over the domain. More...
 
void FillMode (const int mode, Array< OneD, NekDouble > &outarray)
 This function fills the array outarray with the mode-th mode of the expansion. More...
 
void IProductWRTBase (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 this function calculates the inner product of a given function f with the different modes of the expansion More...
 
void IProductWRTBase (const Array< OneD, const NekDouble > &base, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, int coll_check)
 
void IProductWRTDerivBase (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
void IProductWRTDirectionalDerivBase (const Array< OneD, const NekDouble > &direction, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
int GetElmtId ()
 Get the element id of this expansion when used in a list by returning value of m_elmt_id. More...
 
void SetElmtId (const int id)
 Set the element id of this expansion when used in a list by returning value of m_elmt_id. More...
 
void GetCoords (Array< OneD, NekDouble > &coords_1, Array< OneD, NekDouble > &coords_2=NullNekDouble1DArray, Array< OneD, NekDouble > &coords_3=NullNekDouble1DArray)
 this function returns the physical coordinates of the quadrature points of the expansion More...
 
void GetCoord (const Array< OneD, const NekDouble > &Lcoord, Array< OneD, NekDouble > &coord)
 given the coordinates of a point of the element in the local collapsed coordinate system, this function calculates the physical coordinates of the point More...
 
DNekMatSharedPtr GetStdMatrix (const StdMatrixKey &mkey)
 
DNekBlkMatSharedPtr GetStdStaticCondMatrix (const StdMatrixKey &mkey)
 
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 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 ()
 
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)
 
- 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)
 
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)
 
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) const
 
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)
 
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
 

Protected Member Functions

virtual NekDouble v_Integral (const Array< OneD, const NekDouble > &inarray)
 Integrates the specified function over the domain. More...
 
virtual NekDouble v_StdPhysEvaluate (const Array< OneD, const NekDouble > &Lcoord, const Array< OneD, const NekDouble > &physvals)
 
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_FwdTrans_BndConstrained (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*base1 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_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_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_GetEdgePhysVals (const int edge, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
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 const SpatialDomains::GeomFactorsSharedPtr & v_GetMetricInfo () const
 
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)
 
DNekScalMatSharedPtr CreateMatrix (const MatrixKey &mkey)
 
DNekScalBlkMatSharedPtr CreateStaticCondMatrix (const MatrixKey &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)
 
- Protected Member Functions inherited from Nektar::StdRegions::StdQuadExp
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)
 
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 > &array)
 Fill outarray with mode mode of expansion. More...
 
virtual int v_GetNverts () const
 
virtual int v_GetNtraces () const
 
virtual int v_GetTraceNcoeffs (const int i) const
 
virtual int v_GetTraceNumPoints (const int i) const
 
virtual int v_NumBndryCoeffs () const
 
virtual int v_NumDGBndryCoeffs () const
 
virtual int v_CalcNumberOfCoefficients (const std::vector< unsigned int > &nummodes, int &modes_offset)
 
virtual const LibUtilities::BasisKey v_GetTraceBasisKey (const int i, const int j) const
 
virtual LibUtilities::ShapeType v_DetShapeType () const
 
virtual bool v_IsBoundaryInteriorExpansion ()
 
virtual NekDouble v_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...
 
virtual void v_GetBoundaryMap (Array< OneD, unsigned int > &outarray)
 
virtual void v_GetInteriorMap (Array< OneD, unsigned int > &outarray)
 
virtual int v_GetVertexMap (int localVertexId, bool useCoeffPacking=false)
 
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_GetTraceInteriorToElementMap (const int eid, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray, const Orientation edgeOrient=eForwards)
 
virtual void v_ExponentialFilter (Array< OneD, NekDouble > &array, const NekDouble alpha, const NekDouble exponent, const NekDouble cutoff)
 
void v_GeneralMatrixOp_MatOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
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_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 const NormalVector & v_GetTraceNormal (const int edge) const
 
virtual NekDouble v_VectorFlux (const Array< OneD, Array< OneD, NekDouble > > &vec)
 
- 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

 QuadExp ()
 

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< Expansion1DWeakPtr > m_edgeExp
 
std::vector< bool > m_requireNeg
 
std::map< int, NormalVector > m_edgeNormals
 
Expansion3DWeakPtr m_elementLeft
 
Expansion3DWeakPtr m_elementRight
 
int m_elementFaceLeft
 
int m_elementFaceRight
 
- Protected Attributes inherited from Nektar::LocalRegions::Expansion
LibUtilities::NekManager< IndexMapKey, IndexMapValues, IndexMapKey::opLess > m_indexMapManager
 
std::vector< ExpansionWeakPtr > m_traceExp
 
SpatialDomains::GeometrySharedPtr m_geom
 
SpatialDomains::GeomFactorsSharedPtr m_metricinfo
 
MetricMap m_metrics
 
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 51 of file QuadExp.h.

Constructor & Destructor Documentation

◆ QuadExp() [1/3]

Nektar::LocalRegions::QuadExp::QuadExp ( const LibUtilities::BasisKey &  Ba,
const LibUtilities::BasisKey &  Bb,
const SpatialDomains::QuadGeomSharedPtr &  geom 
)

Constructor using BasisKey class for quadrature points and order definition.

Definition at line 51 of file QuadExp.cpp.

53  :
54  StdExpansion (Ba.GetNumModes()*Bb.GetNumModes(),2,Ba,Bb),
55  StdExpansion2D(Ba.GetNumModes()*Bb.GetNumModes(),Ba,Bb),
56  StdQuadExp (Ba,Bb),
57  Expansion (geom),
58  Expansion2D (geom),
59  m_matrixManager(
60  std::bind(&QuadExp::CreateMatrix, this, std::placeholders::_1),
61  std::string("QuadExpMatrix")),
62  m_staticCondMatrixManager(
63  std::bind(&QuadExp::CreateStaticCondMatrix, this, std::placeholders::_1),
64  std::string("QuadExpStaticCondMatrix"))
65  {
66  }
Nektar::LocalRegions::Expansion2D::Expansion2D
Expansion2D(SpatialDomains::Geometry2DSharedPtr pGeom)
Definition: Expansion2D.cpp:51
Nektar::LocalRegions::Expansion::Expansion
Expansion(SpatialDomains::GeometrySharedPtr pGeom)
Definition: Expansion.cpp:47
Nektar::LocalRegions::QuadExp::CreateStaticCondMatrix
DNekScalBlkMatSharedPtr CreateStaticCondMatrix(const MatrixKey &mkey)
Definition: QuadExp.cpp:1996
Nektar::LocalRegions::QuadExp::CreateMatrix
DNekScalMatSharedPtr CreateMatrix(const MatrixKey &mkey)
Definition: QuadExp.cpp:1682
Nektar::LocalRegions::QuadExp::m_matrixManager
LibUtilities::NekManager< MatrixKey, DNekScalMat, MatrixKey::opLess > m_matrixManager
Definition: QuadExp.h:286
Nektar::LocalRegions::QuadExp::m_staticCondMatrixManager
LibUtilities::NekManager< MatrixKey, DNekScalBlkMat, MatrixKey::opLess > m_staticCondMatrixManager
Definition: QuadExp.h:287
Nektar::StdRegions::StdExpansion::StdExpansion
StdExpansion()
Default Constructor.
Definition: StdExpansion.cpp:45

◆ QuadExp() [2/3]

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

Definition at line 69 of file QuadExp.cpp.

69  :
70  StdExpansion(T),
71  StdExpansion2D(T),
72  StdQuadExp(T),
73  Expansion (T),
74  Expansion2D (T),
75  m_matrixManager(T.m_matrixManager),
76  m_staticCondMatrixManager(T.m_staticCondMatrixManager)
77  {
78  }

◆ ~QuadExp()

Nektar::LocalRegions::QuadExp::~QuadExp ( )
virtual

Definition at line 81 of file QuadExp.cpp.

82  {
83  }

◆ QuadExp() [3/3]

Nektar::LocalRegions::QuadExp::QuadExp ( )
private

Member Function Documentation

◆ CreateMatrix()

DNekScalMatSharedPtr Nektar::LocalRegions::QuadExp::CreateMatrix ( const MatrixKey &  mkey)
protected

Definition at line 1682 of file QuadExp.cpp.

1683  {
1684  DNekScalMatSharedPtr returnval;
1685  LibUtilities::PointsKeyVector ptsKeys = GetPointsKeys();
1686 
1687  ASSERTL2(m_metricinfo->GetGtype() != SpatialDomains::eNoGeomType,
1688  "Geometric information is not set up");
1689 
1690  switch (mkey.GetMatrixType())
1691  {
1692  case StdRegions::eMass:
1693  {
1694  if ((m_metricinfo->GetGtype() ==
1695  SpatialDomains::eDeformed) || (mkey.GetNVarCoeff()))
1696  {
1697  NekDouble one = 1.0;
1698  DNekMatSharedPtr mat = GenMatrix(mkey);
1699  returnval = MemoryManager<DNekScalMat>::
1700  AllocateSharedPtr(one,mat);
1701  }
1702  else
1703  {
1704  NekDouble jac = (m_metricinfo->GetJac(ptsKeys))[0];
1705  DNekMatSharedPtr mat = GetStdMatrix(mkey);
1706  returnval = MemoryManager<DNekScalMat>::
1707  AllocateSharedPtr(jac,mat);
1708  }
1709  }
1710  break;
1711  case StdRegions::eInvMass:
1712  {
1713  if ((m_metricinfo->GetGtype() ==
1714  SpatialDomains::eDeformed) || (mkey.GetNVarCoeff()))
1715  {
1716  NekDouble one = 1.0;
1717  StdRegions::StdMatrixKey masskey(
1718  StdRegions::eMass, DetShapeType(), *this);
1719  DNekMatSharedPtr mat = GenMatrix(masskey);
1720  mat->Invert();
1721 
1722  returnval = MemoryManager<DNekScalMat>::
1723  AllocateSharedPtr(one,mat);
1724  }
1725  else
1726  {
1727  NekDouble fac = 1.0/(m_metricinfo->GetJac(ptsKeys))[0];
1728  DNekMatSharedPtr mat = GetStdMatrix(mkey);
1729  returnval = MemoryManager<DNekScalMat>::
1730  AllocateSharedPtr(fac,mat);
1731  }
1732  }
1733  break;
1734  case StdRegions::eWeakDeriv0:
1735  case StdRegions::eWeakDeriv1:
1736  case StdRegions::eWeakDeriv2:
1737  {
1738  if((m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
1739  || (mkey.GetNVarCoeff()))
1740  {
1741  NekDouble one = 1.0;
1742  DNekMatSharedPtr mat = GenMatrix(mkey);
1743 
1744  returnval = MemoryManager<DNekScalMat>::
1745  AllocateSharedPtr(one,mat);
1746  }
1747  else
1748  {
1749  NekDouble jac = (m_metricinfo->GetJac(ptsKeys))[0];
1750  Array<TwoD, const NekDouble> df =
1751  m_metricinfo->GetDerivFactors(ptsKeys);
1752  int dir = 0;
1753 
1754  switch(mkey.GetMatrixType())
1755  {
1756  case StdRegions::eWeakDeriv0:
1757  dir = 0;
1758  break;
1759  case StdRegions::eWeakDeriv1:
1760  dir = 1;
1761  break;
1762  case StdRegions::eWeakDeriv2:
1763  dir = 2;
1764  break;
1765  default:
1766  break;
1767  }
1768 
1769  MatrixKey deriv0key(StdRegions::eWeakDeriv0,
1770  mkey.GetShapeType(), *this);
1771  MatrixKey deriv1key(StdRegions::eWeakDeriv1,
1772  mkey.GetShapeType(), *this);
1773 
1774  DNekMat &deriv0 = *GetStdMatrix(deriv0key);
1775  DNekMat &deriv1 = *GetStdMatrix(deriv1key);
1776 
1777  int rows = deriv0.GetRows();
1778  int cols = deriv1.GetColumns();
1779 
1780  DNekMatSharedPtr WeakDeriv = MemoryManager<DNekMat>::
1781  AllocateSharedPtr(rows,cols);
1782  (*WeakDeriv) = df[2*dir][0]*deriv0 +
1783  df[2*dir+1][0]*deriv1;
1784  returnval = MemoryManager<DNekScalMat>::
1785  AllocateSharedPtr(jac,WeakDeriv);
1786  }
1787  }
1788  break;
1789  case StdRegions::eLaplacian:
1790  {
1791  if( (m_metricinfo->GetGtype() ==
1792  SpatialDomains::eDeformed) || (mkey.GetNVarCoeff() > 0)
1793  || (mkey.ConstFactorExists
1794  (StdRegions::eFactorSVVCutoffRatio)))
1795  {
1796  NekDouble one = 1.0;
1797  DNekMatSharedPtr mat = GenMatrix(mkey);
1798 
1799  returnval = MemoryManager<DNekScalMat>::
1800  AllocateSharedPtr(one,mat);
1801  }
1802  else
1803  {
1804  MatrixKey lap00key(StdRegions::eLaplacian00,
1805  mkey.GetShapeType(), *this);
1806  MatrixKey lap01key(StdRegions::eLaplacian01,
1807  mkey.GetShapeType(), *this);
1808  MatrixKey lap11key(StdRegions::eLaplacian11,
1809  mkey.GetShapeType(), *this);
1810 
1811  DNekMat &lap00 = *GetStdMatrix(lap00key);
1812  DNekMat &lap01 = *GetStdMatrix(lap01key);
1813  DNekMat &lap11 = *GetStdMatrix(lap11key);
1814 
1815  NekDouble jac = (m_metricinfo->GetJac(ptsKeys))[0];
1816  Array<TwoD, const NekDouble>
1817  gmat = m_metricinfo->GetGmat(ptsKeys);
1818 
1819  int rows = lap00.GetRows();
1820  int cols = lap00.GetColumns();
1821 
1822  DNekMatSharedPtr lap =
1823  MemoryManager<DNekMat>::AllocateSharedPtr(rows,cols);
1824 
1825  (*lap) = gmat[0][0] * lap00 +
1826  gmat[1][0] * (lap01 + Transpose(lap01)) +
1827  gmat[3][0] * lap11;
1828 
1829  returnval = MemoryManager<DNekScalMat>::
1830  AllocateSharedPtr(jac,lap);
1831  }
1832  }
1833  break;
1834  case StdRegions::eInvLaplacianWithUnityMean:
1835  {
1836  DNekMatSharedPtr mat = GenMatrix(mkey);
1837  returnval = MemoryManager<DNekScalMat>::AllocateSharedPtr(1.0,mat);
1838  }
1839  break;
1840  case StdRegions::eHelmholtz:
1841  {
1842  NekDouble lambda =
1843  mkey.GetConstFactor(StdRegions::eFactorLambda);
1844 
1845  MatrixKey masskey(mkey, StdRegions::eMass);
1846  DNekScalMat &MassMat = *(this->m_matrixManager[masskey]);
1847 
1848  MatrixKey lapkey(mkey, StdRegions::eLaplacian);
1849  DNekScalMat &LapMat = *(this->m_matrixManager[lapkey]);
1850 
1851  int rows = LapMat.GetRows();
1852  int cols = LapMat.GetColumns();
1853 
1854  DNekMatSharedPtr helm = MemoryManager<DNekMat>::
1855  AllocateSharedPtr(rows,cols);
1856 
1857  NekDouble one = 1.0;
1858  (*helm) = LapMat + lambda*MassMat;
1859 
1860  returnval =
1861  MemoryManager<DNekScalMat>::AllocateSharedPtr(one,helm);
1862  }
1863  break;
1864  case StdRegions::eIProductWRTBase:
1865  {
1866  if(m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
1867  {
1868  NekDouble one = 1.0;
1869  DNekMatSharedPtr mat = GenMatrix(mkey);
1870  returnval = MemoryManager<DNekScalMat>::
1871  AllocateSharedPtr(one,mat);
1872  }
1873  else
1874  {
1875  NekDouble jac = (m_metricinfo->GetJac(ptsKeys))[0];
1876  DNekMatSharedPtr mat = GetStdMatrix(mkey);
1877  returnval = MemoryManager<DNekScalMat>::
1878  AllocateSharedPtr(jac,mat);
1879  }
1880  }
1881  break;
1882  case StdRegions::eIProductWRTDerivBase0:
1883  case StdRegions::eIProductWRTDerivBase1:
1884  case StdRegions::eIProductWRTDerivBase2:
1885  {
1886  if(m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
1887  {
1888  NekDouble one = 1.0;
1889  DNekMatSharedPtr mat = GenMatrix(mkey);
1890  returnval = MemoryManager<DNekScalMat>::
1891  AllocateSharedPtr(one,mat);
1892  }
1893  else
1894  {
1895  NekDouble jac = (m_metricinfo->GetJac(ptsKeys))[0];
1896  const Array<TwoD, const NekDouble>& df =
1897  m_metricinfo->GetDerivFactors(ptsKeys);
1898  int dir = 0;
1899 
1900  switch(mkey.GetMatrixType())
1901  {
1902  case StdRegions::eIProductWRTDerivBase0:
1903  dir = 0;
1904  break;
1905  case StdRegions::eIProductWRTDerivBase1:
1906  dir = 1;
1907  break;
1908  case StdRegions::eIProductWRTDerivBase2:
1909  dir = 2;
1910  break;
1911  default:
1912  break;
1913  }
1914 
1915  MatrixKey iProdDeriv0Key(
1916  StdRegions::eIProductWRTDerivBase0,
1917  mkey.GetShapeType(), *this);
1918  MatrixKey iProdDeriv1Key(
1919  StdRegions::eIProductWRTDerivBase1,
1920  mkey.GetShapeType(), *this);
1921 
1922  DNekMat &stdiprod0 = *GetStdMatrix(iProdDeriv0Key);
1923  DNekMat &stdiprod1 = *GetStdMatrix(iProdDeriv0Key);
1924 
1925  int rows = stdiprod0.GetRows();
1926  int cols = stdiprod1.GetColumns();
1927 
1928  DNekMatSharedPtr mat = MemoryManager<DNekMat>::
1929  AllocateSharedPtr(rows,cols);
1930  (*mat) = df[2*dir][0]*stdiprod0 +
1931  df[2*dir+1][0]*stdiprod1;
1932 
1933  returnval = MemoryManager<DNekScalMat>::
1934  AllocateSharedPtr(jac,mat);
1935  }
1936  }
1937  break;
1938  case StdRegions::eInvHybridDGHelmholtz:
1939  {
1940  NekDouble one = 1.0;
1941 
1942  MatrixKey hkey(StdRegions::eHybridDGHelmholtz,
1943  DetShapeType(), *this,
1944  mkey.GetConstFactors(), mkey.GetVarCoeffs());
1945  DNekMatSharedPtr mat = GenMatrix(hkey);
1946 
1947  mat->Invert();
1948  returnval =
1949  MemoryManager<DNekScalMat>::AllocateSharedPtr(one,mat);
1950  }
1951  break;
1952  case StdRegions::eInterpGauss:
1953  {
1954  DNekMatSharedPtr m_Ix;
1955  Array<OneD, NekDouble> coords(1, 0.0);
1956  StdRegions::ConstFactorMap factors = mkey.GetConstFactors();
1957  int edge = (int)factors[StdRegions::eFactorGaussEdge];
1958 
1959  coords[0] = (edge == 0 || edge == 3) ? -1.0 : 1.0;
1960 
1961  m_Ix = m_base[(edge + 1) % 2]->GetI(coords);
1962  returnval =
1963  MemoryManager<DNekScalMat>::AllocateSharedPtr(1.0,m_Ix);
1964  }
1965  break;
1966  case StdRegions::ePreconLinearSpace:
1967  {
1968  NekDouble one = 1.0;
1969  MatrixKey helmkey(
1970  StdRegions::eHelmholtz, mkey.GetShapeType(), *this,
1971  mkey.GetConstFactors(), mkey.GetVarCoeffs());
1972  DNekScalBlkMatSharedPtr helmStatCond =
1973  GetLocStaticCondMatrix(helmkey);
1974  DNekScalMatSharedPtr A =helmStatCond->GetBlock(0,0);
1975  DNekMatSharedPtr R=BuildVertexMatrix(A);
1976 
1977  returnval =
1978  MemoryManager<DNekScalMat>::AllocateSharedPtr(one, R);
1979  }
1980  break;
1981  default:
1982  {
1983  NekDouble one = 1.0;
1984  DNekMatSharedPtr mat = GenMatrix(mkey);
1985 
1986  returnval =
1987  MemoryManager<DNekScalMat>::AllocateSharedPtr(one, mat);
1988  }
1989  break;
1990  }
1991 
1992  return returnval;
1993  }
ASSERTL2
#define ASSERTL2(condition, msg)
Assert Level 2 – Debugging which is used FULLDEBUG compilation mode. This level assert is designed to...
Definition: ErrorUtil.hpp:274
Nektar::LocalRegions::Expansion::BuildVertexMatrix
DNekMatSharedPtr BuildVertexMatrix(const DNekScalMatSharedPtr &r_bnd)
Definition: Expansion.cpp:103
Nektar::LocalRegions::Expansion::m_metricinfo
SpatialDomains::GeomFactorsSharedPtr m_metricinfo
Definition: Expansion.h:273
Nektar::MemoryManager::AllocateSharedPtr
static std::shared_ptr< DataType > AllocateSharedPtr(const Args &...args)
Allocate a shared pointer from the memory pool.
Definition: NekMemoryManager.hpp:171
Nektar::StdRegions::StdExpansion::GetStdMatrix
DNekMatSharedPtr GetStdMatrix(const StdMatrixKey &mkey)
Definition: StdExpansion.h:617
Nektar::StdRegions::StdExpansion::GetPointsKeys
const LibUtilities::PointsKeyVector GetPointsKeys() const
Definition: StdExpansion.h:1078
Nektar::StdRegions::StdExpansion::GetLocStaticCondMatrix
DNekScalBlkMatSharedPtr GetLocStaticCondMatrix(const LocalRegions::MatrixKey &mkey)
Definition: StdExpansion.h:660
Nektar::StdRegions::StdExpansion::DetShapeType
LibUtilities::ShapeType DetShapeType() const
This function returns the shape of the expansion domain.
Definition: StdExpansion.h:376
Nektar::StdRegions::StdExpansion::GenMatrix
DNekMatSharedPtr GenMatrix(const StdMatrixKey &mkey)
Definition: StdExpansion.h:850
Nektar::StdRegions::StdExpansion::m_base
Array< OneD, LibUtilities::BasisSharedPtr > m_base
Definition: StdExpansion.h:1162
Nektar::LibUtilities::PointsKeyVector
std::vector< PointsKey > PointsKeyVector
Definition: Points.h:246
Nektar::SpatialDomains::eNoGeomType
@ eNoGeomType
No type defined.
Definition: SpatialDomains.hpp:53
Nektar::SpatialDomains::eDeformed
@ eDeformed
Geometry is curved or has non-constant factors.
Definition: SpatialDomains.hpp:56
Nektar::StdRegions::ConstFactorMap
std::map< ConstFactorType, NekDouble > ConstFactorMap
Definition: StdRegions.hpp:314
Nektar::DNekScalMat
NekMatrix< NekMatrix< NekDouble, StandardMatrixTag >, ScaledMatrixTag > DNekScalMat
Definition: NekMatrixFwd.hpp:68
Nektar::DNekScalMatSharedPtr
std::shared_ptr< DNekScalMat > DNekScalMatSharedPtr
Definition: NekMatrixFwd.hpp:69
Nektar::DNekMat
NekMatrix< NekDouble, StandardMatrixTag > DNekMat
Definition: NekTypeDefs.hpp:51
Nektar::Transpose
NekMatrix< InnerMatrixType, BlockMatrixTag > Transpose(NekMatrix< InnerMatrixType, BlockMatrixTag > &rhs)
Definition: BlockMatrix.hpp:217
Nektar::DNekScalBlkMatSharedPtr
std::shared_ptr< DNekScalBlkMat > DNekScalBlkMatSharedPtr
Definition: NekTypeDefs.hpp:73
Nektar::DNekMatSharedPtr
std::shared_ptr< DNekMat > DNekMatSharedPtr
Definition: NekTypeDefs.hpp:69
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:43

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL2, Nektar::LocalRegions::Expansion::BuildVertexMatrix(), Nektar::StdRegions::StdMatrixKey::ConstFactorExists(), Nektar::StdRegions::StdExpansion::DetShapeType(), Nektar::SpatialDomains::eDeformed, Nektar::StdRegions::eFactorGaussEdge, Nektar::StdRegions::eFactorLambda, Nektar::StdRegions::eFactorSVVCutoffRatio, Nektar::StdRegions::eHelmholtz, Nektar::StdRegions::eHybridDGHelmholtz, Nektar::StdRegions::eInterpGauss, Nektar::StdRegions::eInvHybridDGHelmholtz, Nektar::StdRegions::eInvLaplacianWithUnityMean, Nektar::StdRegions::eInvMass, Nektar::StdRegions::eIProductWRTBase, Nektar::StdRegions::eIProductWRTDerivBase0, Nektar::StdRegions::eIProductWRTDerivBase1, Nektar::StdRegions::eIProductWRTDerivBase2, Nektar::StdRegions::eLaplacian, Nektar::StdRegions::eLaplacian00, Nektar::StdRegions::eLaplacian01, Nektar::StdRegions::eLaplacian11, Nektar::StdRegions::eMass, Nektar::SpatialDomains::eNoGeomType, Nektar::StdRegions::ePreconLinearSpace, Nektar::StdRegions::eWeakDeriv0, Nektar::StdRegions::eWeakDeriv1, Nektar::StdRegions::eWeakDeriv2, Nektar::StdRegions::StdExpansion::GenMatrix(), Nektar::StdRegions::StdMatrixKey::GetConstFactor(), Nektar::StdRegions::StdMatrixKey::GetConstFactors(), Nektar::StdRegions::StdExpansion::GetLocStaticCondMatrix(), Nektar::StdRegions::StdMatrixKey::GetMatrixType(), Nektar::StdRegions::StdMatrixKey::GetNVarCoeff(), Nektar::StdRegions::StdExpansion::GetPointsKeys(), Nektar::StdRegions::StdMatrixKey::GetShapeType(), Nektar::StdRegions::StdExpansion::GetStdMatrix(), Nektar::StdRegions::StdMatrixKey::GetVarCoeffs(), Nektar::StdRegions::StdExpansion::m_base, m_matrixManager, Nektar::LocalRegions::Expansion::m_metricinfo, and Nektar::Transpose().

◆ CreateStaticCondMatrix()

DNekScalBlkMatSharedPtr Nektar::LocalRegions::QuadExp::CreateStaticCondMatrix ( const MatrixKey &  mkey)
protected

Definition at line 1996 of file QuadExp.cpp.

1998  {
1999  DNekScalBlkMatSharedPtr returnval;
2000 
2001  ASSERTL2(m_metricinfo->GetGtype()
2002  != SpatialDomains::eNoGeomType,
2003  "Geometric information is not set up");
2004 
2005  // set up block matrix system
2006  unsigned int nbdry = NumBndryCoeffs();
2007  unsigned int nint = (unsigned int)(m_ncoeffs - nbdry);
2008  unsigned int exp_size[] = {nbdry,nint};
2009  unsigned int nblks = 2;
2010  returnval = MemoryManager<DNekScalBlkMat>::
2011  AllocateSharedPtr(nblks,nblks,exp_size,exp_size);
2012  //Really need a constructor which takes Arrays
2013  NekDouble factor = 1.0;
2014 
2015  switch (mkey.GetMatrixType())
2016  {
2017  // this can only use stdregions statically condensed system
2018  // for mass matrix
2019  case StdRegions::eMass:
2020  if ((m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
2021  ||(mkey.GetNVarCoeff()))
2022  {
2023  factor = 1.0;
2024  goto UseLocRegionsMatrix;
2025  }
2026  else
2027  {
2028  factor = (m_metricinfo->GetJac(GetPointsKeys()))[0];
2029  goto UseStdRegionsMatrix;
2030  }
2031  break;
2032  default: // use Deformed case for both
2033  // regular and deformed geometries
2034  factor = 1.0;
2035  goto UseLocRegionsMatrix;
2036  break;
2037  UseStdRegionsMatrix:
2038  {
2039  NekDouble invfactor = 1.0/factor;
2040  NekDouble one = 1.0;
2041  DNekBlkMatSharedPtr mat = GetStdStaticCondMatrix(mkey);
2042  DNekScalMatSharedPtr Atmp;
2043  DNekMatSharedPtr Asubmat;
2044 
2045  returnval->SetBlock(0,0,Atmp = MemoryManager<DNekScalMat>::
2046  AllocateSharedPtr(factor,Asubmat = mat->GetBlock(0,0)));
2047  returnval->SetBlock(0,1,Atmp = MemoryManager<DNekScalMat>::
2048  AllocateSharedPtr(one,Asubmat = mat->GetBlock(0,1)));
2049  returnval->SetBlock(1,0,Atmp = MemoryManager<DNekScalMat>::
2050  AllocateSharedPtr(factor,Asubmat = mat->GetBlock(1,0)));
2051  returnval->SetBlock(1,1,Atmp = MemoryManager<DNekScalMat>::
2052  AllocateSharedPtr(invfactor,Asubmat = mat->GetBlock(1,1)));
2053  }
2054  break;
2055  UseLocRegionsMatrix:
2056  {
2057  int i,j;
2058  NekDouble invfactor = 1.0/factor;
2059  NekDouble one = 1.0;
2060  DNekScalMat &mat = *GetLocMatrix(mkey);
2061  DNekMatSharedPtr A = MemoryManager<DNekMat>::
2062  AllocateSharedPtr(nbdry,nbdry);
2063  DNekMatSharedPtr B = MemoryManager<DNekMat>::
2064  AllocateSharedPtr(nbdry,nint);
2065  DNekMatSharedPtr C = MemoryManager<DNekMat>::
2066  AllocateSharedPtr(nint,nbdry);
2067  DNekMatSharedPtr D = MemoryManager<DNekMat>::
2068  AllocateSharedPtr(nint,nint);
2069 
2070  Array<OneD,unsigned int> bmap(nbdry);
2071  Array<OneD,unsigned int> imap(nint);
2072  GetBoundaryMap(bmap);
2073  GetInteriorMap(imap);
2074 
2075  for (i = 0; i < nbdry; ++i)
2076  {
2077  for(j = 0; j < nbdry; ++j)
2078  {
2079  (*A)(i,j) = mat(bmap[i],bmap[j]);
2080  }
2081 
2082  for(j = 0; j < nint; ++j)
2083  {
2084  (*B)(i,j) = mat(bmap[i],imap[j]);
2085  }
2086  }
2087 
2088  for (i = 0; i < nint; ++i)
2089  {
2090  for(j = 0; j < nbdry; ++j)
2091  {
2092  (*C)(i,j) = mat(imap[i],bmap[j]);
2093  }
2094 
2095  for(j = 0; j < nint; ++j)
2096  {
2097  (*D)(i,j) = mat(imap[i],imap[j]);
2098  }
2099  }
2100 
2101  // Calculate static condensed system
2102  if(nint)
2103  {
2104  D->Invert();
2105  (*B) = (*B)*(*D);
2106  (*A) = (*A) - (*B)*(*C);
2107  }
2108 
2109  DNekScalMatSharedPtr Atmp;
2110 
2111  returnval->SetBlock(0,0,Atmp = MemoryManager<DNekScalMat>::
2112  AllocateSharedPtr(factor, A));
2113  returnval->SetBlock(0,1,Atmp = MemoryManager<DNekScalMat>::
2114  AllocateSharedPtr(one, B));
2115  returnval->SetBlock(1,0,Atmp = MemoryManager<DNekScalMat>::
2116  AllocateSharedPtr(factor, C));
2117  returnval->SetBlock(1,1,Atmp = MemoryManager<DNekScalMat>::
2118  AllocateSharedPtr(invfactor, D));
2119 
2120  }
2121  }
2122  return returnval;
2123  }
Nektar::LocalRegions::Expansion::GetLocMatrix
DNekScalMatSharedPtr GetLocMatrix(const LocalRegions::MatrixKey &mkey)
Definition: Expansion.cpp:90
Nektar::StdRegions::StdExpansion::GetBoundaryMap
void GetBoundaryMap(Array< OneD, unsigned int > &outarray)
Definition: StdExpansion.h:687
Nektar::StdRegions::StdExpansion::GetStdStaticCondMatrix
DNekBlkMatSharedPtr GetStdStaticCondMatrix(const StdMatrixKey &mkey)
Definition: StdExpansion.h:622
Nektar::StdRegions::StdExpansion::GetInteriorMap
void GetInteriorMap(Array< OneD, unsigned int > &outarray)
Definition: StdExpansion.h:692
Nektar::DNekBlkMatSharedPtr
std::shared_ptr< DNekBlkMat > DNekBlkMatSharedPtr
Definition: NekTypeDefs.hpp:71

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL2, Nektar::SpatialDomains::eDeformed, Nektar::StdRegions::eMass, Nektar::SpatialDomains::eNoGeomType, Nektar::StdRegions::StdExpansion::GetBoundaryMap(), Nektar::StdRegions::StdExpansion::GetInteriorMap(), Nektar::LocalRegions::Expansion::GetLocMatrix(), Nektar::StdRegions::StdMatrixKey::GetMatrixType(), Nektar::StdRegions::StdMatrixKey::GetNVarCoeff(), Nektar::StdRegions::StdExpansion::GetPointsKeys(), Nektar::StdRegions::StdExpansion::GetStdStaticCondMatrix(), Nektar::LocalRegions::Expansion::m_metricinfo, Nektar::StdRegions::StdExpansion::m_ncoeffs, and Nektar::StdRegions::StdExpansion::NumBndryCoeffs().

◆ v_AlignVectorToCollapsedDir()

void Nektar::LocalRegions::QuadExp::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 524 of file QuadExp.cpp.

528  {
529  ASSERTL1((dir==0) || (dir==1) || (dir==2),
530  "Invalid direction.");
531  ASSERTL1((dir==2) ? (m_geom->GetCoordim() ==3):true,
532  "Invalid direction.");
533 
534  int nquad0 = m_base[0]->GetNumPoints();
535  int nquad1 = m_base[1]->GetNumPoints();
536  int nqtot = nquad0*nquad1;
537  int nmodes0 = m_base[0]->GetNumModes();
538 
539  const Array<TwoD, const NekDouble>& df =
540  m_metricinfo->GetDerivFactors(GetPointsKeys());
541 
542  Array<OneD, NekDouble> tmp1 = outarray[0];
543  Array<OneD, NekDouble> tmp2 = outarray[1];
544  Array<OneD, NekDouble> tmp3(m_ncoeffs);
545  Array<OneD, NekDouble> tmp4(nmodes0*nquad1);
546 
547  if (m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
548  {
549  Vmath::Vmul(nqtot,
550  &df[2*dir][0], 1,
551  inarray.get(), 1,
552  tmp1.get(), 1);
553  Vmath::Vmul(nqtot,
554  &df[2*dir+1][0], 1,
555  inarray.get(), 1,
556  tmp2.get(),1);
557  }
558  else
559  {
560  Vmath::Smul(nqtot,
561  df[2*dir][0], inarray.get(), 1,
562  tmp1.get(), 1);
563  Vmath::Smul(nqtot,
564  df[2*dir+1][0], inarray.get(), 1,
565  tmp2.get(), 1);
566  }
567  }
ASSERTL1
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode....
Definition: ErrorUtil.hpp:250
Nektar::LocalRegions::Expansion::m_geom
SpatialDomains::GeometrySharedPtr m_geom
Definition: Expansion.h:272
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:192
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:225

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(), and Vmath::Vmul().

Referenced by v_IProductWRTDerivBase_SumFac().

◆ v_ComputeLaplacianMetric()

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

Reimplemented from Nektar::LocalRegions::Expansion.

Definition at line 2340 of file QuadExp.cpp.

2341  {
2342  if (m_metrics.count(eMetricQuadrature) == 0)
2343  {
2344  ComputeQuadratureMetric();
2345  }
2346 
2347  const SpatialDomains::GeomType type = m_metricinfo->GetGtype();
2348  const unsigned int nqtot = GetTotPoints();
2349  const unsigned int dim = 2;
2350  const MetricType m[3][3] = { {eMetricLaplacian00, eMetricLaplacian01, eMetricLaplacian02},
2351  {eMetricLaplacian01, eMetricLaplacian11, eMetricLaplacian12},
2352  {eMetricLaplacian02, eMetricLaplacian12, eMetricLaplacian22}
2353  };
2354 
2355  const Array<TwoD, const NekDouble> gmat =
2356  m_metricinfo->GetGmat(GetPointsKeys());
2357  for (unsigned int i = 0; i < dim; ++i)
2358  {
2359  for (unsigned int j = i; j < dim; ++j)
2360  {
2361  m_metrics[m[i][j]] = Array<OneD, NekDouble>(nqtot);
2362  if (type == SpatialDomains::eDeformed)
2363  {
2364  Vmath::Vcopy(nqtot, &gmat[i*dim+j][0], 1,
2365  &m_metrics[m[i][j]][0], 1);
2366  }
2367  else
2368  {
2369  Vmath::Fill(nqtot, gmat[i*dim+j][0],
2370  &m_metrics[m[i][j]][0], 1);
2371  }
2372  MultiplyByQuadratureMetric(m_metrics[m[i][j]],
2373  m_metrics[m[i][j]]);
2374 
2375  }
2376  }
2377  }
Nektar::StdRegions::StdExpansion::GetTotPoints
int GetTotPoints() const
This function returns the total number of quadrature points used in the element.
Definition: StdExpansion.h:134
Nektar::StdRegions::StdExpansion::MultiplyByQuadratureMetric
void MultiplyByQuadratureMetric(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
Definition: StdExpansion.h:733
Nektar::SpatialDomains::GeomType
GeomType
Indicates the type of element geometry.
Definition: SpatialDomains.hpp:52
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
Vmath::Vcopy
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1199

References Nektar::LocalRegions::Expansion::ComputeQuadratureMetric(), Nektar::SpatialDomains::eDeformed, Nektar::LocalRegions::eMetricLaplacian00, Nektar::LocalRegions::eMetricLaplacian01, Nektar::LocalRegions::eMetricLaplacian02, Nektar::LocalRegions::eMetricLaplacian11, Nektar::LocalRegions::eMetricLaplacian12, Nektar::LocalRegions::eMetricLaplacian22, Nektar::LocalRegions::eMetricQuadrature, Vmath::Fill(), Nektar::StdRegions::StdExpansion::GetPointsKeys(), Nektar::StdRegions::StdExpansion::GetTotPoints(), Nektar::LocalRegions::Expansion::m_metricinfo, Nektar::LocalRegions::Expansion::m_metrics, Nektar::StdRegions::StdExpansion::MultiplyByQuadratureMetric(), and Vmath::Vcopy().

◆ v_ComputeTraceNormal()

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

Reimplemented from Nektar::LocalRegions::Expansion.

Definition at line 1220 of file QuadExp.cpp.

1221  {
1222  int i;
1223  const SpatialDomains::GeomFactorsSharedPtr & geomFactors =
1224  GetGeom()->GetMetricInfo();
1225  SpatialDomains::GeomType type = geomFactors->GetGtype();
1226 
1227  LibUtilities::PointsKeyVector ptsKeys = GetPointsKeys();
1228  for(i = 0; i < ptsKeys.size(); ++i)
1229  {
1230  // Need at least 2 points for computing normals
1231  if (ptsKeys[i].GetNumPoints() == 1)
1232  {
1233  LibUtilities::PointsKey pKey(2, ptsKeys[i].GetPointsType());
1234  ptsKeys[i] = pKey;
1235  }
1236  }
1237 
1238  const Array<TwoD, const NekDouble> & df = geomFactors->GetDerivFactors(ptsKeys);
1239  const Array<OneD, const NekDouble> & jac = geomFactors->GetJac(ptsKeys);
1240  int nqe;
1241  if (edge == 0 || edge == 2)
1242  {
1243  nqe = m_base[0]->GetNumPoints();
1244  }
1245  else
1246  {
1247  nqe = m_base[1]->GetNumPoints();
1248  }
1249  int vCoordDim = GetCoordim();
1250 
1251  m_edgeNormals[edge] = Array<OneD, Array<OneD, NekDouble> >
1252  (vCoordDim);
1253  Array<OneD, Array<OneD, NekDouble> > &normal = m_edgeNormals[edge];
1254  for (i = 0; i < vCoordDim; ++i)
1255  {
1256  normal[i] = Array<OneD, NekDouble>(nqe);
1257  }
1258 
1259  size_t nqb = nqe;
1260  size_t nbnd= edge;
1261  m_elmtBndNormDirElmtLen[nbnd] = Array<OneD, NekDouble> {nqb, 0.0};
1262  Array<OneD, NekDouble> &length = m_elmtBndNormDirElmtLen[nbnd];
1263 
1264  // Regular geometry case
1265  if ((type == SpatialDomains::eRegular)||
1266  (type == SpatialDomains::eMovingRegular))
1267  {
1268  NekDouble fac;
1269  // Set up normals
1270  switch (edge)
1271  {
1272  case 0:
1273  for (i = 0; i < vCoordDim; ++i)
1274  {
1275  Vmath::Fill(nqe, -df[2*i+1][0], normal[i], 1);
1276  }
1277  break;
1278  case 1:
1279  for (i = 0; i < vCoordDim; ++i)
1280  {
1281  Vmath::Fill(nqe, df[2*i][0], normal[i], 1);
1282  }
1283  break;
1284  case 2:
1285  for (i = 0; i < vCoordDim; ++i)
1286  {
1287  Vmath::Fill(nqe, df[2*i+1][0], normal[i], 1);
1288  }
1289  break;
1290  case 3:
1291  for (i = 0; i < vCoordDim; ++i)
1292  {
1293  Vmath::Fill(nqe, -df[2*i][0], normal[i], 1);
1294  }
1295  break;
1296  default:
1297  ASSERTL0(false, "edge is out of range (edge < 4)");
1298  }
1299 
1300  // normalise
1301  fac = 0.0;
1302  for (i =0 ; i < vCoordDim; ++i)
1303  {
1304  fac += normal[i][0]*normal[i][0];
1305  }
1306  fac = 1.0/sqrt(fac);
1307 
1308  Vmath::Fill(nqb, fac, length, 1);
1309 
1310  for (i = 0; i < vCoordDim; ++i)
1311  {
1312  Vmath::Smul(nqe, fac, normal[i], 1,normal[i], 1);
1313  }
1314  }
1315  else // Set up deformed normals
1316  {
1317  int j;
1318 
1319  int nquad0 = ptsKeys[0].GetNumPoints();
1320  int nquad1 = ptsKeys[1].GetNumPoints();
1321 
1322  LibUtilities::PointsKey from_key;
1323 
1324  Array<OneD,NekDouble> normals(vCoordDim*max(nquad0,nquad1),0.0);
1325  Array<OneD,NekDouble> edgejac(vCoordDim*max(nquad0,nquad1),0.0);
1326 
1327  // Extract Jacobian along edges and recover local
1328  // derivates (dx/dr) for polynomial interpolation by
1329  // multiplying m_gmat by jacobian
1330 
1331  // Implementation for all the basis except Gauss points
1332  if (m_base[0]->GetPointsType() !=
1333  LibUtilities::eGaussGaussLegendre
1334  && m_base[1]->GetPointsType() !=
1335  LibUtilities::eGaussGaussLegendre)
1336  {
1337  switch (edge)
1338  {
1339  case 0:
1340  for (j = 0; j < nquad0; ++j)
1341  {
1342  edgejac[j] = jac[j];
1343  for (i = 0; i < vCoordDim; ++i)
1344  {
1345  normals[i*nquad0+j] =
1346  -df[2*i+1][j]*edgejac[j];
1347  }
1348  }
1349  from_key = ptsKeys[0];
1350  break;
1351  case 1:
1352  for (j = 0; j < nquad1; ++j)
1353  {
1354  edgejac[j] = jac[nquad0*j+nquad0-1];
1355  for (i = 0; i < vCoordDim; ++i)
1356  {
1357  normals[i*nquad1+j] =
1358  df[2*i][nquad0*j + nquad0-1]
1359  *edgejac[j];
1360  }
1361  }
1362  from_key = ptsKeys[1];
1363  break;
1364  case 2:
1365  for (j = 0; j < nquad0; ++j)
1366  {
1367  edgejac[j] = jac[nquad0*(nquad1-1)+j];
1368  for (i = 0; i < vCoordDim; ++i)
1369  {
1370  normals[i*nquad0+j] =
1371  (df[2*i+1][nquad0*(nquad1-1)+j])
1372  *edgejac[j];
1373  }
1374  }
1375  from_key = ptsKeys[0];
1376  break;
1377  case 3:
1378  for (j = 0; j < nquad1; ++j)
1379  {
1380  edgejac[j] = jac[nquad0*j];
1381  for (i = 0; i < vCoordDim; ++i)
1382  {
1383  normals[i*nquad1+j] =
1384  -df[2*i][nquad0*j]*edgejac[j];
1385  }
1386  }
1387  from_key = ptsKeys[1];
1388  break;
1389  default:
1390  ASSERTL0(false,"edge is out of range (edge < 3)");
1391  }
1392  }
1393  else
1394  {
1395  int nqtot = nquad0 * nquad1;
1396  Array<OneD, NekDouble> tmp_gmat(nqtot, 0.0);
1397  Array<OneD, NekDouble> tmp_gmat_edge(nqe, 0.0);
1398 
1399  switch (edge)
1400  {
1401  case 0:
1402  for (j = 0; j < nquad0; ++j)
1403  {
1404  for (i = 0; i < vCoordDim; ++i)
1405  {
1406  Vmath::Vmul(nqtot,
1407  &(df[2*i+1][0]), 1,
1408  &jac[0], 1,
1409  &(tmp_gmat[0]), 1);
1410  QuadExp::v_GetEdgeInterpVals(
1411  edge, tmp_gmat, tmp_gmat_edge);
1412  normals[i*nquad0+j] = -tmp_gmat_edge[j];
1413  }
1414  }
1415  from_key = ptsKeys[0];
1416  break;
1417  case 1:
1418  for (j = 0; j < nquad1; ++j)
1419  {
1420  for (i = 0; i < vCoordDim; ++i)
1421  {
1422  Vmath::Vmul(nqtot,
1423  &(df[2*i][0]), 1,
1424  &jac[0], 1,
1425  &(tmp_gmat[0]), 1);
1426  QuadExp::v_GetEdgeInterpVals(
1427  edge, tmp_gmat, tmp_gmat_edge);
1428  normals[i*nquad1+j] = tmp_gmat_edge[j];
1429  }
1430  }
1431  from_key = ptsKeys[1];
1432  break;
1433  case 2:
1434  for (j = 0; j < nquad0; ++j)
1435  {
1436  for (i = 0; i < vCoordDim; ++i)
1437  {
1438  Vmath::Vmul(nqtot,
1439  &(df[2*i+1][0]), 1,
1440  &jac[0], 1,
1441  &(tmp_gmat[0]), 1);
1442  QuadExp::v_GetEdgeInterpVals(
1443  edge, tmp_gmat, tmp_gmat_edge);
1444  normals[i*nquad0+j] = tmp_gmat_edge[j];
1445  }
1446  }
1447  from_key = ptsKeys[0];
1448  break;
1449  case 3:
1450  for (j = 0; j < nquad1; ++j)
1451  {
1452  for (i = 0; i < vCoordDim; ++i)
1453  {
1454  Vmath::Vmul(nqtot,
1455  &(df[2*i][0]), 1,
1456  &jac[0], 1,
1457  &(tmp_gmat[0]) ,1);
1458  QuadExp::v_GetEdgeInterpVals(
1459  edge, tmp_gmat, tmp_gmat_edge);
1460  normals[i*nquad1+j] = -tmp_gmat_edge[j];
1461  }
1462  }
1463  from_key = ptsKeys[1];
1464  break;
1465  default:
1466  ASSERTL0(false,"edge is out of range (edge < 3)");
1467  }
1468  }
1469 
1470  int nq = from_key.GetNumPoints();
1471  Array<OneD,NekDouble> work(nqe,0.0);
1472 
1473  // interpolate Jacobian and invert
1474  LibUtilities::Interp1D(
1475  from_key,jac, m_base[0]->GetPointsKey(), work);
1476  Vmath::Sdiv(nqe,1.0,&work[0],1,&work[0],1);
1477 
1478  // interpolate
1479  for (i = 0; i < GetCoordim(); ++i)
1480  {
1481  LibUtilities::Interp1D(
1482  from_key,&normals[i*nq],
1483  m_base[0]->GetPointsKey(),
1484  &normal[i][0]);
1485  Vmath::Vmul(nqe, work, 1, normal[i], 1, normal[i], 1);
1486  }
1487 
1488  //normalise normal vectors
1489  Vmath::Zero(nqe,work,1);
1490  for (i = 0; i < GetCoordim(); ++i)
1491  {
1492  Vmath::Vvtvp(nqe,
1493  normal[i], 1,
1494  normal[i],1 ,
1495  work, 1,
1496  work, 1);
1497  }
1498 
1499  Vmath::Vsqrt(nqe,work,1,work,1);
1500  Vmath::Sdiv(nqe,1.0,work,1,work,1);
1501 
1502  Vmath::Vcopy(nqb, work, 1, length, 1);
1503 
1504  for (i = 0; i < GetCoordim(); ++i)
1505  {
1506  Vmath::Vmul(nqe, normal[i], 1, work, 1, normal[i], 1);
1507  }
1508  }
1509  if (GetGeom()->GetEorient(edge) == StdRegions::eBackwards)
1510  {
1511  for (i = 0; i < vCoordDim; ++i)
1512  {
1513  if (geomFactors->GetGtype() == SpatialDomains::eDeformed)
1514  {
1515  Vmath::Reverse(nqe, normal[i], 1, normal[i],1);
1516  }
1517  }
1518  }
1519  }
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:216
Nektar::LocalRegions::Expansion2D::m_edgeNormals
std::map< int, NormalVector > m_edgeNormals
Definition: Expansion2D.h:121
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:284
Nektar::LocalRegions::Expansion::GetGeom
SpatialDomains::GeometrySharedPtr GetGeom() const
Definition: Expansion.cpp:172
Nektar::LocalRegions::QuadExp::v_GetEdgeInterpVals
virtual void v_GetEdgeInterpVals(const int edge, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
Definition: QuadExp.cpp:854
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:208
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:221
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:53
Nektar::LibUtilities::eGaussGaussLegendre
@ eGaussGaussLegendre
1D Gauss-Gauss-Legendre quadrature points
Definition: PointsType.h:48
Nektar::SpatialDomains::GeomFactorsSharedPtr
std::shared_ptr< GeomFactors > GeomFactorsSharedPtr
Pointer to a GeomFactors object.
Definition: GeomFactors.h:62
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
Vmath::Vsqrt
void Vsqrt(int n, const T *x, const int incx, T *y, const int incy)
sqrt y = sqrt(x)
Definition: Vmath.cpp:475
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:513
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:291
Vmath::Zero
void Zero(int n, T *x, const int incx)
Zero vector.
Definition: Vmath.cpp:436
Vmath::Reverse
void Reverse(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1226
tinysimd::sqrt
scalarT< T > sqrt(scalarT< T > in)
Definition: scalar.hpp:267

References ASSERTL0, Nektar::StdRegions::eBackwards, Nektar::SpatialDomains::eDeformed, Nektar::LibUtilities::eGaussGaussLegendre, 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::Expansion2D::m_edgeNormals, Nektar::LocalRegions::Expansion::m_elmtBndNormDirElmtLen, Vmath::Reverse(), Vmath::Sdiv(), Vmath::Smul(), tinysimd::sqrt(), v_GetEdgeInterpVals(), Vmath::Vcopy(), Vmath::Vmul(), Vmath::Vsqrt(), Vmath::Vvtvp(), and Vmath::Zero().

◆ v_CreateStdMatrix()

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

Reimplemented from Nektar::StdRegions::StdQuadExp.

Definition at line 1671 of file QuadExp.cpp.

1673  {
1674  LibUtilities::BasisKey bkey0 = m_base[0]->GetBasisKey();
1675  LibUtilities::BasisKey bkey1 = m_base[1]->GetBasisKey();
1676  StdRegions::StdQuadExpSharedPtr tmp =
1677  MemoryManager<StdQuadExp>::AllocateSharedPtr(bkey0,bkey1);
1678  return tmp->GetStdMatrix(mkey);
1679  }
Nektar::StdRegions::StdQuadExpSharedPtr
std::shared_ptr< StdQuadExp > StdQuadExpSharedPtr
Definition: StdQuadExp.h:273

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

◆ v_DropLocStaticCondMatrix()

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 2138 of file QuadExp.cpp.

2139  {
2140  m_staticCondMatrixManager.DeleteObject(mkey);
2141  }

References m_staticCondMatrixManager.

◆ v_ExtractDataToCoeffs()

void Nektar::LocalRegions::QuadExp::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 1533 of file QuadExp.cpp.

1539  {
1540  int data_order0 = nummodes[mode_offset];
1541  int fillorder0 = std::min(m_base[0]->GetNumModes(),data_order0);
1542 
1543  int data_order1 = nummodes[mode_offset + 1];
1544  int order1 = m_base[1]->GetNumModes();
1545  int fillorder1 = min(order1,data_order1);
1546 
1547  // Check if same basis
1548  if (fromType[0] != m_base[0]->GetBasisType() ||
1549  fromType[1] != m_base[1]->GetBasisType())
1550  {
1551  // Construct a quad with the appropriate basis type at our
1552  // quadrature points, and one more to do a forwards
1553  // transform. We can then copy the output to coeffs.
1554  StdRegions::StdQuadExp tmpQuad(
1555  LibUtilities::BasisKey(
1556  fromType[0], data_order0, m_base[0]->GetPointsKey()),
1557  LibUtilities::BasisKey(
1558  fromType[1], data_order1, m_base[1]->GetPointsKey()));
1559  StdRegions::StdQuadExp tmpQuad2(m_base[0]->GetBasisKey(),
1560  m_base[1]->GetBasisKey());
1561 
1562  Array<OneD, const NekDouble> tmpData(tmpQuad.GetNcoeffs(), data);
1563  Array<OneD, NekDouble> tmpBwd(tmpQuad2.GetTotPoints());
1564  Array<OneD, NekDouble> tmpOut(tmpQuad2.GetNcoeffs());
1565 
1566  tmpQuad.BwdTrans(tmpData, tmpBwd);
1567  tmpQuad2.FwdTrans(tmpBwd, tmpOut);
1568  Vmath::Vcopy(tmpOut.size(), &tmpOut[0], 1, coeffs, 1);
1569 
1570  return;
1571  }
1572 
1573  switch (m_base[0]->GetBasisType())
1574  {
1575  case LibUtilities::eModified_A:
1576  {
1577  int i;
1578  int cnt = 0;
1579  int cnt1 = 0;
1580 
1581  ASSERTL1(m_base[1]->GetBasisType() ==
1582  LibUtilities::eModified_A,
1583  "Extraction routine not set up for this basis");
1584 
1585  Vmath::Zero(m_ncoeffs,coeffs,1);
1586  for (i = 0; i < fillorder0; ++i)
1587  {
1588  Vmath::Vcopy(fillorder1, data + cnt, 1, coeffs +cnt1, 1);
1589  cnt += data_order1;
1590  cnt1 += order1;
1591  }
1592  }
1593  break;
1594  case LibUtilities::eGLL_Lagrange:
1595  {
1596  LibUtilities::PointsKey
1597  p0(nummodes[0], LibUtilities::eGaussLobattoLegendre);
1598  LibUtilities::PointsKey
1599  p1(nummodes[1], LibUtilities::eGaussLobattoLegendre);
1600  LibUtilities::PointsKey t0(
1601  m_base[0]->GetNumModes(),
1602  LibUtilities::eGaussLobattoLegendre);
1603  LibUtilities::PointsKey t1(
1604  m_base[1]->GetNumModes(),
1605  LibUtilities::eGaussLobattoLegendre);
1606  LibUtilities::Interp2D(p0, p1, data, t0, t1, coeffs);
1607  }
1608  break;
1609  case LibUtilities::eGauss_Lagrange:
1610  {
1611  // Assume that input is also Gll_Lagrange but no way to check;
1612  LibUtilities::PointsKey
1613  p0(nummodes[0],LibUtilities::eGaussGaussLegendre);
1614  LibUtilities::PointsKey
1615  p1(nummodes[1],LibUtilities::eGaussGaussLegendre);
1616  LibUtilities::PointsKey t0(
1617  m_base[0]->GetNumModes(),
1618  LibUtilities::eGaussGaussLegendre);
1619  LibUtilities::PointsKey t1(
1620  m_base[1]->GetNumModes(),
1621  LibUtilities::eGaussGaussLegendre);
1622  LibUtilities::Interp2D(p0, p1, data, t0, t1, coeffs);
1623  }
1624  break;
1625  default:
1626  ASSERTL0(false,
1627  "basis is either not set up or not hierarchicial");
1628  }
1629  }
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:158
Nektar::LibUtilities::Interp2D
void Interp2D(const BasisKey &fbasis0, const BasisKey &fbasis1, const Array< OneD, const NekDouble > &from, const BasisKey &tbasis0, const BasisKey &tbasis1, Array< OneD, NekDouble > &to)
this function interpolates a 2D function evaluated at the quadrature points of the 2D basis,...
Definition: Interp.cpp:115
Nektar::LibUtilities::eGaussLobattoLegendre
@ eGaussLobattoLegendre
1D Gauss-Lobatto-Legendre quadrature points
Definition: PointsType.h:51
Nektar::LibUtilities::eGauss_Lagrange
@ eGauss_Lagrange
Lagrange Polynomials using the Gauss points .
Definition: BasisType.h:55
Nektar::LibUtilities::eGLL_Lagrange
@ eGLL_Lagrange
Lagrange for SEM basis .
Definition: BasisType.h:54
Nektar::LibUtilities::eModified_A
@ eModified_A
Principle Modified Functions .
Definition: BasisType.h:48

References ASSERTL0, ASSERTL1, Nektar::StdRegions::StdExpansion::BwdTrans(), Nektar::LibUtilities::eGauss_Lagrange, Nektar::LibUtilities::eGaussGaussLegendre, Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eGLL_Lagrange, Nektar::LibUtilities::eModified_A, Nektar::StdRegions::StdExpansion::FwdTrans(), Nektar::StdRegions::StdExpansion::GetBasisType(), Nektar::StdRegions::StdExpansion::GetNcoeffs(), Nektar::StdRegions::StdExpansion::GetTotPoints(), Nektar::LibUtilities::Interp2D(), Nektar::StdRegions::StdExpansion::m_base, Nektar::StdRegions::StdExpansion::m_ncoeffs, Vmath::Vcopy(), and Vmath::Zero().

◆ v_FwdTrans()

void Nektar::LocalRegions::QuadExp::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::StdQuadExp.

Definition at line 261 of file QuadExp.cpp.

264  {
265  if ((m_base[0]->Collocation())&&(m_base[1]->Collocation()))
266  {
267  Vmath::Vcopy(m_ncoeffs, inarray, 1, outarray, 1);
268  }
269  else
270  {
271  IProductWRTBase(inarray,outarray);
272 
273  // get Mass matrix inverse
274  MatrixKey masskey(StdRegions::eInvMass,
275  DetShapeType(),*this);
276  DNekScalMatSharedPtr matsys = m_matrixManager[masskey];
277 
278  // copy inarray in case inarray == outarray
279  NekVector<NekDouble> in(m_ncoeffs,outarray,eCopy);
280  NekVector<NekDouble> out(m_ncoeffs,outarray,eWrapper);
281 
282  out = (*matsys)*in;
283  }
284  }
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:537

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

◆ v_FwdTrans_BndConstrained()

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

Reimplemented from Nektar::StdRegions::StdQuadExp.

Definition at line 287 of file QuadExp.cpp.

290  {
291  if ((m_base[0]->Collocation())&&(m_base[1]->Collocation()))
292  {
293  Vmath::Vcopy(m_ncoeffs, inarray, 1, outarray, 1);
294  }
295  else
296  {
297  int i,j;
298  int npoints[2] = {m_base[0]->GetNumPoints(),
299  m_base[1]->GetNumPoints()};
300  int nmodes[2] = {m_base[0]->GetNumModes(),
301  m_base[1]->GetNumModes()};
302 
303  fill(outarray.get(), outarray.get()+m_ncoeffs, 0.0 );
304 
305  if(nmodes[0] == 1 && nmodes[1] == 1)
306  {
307  outarray[0] = inarray[0];
308  return;
309  }
310 
311  Array<OneD, NekDouble> physEdge[4];
312  Array<OneD, NekDouble> coeffEdge[4];
313  StdRegions::Orientation orient[4];
314  for (i = 0; i < 4; i++)
315  {
316  physEdge[i] = Array<OneD, NekDouble>(npoints[i%2]);
317  coeffEdge[i] = Array<OneD, NekDouble>(nmodes[i%2]);
318  orient[i] = GetTraceOrient(i);
319  }
320 
321  for (i = 0; i < npoints[0]; i++)
322  {
323  physEdge[0][i] = inarray[i];
324  physEdge[2][i] = inarray[npoints[0]*(npoints[1]-1)+i];
325  }
326 
327  for (i = 0; i < npoints[1]; i++)
328  {
329  physEdge[1][i] =
330  inarray[npoints[0]-1+i*npoints[0]];
331  physEdge[3][i] =
332  inarray[i*npoints[0]];
333  }
334 
335  for (i = 0; i < 4; i++)
336  {
337  if ( orient[i] == StdRegions::eBackwards )
338  {
339  reverse((physEdge[i]).get(),
340  (physEdge[i]).get() + npoints[i%2] );
341  }
342  }
343 
344  SegExpSharedPtr segexp[4];
345  for (i = 0; i < 4; i++)
346  {
347  segexp[i] = MemoryManager<LocalRegions::SegExp>::
348  AllocateSharedPtr(
349  m_base[i%2]->GetBasisKey(),GetGeom2D()->GetEdge(i));
350  }
351 
352  Array<OneD, unsigned int> mapArray;
353  Array<OneD, int> signArray;
354  NekDouble sign;
355 
356  for (i = 0; i < 4; i++)
357  {
358  segexp[i%2]->FwdTrans_BndConstrained(
359  physEdge[i],coeffEdge[i]);
360 
361  GetTraceToElementMap(i,mapArray,signArray,orient[i]);
362  for (j=0; j < nmodes[i%2]; j++)
363  {
364  sign = (NekDouble) signArray[j];
365  outarray[ mapArray[j] ] = sign * coeffEdge[i][j];
366  }
367  }
368 
369  int nBoundaryDofs = NumBndryCoeffs();
370  int nInteriorDofs = m_ncoeffs - nBoundaryDofs;
371 
372  if (nInteriorDofs > 0) {
373  Array<OneD, NekDouble> tmp0(m_ncoeffs);
374  Array<OneD, NekDouble> tmp1(m_ncoeffs);
375 
376  StdRegions::StdMatrixKey
377  stdmasskey(StdRegions::eMass,DetShapeType(),*this);
378  MassMatrixOp(outarray,tmp0,stdmasskey);
379  IProductWRTBase(inarray,tmp1);
380 
381  Vmath::Vsub(m_ncoeffs, tmp1, 1, tmp0, 1, tmp1, 1);
382 
383  // get Mass matrix inverse (only of interior DOF)
384  // use block (1,1) of the static condensed system
385  // note: this block alreay contains the inverse matrix
386  MatrixKey
387  masskey(StdRegions::eMass,DetShapeType(),*this);
388  DNekScalMatSharedPtr matsys =
389  (m_staticCondMatrixManager[masskey])->GetBlock(1,1);
390 
391  Array<OneD, NekDouble> rhs(nInteriorDofs);
392  Array<OneD, NekDouble> result(nInteriorDofs);
393 
394  GetInteriorMap(mapArray);
395 
396  for (i = 0; i < nInteriorDofs; i++)
397  {
398  rhs[i] = tmp1[ mapArray[i] ];
399  }
400 
401  Blas::Dgemv('N', nInteriorDofs, nInteriorDofs,
402  matsys->Scale(),
403  &((matsys->GetOwnedMatrix())->GetPtr())[0],
404  nInteriorDofs,rhs.get(),1,0.0,result.get(),1);
405 
406  for (i = 0; i < nInteriorDofs; i++)
407  {
408  outarray[ mapArray[i] ] = result[i];
409  }
410  }
411  }
412 
413  }
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:204
Nektar::LocalRegions::Expansion::GetTraceOrient
StdRegions::Orientation GetTraceOrient(int trace)
Definition: Expansion.h:164
Nektar::StdRegions::StdExpansion::MassMatrixOp
void MassMatrixOp(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
Definition: StdExpansion.h:762
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:703
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:265
Nektar::LocalRegions::SegExpSharedPtr
std::shared_ptr< SegExp > SegExpSharedPtr
Definition: SegExp.h:272
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:372

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::StdRegions::StdExpansion::DetShapeType(), Blas::Dgemv(), Nektar::StdRegions::eBackwards, Nektar::StdRegions::eMass, Nektar::LocalRegions::Expansion2D::GetGeom2D(), Nektar::StdRegions::StdExpansion::GetInteriorMap(), Nektar::LocalRegions::Expansion::GetTraceOrient(), Nektar::StdRegions::StdExpansion::GetTraceToElementMap(), 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, Vmath::Vcopy(), and Vmath::Vsub().

◆ v_GeneralMatrixOp_MatOp()

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

Definition at line 2213 of file QuadExp.cpp.

2217  {
2218  MatrixKey newkey(mkey);
2219  DNekScalMatSharedPtr mat = GetLocMatrix(newkey);
2220 
2221  if (inarray.get() == outarray.get())
2222  {
2223  Array<OneD,NekDouble> tmp(m_ncoeffs);
2224  Vmath::Vcopy(m_ncoeffs,inarray.get(),1,tmp.get(),1);
2225 
2226  Blas::Dgemv('N',m_ncoeffs,m_ncoeffs, mat->Scale(),
2227  (mat->GetOwnedMatrix())->GetPtr().get(), m_ncoeffs,
2228  tmp.get(), 1, 0.0, outarray.get(), 1);
2229  }
2230  else
2231  {
2232  Blas::Dgemv('N',m_ncoeffs,m_ncoeffs,mat->Scale(),
2233  (mat->GetOwnedMatrix())->GetPtr().get(), m_ncoeffs,
2234  inarray.get(), 1, 0.0, outarray.get(), 1);
2235  }
2236  }

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

◆ v_GenMatrix()

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

Reimplemented from Nektar::StdRegions::StdQuadExp.

Definition at line 1650 of file QuadExp.cpp.

1652  {
1653  DNekMatSharedPtr returnval;
1654  switch (mkey.GetMatrixType())
1655  {
1656  case StdRegions::eHybridDGHelmholtz:
1657  case StdRegions::eHybridDGLamToU:
1658  case StdRegions::eHybridDGLamToQ0:
1659  case StdRegions::eHybridDGLamToQ1:
1660  case StdRegions::eHybridDGLamToQ2:
1661  case StdRegions::eHybridDGHelmBndLam:
1662  case StdRegions::eInvLaplacianWithUnityMean:
1663  returnval = Expansion2D::v_GenMatrix(mkey);
1664  break;
1665  default:
1666  returnval = StdQuadExp::v_GenMatrix(mkey);
1667  }
1668  return returnval;
1669  }
Nektar::LocalRegions::Expansion2D::v_GenMatrix
virtual DNekMatSharedPtr v_GenMatrix(const StdRegions::StdMatrixKey &mkey)
Definition: Expansion2D.cpp:680

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::QuadExp::v_GetBasis ( int  dir) const
protectedvirtual

Definition at line 1638 of file QuadExp.cpp.

1639  {
1640  ASSERTL1(dir >= 0 &&dir <= 1, "input dir is out of range");
1641  return m_base[dir];
1642  }

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

◆ v_GetCoord()

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 674 of file QuadExp.cpp.

676  {
677  int i;
678 
679  ASSERTL1(Lcoords[0] >= -1.0 && Lcoords[1] <= 1.0 &&
680  Lcoords[1] >= -1.0 && Lcoords[1] <=1.0,
681  "Local coordinates are not in region [-1,1]");
682 
683  m_geom->FillGeom();
684  for (i = 0; i < m_geom->GetCoordim(); ++i)
685  {
686  coords[i] = m_geom->GetCoord(i,Lcoords);
687  }
688  }

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

◆ v_GetCoordim()

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

Reimplemented from Nektar::StdRegions::StdExpansion2D.

Definition at line 1527 of file QuadExp.cpp.

1528  {
1529  return m_geom->GetCoordim();
1530  }

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

◆ v_GetCoords()

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

Reimplemented from Nektar::StdRegions::StdQuadExp.

Definition at line 665 of file QuadExp.cpp.

669  {
670  Expansion::v_GetCoords(coords_0, coords_1, coords_2);
671  }
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:318

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

◆ v_GetEdgeInterpVals()

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

Definition at line 854 of file QuadExp.cpp.

857  {
858  int i;
859  int nq0 = m_base[0]->GetNumPoints();
860  int nq1 = m_base[1]->GetNumPoints();
861 
862  StdRegions::ConstFactorMap factors;
863  factors[StdRegions::eFactorGaussEdge] = edge;
864 
865  StdRegions::StdMatrixKey key(
866  StdRegions::eInterpGauss,
867  DetShapeType(),*this,factors);
868 
869  DNekScalMatSharedPtr mat_gauss = m_matrixManager[key];
870 
871  switch (edge)
872  {
873  case 0:
874  {
875  for (i = 0; i < nq0; i++)
876  {
877  outarray[i] = Blas::Ddot(
878  nq1, mat_gauss->GetOwnedMatrix()->GetPtr().get(),
879  1, &inarray[i], nq0);
880  }
881  break;
882  }
883  case 1:
884  {
885  for (i = 0; i < nq1; i++)
886  {
887  outarray[i] = Blas::Ddot(
888  nq0, mat_gauss->GetOwnedMatrix()->GetPtr().get(),
889  1, &inarray[i * nq0], 1);
890  }
891  break;
892  }
893  case 2:
894  {
895  for (i = 0; i < nq0; i++)
896  {
897  outarray[i] = Blas::Ddot(
898  nq1, mat_gauss->GetOwnedMatrix()->GetPtr().get(),
899  1, &inarray[i], nq0);
900  }
901  break;
902  }
903  case 3:
904  {
905  for (i = 0; i < nq1; i++)
906  {
907  outarray[i] = Blas::Ddot(
908  nq0, mat_gauss->GetOwnedMatrix()->GetPtr().get(),
909  1, &inarray[i * nq0], 1);
910  }
911  break;
912  }
913  default:
914  ASSERTL0(false, "edge value (< 3) is out of range");
915  break;
916  }
917  }
Blas::Ddot
static double Ddot(const int &n, const double *x, const int &incx, const double *y, const int &incy)
BLAS level 1: output = .
Definition: Blas.hpp:197

References ASSERTL0, Blas::Ddot(), Nektar::StdRegions::StdExpansion::DetShapeType(), Nektar::StdRegions::eFactorGaussEdge, Nektar::StdRegions::eInterpGauss, Nektar::StdRegions::StdExpansion::m_base, and m_matrixManager.

Referenced by v_ComputeTraceNormal(), v_GetTracePhysVals(), and v_GetTraceQFactors().

◆ v_GetEdgePhysVals()

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

Definition at line 721 of file QuadExp.cpp.

725  {
726  int nquad0 = m_base[0]->GetNumPoints();
727  int nquad1 = m_base[1]->GetNumPoints();
728 
729  StdRegions::Orientation edgedir = GetTraceOrient(edge);
730  switch(edge)
731  {
732  case 0:
733  if (edgedir == StdRegions::eForwards)
734  {
735  Vmath::Vcopy(nquad0,&(inarray[0]),1,&(outarray[0]),1);
736  }
737  else
738  {
739  Vmath::Vcopy(nquad0,&(inarray[0])+(nquad0-1),-1,
740  &(outarray[0]),1);
741  }
742  break;
743  case 1:
744  if (edgedir == StdRegions::eForwards)
745  {
746  Vmath::Vcopy(nquad1,&(inarray[0])+(nquad0-1),nquad0,
747  &(outarray[0]),1);
748  }
749  else
750  {
751  Vmath::Vcopy(nquad1,&(inarray[0])+(nquad0*nquad1-1),
752  -nquad0, &(outarray[0]),1);
753  }
754  break;
755  case 2:
756  if (edgedir == StdRegions::eForwards)
757  {
758  Vmath::Vcopy(nquad0,&(inarray[0])+(nquad0*nquad1-1),-1,
759  &(outarray[0]),1);
760  }
761  else
762  {
763  Vmath::Vcopy(nquad0,&(inarray[0])+nquad0*(nquad1-1),1,
764  &(outarray[0]),1);
765  }
766  break;
767  case 3:
768  if (edgedir == StdRegions::eForwards)
769  {
770  Vmath::Vcopy(nquad1,&(inarray[0]) + nquad0*(nquad1-1),
771  -nquad0,&(outarray[0]),1);
772  }
773  else
774  {
775  Vmath::Vcopy(nquad1,&(inarray[0]),nquad0,
776  &(outarray[0]),1);
777  }
778  break;
779  default:
780  ASSERTL0(false,"edge value (< 3) is out of range");
781  break;
782  }
783  }

References ASSERTL0, Nektar::StdRegions::eForwards, Nektar::LocalRegions::Expansion::GetTraceOrient(), Nektar::StdRegions::StdExpansion::m_base, and Vmath::Vcopy().

◆ v_GetLinStdExp()

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 654 of file QuadExp.cpp.

655  {
656  LibUtilities::BasisKey bkey0(m_base[0]->GetBasisType(),
657  2, m_base[0]->GetPointsKey());
658  LibUtilities::BasisKey bkey1(m_base[1]->GetBasisType(),
659  2, m_base[1]->GetPointsKey());
660 
661  return MemoryManager<StdRegions::StdQuadExp>
662  ::AllocateSharedPtr( bkey0, bkey1);
663  }

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

◆ v_GetLocMatrix()

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

Reimplemented from Nektar::LocalRegions::Expansion.

Definition at line 2126 of file QuadExp.cpp.

2127  {
2128  return m_matrixManager[mkey];
2129  }

References m_matrixManager.

◆ v_GetLocStaticCondMatrix()

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 2132 of file QuadExp.cpp.

2134  {
2135  return m_staticCondMatrixManager[mkey];
2136  }

References m_staticCondMatrixManager.

◆ v_GetMetricInfo()

const SpatialDomains::GeomFactorsSharedPtr & Nektar::LocalRegions::QuadExp::v_GetMetricInfo ( ) const
protectedvirtual

Definition at line 1521 of file QuadExp.cpp.

1522  {
1523  return m_metricinfo;
1524  }

References Nektar::LocalRegions::Expansion::m_metricinfo.

◆ v_GetNumPoints()

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

Definition at line 1645 of file QuadExp.cpp.

1646  {
1647  return GetNumPoints(dir);
1648  }

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

◆ v_GetStdExp()

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 646 of file QuadExp.cpp.

647  {
648  return MemoryManager<StdRegions::StdQuadExp>
649  ::AllocateSharedPtr(m_base[0]->GetBasisKey(),
650  m_base[1]->GetBasisKey());
651  }

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

◆ v_GetTraceOrient()

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

Reimplemented from Nektar::LocalRegions::Expansion.

Definition at line 1632 of file QuadExp.cpp.

1633  {
1634  return m_geom->GetEorient(edge);
1635  }

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

◆ v_GetTracePhysMap()

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

Reimplemented from Nektar::LocalRegions::Expansion.

Definition at line 920 of file QuadExp.cpp.

923  {
924  int nquad0 = m_base[0]->GetNumPoints();
925  int nquad1 = m_base[1]->GetNumPoints();
926 
927  // Get points in Cartesian orientation
928  switch (edge)
929  {
930  case 0:
931  outarray = Array<OneD, int>(nquad0);
932  for (int i = 0; i < nquad0; ++i)
933  {
934  outarray[i] = i;
935  }
936  break;
937  case 1:
938  outarray = Array<OneD, int>(nquad1);
939  for (int i = 0; i < nquad1; ++i)
940  {
941  outarray[i] = (nquad0-1) + i*nquad0;
942  }
943  break;
944  case 2:
945  outarray = Array<OneD, int>(nquad0);
946  for (int i = 0; i < nquad0; ++i)
947  {
948  outarray[i] = i + nquad0*(nquad1-1);
949  }
950  break;
951  case 3:
952  outarray = Array<OneD, int>(nquad1);
953  for (int i = 0; i < nquad1; ++i)
954  {
955  outarray[i] = i*nquad0;
956  }
957  break;
958  default:
959  ASSERTL0(false, "edge value (< 3) is out of range");
960  break;
961  }
962 
963  }

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

◆ v_GetTracePhysVals()

void Nektar::LocalRegions::QuadExp::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 786 of file QuadExp.cpp.

792  {
793  int nquad0 = m_base[0]->GetNumPoints();
794  int nquad1 = m_base[1]->GetNumPoints();
795 
796  // Implementation for all the basis except Gauss points
797  if (m_base[0]->GetPointsType() !=
798  LibUtilities::eGaussGaussLegendre &&
799  m_base[1]->GetPointsType() !=
800  LibUtilities::eGaussGaussLegendre)
801  {
802  switch (edge)
803  {
804  case 0:
805  Vmath::Vcopy(nquad0,&(inarray[0]),1,&(outarray[0]),1);
806  break;
807  case 1:
808  Vmath::Vcopy(nquad1,&(inarray[0])+(nquad0-1),
809  nquad0,&(outarray[0]),1);
810  break;
811  case 2:
812  Vmath::Vcopy(nquad0,&(inarray[0])+nquad0*(nquad1-1),1,
813  &(outarray[0]),1);
814  break;
815  case 3:
816  Vmath::Vcopy(nquad1,&(inarray[0]),nquad0,
817  &(outarray[0]),1);
818  break;
819  default:
820  ASSERTL0(false,"edge value (< 3) is out of range");
821  break;
822  }
823  }
824  else
825  {
826  QuadExp::v_GetEdgeInterpVals(edge, inarray, outarray);
827  }
828 
829  // Interpolate if required
830  if (m_base[edge%2]->GetPointsKey() !=
831  EdgeExp->GetBasis(0)->GetPointsKey())
832  {
833  Array<OneD,NekDouble> outtmp(max(nquad0,nquad1));
834 
835  outtmp = outarray;
836 
837  LibUtilities::Interp1D(
838  m_base[edge%2]->GetPointsKey(), outtmp,
839  EdgeExp->GetBasis(0)->GetPointsKey(), outarray);
840  }
841 
842  if (orient == StdRegions::eNoOrientation)
843  {
844  orient = GetTraceOrient(edge);
845  }
846  //Reverse data if necessary
847  if(orient == StdRegions::eBackwards)
848  {
849  Vmath::Reverse(EdgeExp->GetNumPoints(0),&outarray[0], 1,
850  &outarray[0], 1);
851  }
852  }

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

◆ v_GetTraceQFactors()

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

Reimplemented from Nektar::LocalRegions::Expansion.

Definition at line 968 of file QuadExp.cpp.

971  {
972  int i;
973  int nquad0 = m_base[0]->GetNumPoints();
974  int nquad1 = m_base[1]->GetNumPoints();
975 
976  LibUtilities::PointsKeyVector ptsKeys = GetPointsKeys();
977  const Array<OneD, const NekDouble>& jac = m_metricinfo->GetJac(ptsKeys);
978  const Array<TwoD, const NekDouble>& df = m_metricinfo->GetDerivFactors(ptsKeys);
979 
980  Array<OneD, NekDouble> j (max(nquad0, nquad1), 0.0);
981  Array<OneD, NekDouble> g0(max(nquad0, nquad1), 0.0);
982  Array<OneD, NekDouble> g1(max(nquad0, nquad1), 0.0);
983  Array<OneD, NekDouble> g2(max(nquad0, nquad1), 0.0);
984  Array<OneD, NekDouble> g3(max(nquad0, nquad1), 0.0);
985 
986  if (m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
987  {
988  // Implementation for all the basis except Gauss points
989  if (m_base[0]->GetPointsType()
990  != LibUtilities::eGaussGaussLegendre
991  && m_base[1]->GetPointsType() !=
992  LibUtilities::eGaussGaussLegendre)
993  {
994  switch (edge)
995  {
996  case 0:
997  Vmath::Vcopy(nquad0, &(df[1][0]),
998  1, &(g1[0]), 1);
999  Vmath::Vcopy(nquad0, &(df[3][0]),
1000  1, &(g3[0]), 1);
1001  Vmath::Vcopy(nquad0, &(jac[0]),1, &(j[0]), 1);
1002 
1003  for (i = 0; i < nquad0; ++i)
1004  {
1005  outarray[i] = j[i]*sqrt(g1[i]*g1[i]
1006  + g3[i]*g3[i]);
1007  }
1008  break;
1009  case 1:
1010  Vmath::Vcopy(nquad1,
1011  &(df[0][0])+(nquad0-1), nquad0,
1012  &(g0[0]), 1);
1013 
1014  Vmath::Vcopy(nquad1,
1015  &(df[2][0])+(nquad0-1), nquad0,
1016  &(g2[0]), 1);
1017 
1018  Vmath::Vcopy(nquad1,
1019  &(jac[0])+(nquad0-1), nquad0,
1020  &(j[0]), 1);
1021 
1022  for (i = 0; i < nquad1; ++i)
1023  {
1024  outarray[i] = j[i]*sqrt(g0[i]*g0[i] +
1025  g2[i]*g2[i]);
1026  }
1027  break;
1028  case 2:
1029 
1030  Vmath::Vcopy(nquad0,
1031  &(df[1][0])+(nquad0*(nquad1-1)), 1,
1032  &(g1[0]), 1);
1033 
1034  Vmath::Vcopy(nquad0,
1035  &(df[3][0])+(nquad0*(nquad1-1)), 1,
1036  &(g3[0]), 1);
1037 
1038  Vmath::Vcopy(nquad0,
1039  &(jac[0])+(nquad0*(nquad1-1)), 1,
1040  &(j[0]), 1);
1041 
1042  for (i = 0; i < nquad0; ++i)
1043  {
1044  outarray[i] =
1045  j[i]*sqrt(g1[i]*g1[i]+ g3[i]*g3[i]);
1046  }
1047  break;
1048  case 3:
1049 
1050  Vmath::Vcopy(nquad1, &(df[0][0]), nquad0,&(g0[0]), 1);
1051  Vmath::Vcopy(nquad1, &(df[2][0]), nquad0,&(g2[0]), 1);
1052  Vmath::Vcopy(nquad1, &(jac[0]), nquad0, &(j[0]), 1);
1053 
1054  for (i = 0; i < nquad1; ++i)
1055  {
1056  outarray[i] = j[i]*sqrt(g0[i]*g0[i] +
1057  g2[i]*g2[i]);
1058  }
1059  break;
1060  default:
1061  ASSERTL0(false,"edge value (< 3) is out of range");
1062  break;
1063  }
1064  }
1065  else
1066  {
1067  int nqtot = nquad0 * nquad1;
1068  Array<OneD, NekDouble> tmp_gmat0(nqtot, 0.0);
1069  Array<OneD, NekDouble> tmp_gmat1(nqtot, 0.0);
1070  Array<OneD, NekDouble> tmp_gmat2(nqtot, 0.0);
1071  Array<OneD, NekDouble> tmp_gmat3(nqtot, 0.0);
1072  Array<OneD, NekDouble> g0_edge(max(nquad0, nquad1), 0.0);
1073  Array<OneD, NekDouble> g1_edge(max(nquad0, nquad1), 0.0);
1074  Array<OneD, NekDouble> g2_edge(max(nquad0, nquad1), 0.0);
1075  Array<OneD, NekDouble> g3_edge(max(nquad0, nquad1), 0.0);
1076  Array<OneD, NekDouble> jac_edge(max(nquad0, nquad1), 0.0);
1077 
1078  switch (edge)
1079  {
1080  case 0:
1081  Vmath::Vmul(nqtot,&(df[1][0]),1,&jac[0],1,
1082  &(tmp_gmat1[0]),1);
1083  Vmath::Vmul(nqtot,&(df[3][0]),1,&jac[0],1,
1084  &(tmp_gmat3[0]),1);
1085  QuadExp::v_GetEdgeInterpVals(
1086  edge, tmp_gmat1, g1_edge);
1087  QuadExp::v_GetEdgeInterpVals(
1088  edge, tmp_gmat3, g3_edge);
1089 
1090  for (i = 0; i < nquad0; ++i)
1091  {
1092  outarray[i] = sqrt(g1_edge[i]*g1_edge[i] +
1093  g3_edge[i]*g3_edge[i]);
1094  }
1095  break;
1096 
1097  case 1:
1098  Vmath::Vmul(nqtot,
1099  &(df[0][0]), 1,
1100  &jac[0], 1,
1101  &(tmp_gmat0[0]), 1);
1102  Vmath::Vmul(nqtot,
1103  &(df[2][0]), 1,
1104  &jac[0], 1,
1105  &(tmp_gmat2[0]),
1106  1);
1107  QuadExp::v_GetEdgeInterpVals(
1108  edge, tmp_gmat0, g0_edge);
1109  QuadExp::v_GetEdgeInterpVals(
1110  edge, tmp_gmat2, g2_edge);
1111 
1112  for (i = 0; i < nquad1; ++i)
1113  {
1114  outarray[i] = sqrt(g0_edge[i]*g0_edge[i]
1115  + g2_edge[i]*g2_edge[i]);
1116  }
1117 
1118  break;
1119  case 2:
1120 
1121  Vmath::Vmul(nqtot,
1122  &(df[1][0]), 1,
1123  &jac[0], 1,
1124  &(tmp_gmat1[0]), 1);
1125  Vmath::Vmul(nqtot,
1126  &(df[3][0]), 1,
1127  &jac[0], 1,
1128  &(tmp_gmat3[0]),1);
1129  QuadExp::v_GetEdgeInterpVals(
1130  edge, tmp_gmat1, g1_edge);
1131  QuadExp::v_GetEdgeInterpVals(
1132  edge, tmp_gmat3, g3_edge);
1133 
1134 
1135  for (i = 0; i < nquad0; ++i)
1136  {
1137  outarray[i] = sqrt(g1_edge[i]*g1_edge[i]
1138  + g3_edge[i]*g3_edge[i]);
1139  }
1140 
1141  Vmath::Reverse(nquad0,&outarray[0],1,&outarray[0],1);
1142 
1143  break;
1144  case 3:
1145  Vmath::Vmul(nqtot,
1146  &(df[0][0]), 1,
1147  &jac[0], 1,
1148  &(tmp_gmat0[0]), 1);
1149  Vmath::Vmul(nqtot,
1150  &(df[2][0]),1,
1151  &jac[0], 1,
1152  &(tmp_gmat2[0]),1);
1153  QuadExp::v_GetEdgeInterpVals(
1154  edge, tmp_gmat0, g0_edge);
1155  QuadExp::v_GetEdgeInterpVals(
1156  edge, tmp_gmat2, g2_edge);
1157 
1158 
1159  for (i = 0; i < nquad1; ++i)
1160  {
1161  outarray[i] = sqrt(g0_edge[i]*g0_edge[i] +
1162  g2_edge[i]*g2_edge[i]);
1163  }
1164 
1165  Vmath::Reverse(nquad1,
1166  &outarray[0], 1,
1167  &outarray[0], 1);
1168 
1169  break;
1170  default:
1171  ASSERTL0(false,"edge value (< 3) is out of range");
1172  break;
1173  }
1174  }
1175  }
1176  else
1177  {
1178 
1179  switch (edge)
1180  {
1181  case 0:
1182 
1183 
1184 
1185  for (i = 0; i < nquad0; ++i)
1186  {
1187  outarray[i] = jac[0]*sqrt(df[1][0]*df[1][0] +
1188  df[3][0]*df[3][0]);
1189  }
1190  break;
1191  case 1:
1192  for (i = 0; i < nquad1; ++i)
1193  {
1194  outarray[i] = jac[0]*sqrt(df[0][0]*df[0][0] +
1195  df[2][0]*df[2][0]);
1196  }
1197  break;
1198  case 2:
1199  for (i = 0; i < nquad0; ++i)
1200  {
1201  outarray[i] = jac[0]*sqrt(df[1][0]*df[1][0] +
1202  df[3][0]*df[3][0]);
1203  }
1204  break;
1205  case 3:
1206  for (i = 0; i < nquad1; ++i)
1207  {
1208  outarray[i] = jac[0]*sqrt(df[0][0]*df[0][0] +
1209  df[2][0]*df[2][0]);
1210  }
1211  break;
1212  default:
1213  ASSERTL0(false,"edge value (< 3) is out of range");
1214  break;
1215  }
1216  }
1217  }

References ASSERTL0, Nektar::SpatialDomains::eDeformed, Nektar::LibUtilities::eGaussGaussLegendre, Nektar::StdRegions::StdExpansion::GetPointsKeys(), Nektar::StdRegions::StdExpansion::GetPointsType(), Nektar::StdRegions::StdExpansion::m_base, Nektar::LocalRegions::Expansion::m_metricinfo, Vmath::Reverse(), tinysimd::sqrt(), v_GetEdgeInterpVals(), Vmath::Vcopy(), and Vmath::Vmul().

◆ v_HelmholtzMatrixOp()

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

Reimplemented from Nektar::StdRegions::StdQuadExp.

Definition at line 2204 of file QuadExp.cpp.

2208  {
2209  QuadExp::HelmholtzMatrixOp_MatFree(inarray, outarray, mkey);
2210  }
Nektar::StdRegions::StdExpansion::HelmholtzMatrixOp_MatFree
void HelmholtzMatrixOp_MatFree(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
Definition: StdExpansion.h:1288

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

◆ v_Integral()

NekDouble Nektar::LocalRegions::QuadExp::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::StdQuadExp.

Definition at line 86 of file QuadExp.cpp.

89  {
90  int nquad0 = m_base[0]->GetNumPoints();
91  int nquad1 = m_base[1]->GetNumPoints();
92  Array<OneD, const NekDouble> jac = m_metricinfo->GetJac(GetPointsKeys());
93  NekDouble ival;
94  Array<OneD,NekDouble> tmp(nquad0*nquad1);
95 
96  // multiply inarray with Jacobian
97  if (m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
98  {
99  Vmath::Vmul(nquad0*nquad1, jac, 1, inarray, 1, tmp, 1);
100  }
101  else
102  {
103  Vmath::Smul(nquad0*nquad1, jac[0], inarray, 1, tmp, 1);
104  }
105 
106  // call StdQuadExp version;
107  ival = StdQuadExp::v_Integral(tmp);
108  return ival;
109  }

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::QuadExp::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*base1 and put into outarray.

\( \begin{array}{rcl} I_{pq} = (\phi_p \phi_q, u) & = & \sum_{i=0}^{nq_0} \sum_{j=0}^{nq_1} \phi_p(\xi_{0,i}) \phi_q(\xi_{1,j}) w^0_i w^1_j u(\xi_{0,i} \xi_{1,j}) \\ & = & \sum_{i=0}^{nq_0} \phi_p(\xi_{0,i}) \sum_{j=0}^{nq_1} \phi_q(\xi_{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_{qi} = \sum_{j=0}^{nq_1} \phi_q(\xi_{1,j}) \tilde{u}_{i,j} = {\bf B_1 U} \) \( I_{pq} = \sum_{i=0}^{nq_0} \phi_p(\xi_{0,i}) f_{qi} = {\bf B_0 F} \)

Reimplemented from Nektar::StdRegions::StdQuadExp.

Definition at line 416 of file QuadExp.cpp.

419  {
420  if (m_base[0]->Collocation() && m_base[1]->Collocation())
421  {
422  MultiplyByQuadratureMetric(inarray,outarray);
423  }
424  else
425  {
426  IProductWRTBase_SumFac(inarray,outarray);
427  }
428  }
Nektar::StdRegions::StdExpansion::IProductWRTBase_SumFac
void IProductWRTBase_SumFac(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, bool multiplybyweights=true)
Definition: StdExpansion.h:1147

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

◆ v_IProductWRTBase_MatOp()

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

Reimplemented from Nektar::StdRegions::StdQuadExp.

Definition at line 470 of file QuadExp.cpp.

473  {
474  int nq = GetTotPoints();
475  MatrixKey
476  iprodmatkey(StdRegions::eIProductWRTBase,DetShapeType(),*this);
477  DNekScalMatSharedPtr iprodmat = m_matrixManager[iprodmatkey];
478 
479  Blas::Dgemv('N',m_ncoeffs,nq,iprodmat->Scale(),
480  (iprodmat->GetOwnedMatrix())->GetPtr().get(),
481  m_ncoeffs, inarray.get(), 1, 0.0, outarray.get(), 1);
482 
483  }

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::QuadExp::v_IProductWRTBase_SumFac ( const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray,
bool  multiplybyweights = true 
)
protectedvirtual

Reimplemented from Nektar::StdRegions::StdQuadExp.

Definition at line 440 of file QuadExp.cpp.

444  {
445  int nquad0 = m_base[0]->GetNumPoints();
446  int nquad1 = m_base[1]->GetNumPoints();
447  int order0 = m_base[0]->GetNumModes();
448 
449  if(multiplybyweights)
450  {
451  Array<OneD,NekDouble> tmp(nquad0*nquad1+nquad1*order0);
452  Array<OneD,NekDouble> wsp(tmp+nquad0*nquad1);
453 
454  MultiplyByQuadratureMetric(inarray,tmp);
455  StdQuadExp::IProductWRTBase_SumFacKernel(m_base[0]->GetBdata(),
456  m_base[1]->GetBdata(),
457  tmp,outarray,wsp,true,true);
458  }
459  else
460  {
461  Array<OneD,NekDouble> wsp(nquad1*order0);
462 
463  StdQuadExp::IProductWRTBase_SumFacKernel(m_base[0]->GetBdata(),
464  m_base[1]->GetBdata(),
465  inarray,outarray,wsp,true,true);
466  }
467  }

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

◆ v_IProductWRTDerivBase()

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

Reimplemented from Nektar::StdRegions::StdQuadExp.

Definition at line 431 of file QuadExp.cpp.

435  {
436  IProductWRTDerivBase_SumFac(dir,inarray,outarray);
437  }
Nektar::StdRegions::StdExpansion::IProductWRTDerivBase_SumFac
void IProductWRTDerivBase_SumFac(const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
Definition: StdExpansion.h:1203

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

◆ v_IProductWRTDerivBase_MatOp()

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

Reimplemented from Nektar::StdRegions::StdQuadExp.

Definition at line 569 of file QuadExp.cpp.

573  {
574  int nq = GetTotPoints();
575  StdRegions::MatrixType mtype = StdRegions::eIProductWRTDerivBase0;
576 
577  switch (dir)
578  {
579  case 0:
580  {
581  mtype = StdRegions::eIProductWRTDerivBase0;
582  }
583  break;
584  case 1:
585  {
586  mtype = StdRegions::eIProductWRTDerivBase1;
587  }
588  break;
589  case 2:
590  {
591  mtype = StdRegions::eIProductWRTDerivBase2;
592  }
593  break;
594  default:
595  {
596  ASSERTL1(false,"input dir is out of range");
597  }
598  break;
599  }
600 
601  MatrixKey iprodmatkey(mtype,DetShapeType(),*this);
602  DNekScalMatSharedPtr iprodmat = m_matrixManager[iprodmatkey];
603 
604  Blas::Dgemv('N', m_ncoeffs, nq, iprodmat->Scale(),
605  (iprodmat->GetOwnedMatrix())->GetPtr().get(),
606  m_ncoeffs, inarray.get(), 1, 0.0, outarray.get(), 1);
607  }

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::QuadExp::v_IProductWRTDerivBase_SumFac ( const int  dir,
const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray 
)
protectedvirtual

Reimplemented from Nektar::StdRegions::StdQuadExp.

Definition at line 486 of file QuadExp.cpp.

490  {
491  ASSERTL1((dir==0) || (dir==1) || (dir==2),
492  "Invalid direction.");
493  ASSERTL1((dir==2) ? (m_geom->GetCoordim() ==3):true,
494  "Invalid direction.");
495 
496  int nquad0 = m_base[0]->GetNumPoints();
497  int nquad1 = m_base[1]->GetNumPoints();
498  int nqtot = nquad0*nquad1;
499  int nmodes0 = m_base[0]->GetNumModes();
500 
501  Array<OneD, NekDouble> tmp1(2*nqtot+m_ncoeffs+nmodes0*nquad1);
502  Array<OneD, NekDouble> tmp2(tmp1 + nqtot);
503  Array<OneD, NekDouble> tmp3(tmp1 + 2*nqtot);
504  Array<OneD, NekDouble> tmp4(tmp1 + 2*nqtot+m_ncoeffs);
505 
506  Array<OneD, Array<OneD, NekDouble>> tmp2D{2};
507  tmp2D[0] = tmp1;
508  tmp2D[1] = tmp2;
509 
510  QuadExp::v_AlignVectorToCollapsedDir(dir, inarray, tmp2D);
511 
512  MultiplyByQuadratureMetric(tmp1,tmp1);
513  MultiplyByQuadratureMetric(tmp2,tmp2);
514 
515  IProductWRTBase_SumFacKernel(
516  m_base[0]->GetDbdata(), m_base[1]->GetBdata(),
517  tmp1, tmp3, tmp4, false, true);
518  IProductWRTBase_SumFacKernel(
519  m_base[0]->GetBdata() , m_base[1]->GetDbdata(),
520  tmp2, outarray, tmp4, true, false);
521  Vmath::Vadd(m_ncoeffs, tmp3, 1, outarray, 1, outarray, 1);
522  }
Nektar::LocalRegions::QuadExp::v_AlignVectorToCollapsedDir
virtual void v_AlignVectorToCollapsedDir(const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray)
Definition: QuadExp.cpp:524
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:210
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:322

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

◆ v_LaplacianMatrixOp() [1/2]

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

Reimplemented from Nektar::StdRegions::StdQuadExp.

Definition at line 2153 of file QuadExp.cpp.

2157  {
2158  QuadExp::LaplacianMatrixOp_MatFree(inarray, outarray, mkey);
2159  }
Nektar::StdRegions::StdExpansion::LaplacianMatrixOp_MatFree
void LaplacianMatrixOp_MatFree(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
Definition: StdExpansion.h:1241

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

◆ v_LaplacianMatrixOp() [2/2]

void Nektar::LocalRegions::QuadExp::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::StdQuadExp.

Definition at line 2162 of file QuadExp.cpp.

2168  {
2169  StdExpansion::LaplacianMatrixOp_MatFree(
2170  k1, k2, inarray, outarray, mkey);
2171  }

◆ v_LaplacianMatrixOp_MatFree_Kernel()

void Nektar::LocalRegions::QuadExp::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 2288 of file QuadExp.cpp.

2292  {
2293  if (m_metrics.count(eMetricLaplacian00) == 0)
2294  {
2295  ComputeLaplacianMetric();
2296  }
2297 
2298  int nquad0 = m_base[0]->GetNumPoints();
2299  int nquad1 = m_base[1]->GetNumPoints();
2300  int nqtot = nquad0*nquad1;
2301  int nmodes0 = m_base[0]->GetNumModes();
2302  int nmodes1 = m_base[1]->GetNumModes();
2303  int wspsize = max(max(max(nqtot,m_ncoeffs),nquad1*nmodes0),nquad0*nmodes1);
2304 
2305  ASSERTL1(wsp.size() >= 3*wspsize,
2306  "Workspace is of insufficient size.");
2307 
2308  const Array<OneD, const NekDouble>& base0 = m_base[0]->GetBdata();
2309  const Array<OneD, const NekDouble>& base1 = m_base[1]->GetBdata();
2310  const Array<OneD, const NekDouble>& dbase0 = m_base[0]->GetDbdata();
2311  const Array<OneD, const NekDouble>& dbase1 = m_base[1]->GetDbdata();
2312  const Array<OneD, const NekDouble>& metric00 = m_metrics[eMetricLaplacian00];
2313  const Array<OneD, const NekDouble>& metric01 = m_metrics[eMetricLaplacian01];
2314  const Array<OneD, const NekDouble>& metric11 = m_metrics[eMetricLaplacian11];
2315 
2316  // Allocate temporary storage
2317  Array<OneD,NekDouble> wsp0(wsp);
2318  Array<OneD,NekDouble> wsp1(wsp+wspsize);
2319  Array<OneD,NekDouble> wsp2(wsp+2*wspsize);
2320 
2321  StdExpansion2D::PhysTensorDeriv(inarray,wsp1,wsp2);
2322 
2323  // wsp0 = k = g0 * wsp1 + g1 * wsp2 = g0 * du_dxi1 + g1 * du_dxi2
2324  // wsp2 = l = g1 * wsp1 + g2 * wsp2 = g0 * du_dxi1 + g1 * du_dxi2
2325  // where g0, g1 and g2 are the metric terms set up in the GeomFactors class
2326  // especially for this purpose
2327  Vmath::Vvtvvtp(nqtot,&metric00[0],1,&wsp1[0],1,&metric01[0],1,&wsp2[0],1,&wsp0[0],1);
2328  Vmath::Vvtvvtp(nqtot,&metric01[0],1,&wsp1[0],1,&metric11[0],1,&wsp2[0],1,&wsp2[0],1);
2329 
2330  // outarray = m = (D_xi1 * B)^T * k
2331  // wsp1 = n = (D_xi2 * B)^T * l
2332  IProductWRTBase_SumFacKernel(dbase0,base1,wsp0,outarray,wsp1,false,true);
2333  IProductWRTBase_SumFacKernel(base0,dbase1,wsp2,wsp1, wsp0,true,false);
2334 
2335  // outarray = outarray + wsp1
2336  // = L * u_hat
2337  Vmath::Vadd(m_ncoeffs,wsp1.get(),1,outarray.get(),1,outarray.get(),1);
2338  }
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:625

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::QuadExp::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 2194 of file QuadExp.cpp.

2198  {
2199  StdExpansion::MassLevelCurvatureMatrixOp_MatFree(
2200  inarray, outarray, mkey);
2201  }

◆ v_MassMatrixOp()

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

Reimplemented from Nektar::StdRegions::StdQuadExp.

Definition at line 2144 of file QuadExp.cpp.

2148  {
2149  StdExpansion::MassMatrixOp_MatFree(inarray, outarray, mkey);
2150  }

◆ v_NormVectorIProductWRTBase() [1/2]

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 639 of file QuadExp.cpp.

642  {
643  NormVectorIProductWRTBase(Fvec[0], Fvec[1], Fvec[2], outarray);
644  }
Nektar::StdRegions::StdExpansion::NormVectorIProductWRTBase
void NormVectorIProductWRTBase(const Array< OneD, const NekDouble > &Fx, Array< OneD, NekDouble > &outarray)
Definition: StdExpansion.h:628

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

◆ v_NormVectorIProductWRTBase() [2/2]

void Nektar::LocalRegions::QuadExp::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 610 of file QuadExp.cpp.

615  {
616  int nq = m_base[0]->GetNumPoints()*m_base[1]->GetNumPoints();
617  Array<OneD, NekDouble> Fn(nq);
618 
619  const Array<OneD, const Array<OneD, NekDouble> > &normals =
620  GetLeftAdjacentElementExp()->GetTraceNormal(
621  GetLeftAdjacentElementTrace());
622 
623  if (m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
624  {
625  Vmath::Vvtvvtp(nq,&normals[0][0],1,&Fx[0],1,
626  &normals[1][0],1,&Fy[0],1,&Fn[0],1);
627  Vmath::Vvtvp (nq,&normals[2][0],1,&Fz[0],1,&Fn[0],1,&Fn[0],1);
628  }
629  else
630  {
631  Vmath::Svtsvtp(nq,normals[0][0],&Fx[0],1,
632  normals[1][0],&Fy[0],1,&Fn[0],1);
633  Vmath::Svtvp (nq,normals[2][0],&Fz[0],1,&Fn[0],1,&Fn[0],1);
634  }
635 
636  IProductWRTBase(Fn,outarray);
637  }
Nektar::LocalRegions::Expansion::GetLeftAdjacentElementExp
ExpansionSharedPtr GetLeftAdjacentElementExp() const
Definition: Expansion.h:438
Nektar::LocalRegions::Expansion::GetLeftAdjacentElementTrace
int GetLeftAdjacentElementTrace() const
Definition: Expansion.h:454
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:691
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:565

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

For quadrilateral region can use the Tensor_Deriv function defined under StdExpansion.

Reimplemented from Nektar::StdRegions::StdQuadExp.

Definition at line 111 of file QuadExp.cpp.

116  {
117  int nquad0 = m_base[0]->GetNumPoints();
118  int nquad1 = m_base[1]->GetNumPoints();
119  int nqtot = nquad0*nquad1;
120  const Array<TwoD, const NekDouble>& df = m_metricinfo->GetDerivFactors(GetPointsKeys());
121  Array<OneD,NekDouble> diff0(2*nqtot);
122  Array<OneD,NekDouble> diff1(diff0+nqtot);
123 
124  StdQuadExp::v_PhysDeriv(inarray, diff0, diff1);
125 
126  if (m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
127  {
128  if (out_d0.size())
129  {
130  Vmath::Vmul (nqtot, df[0], 1, diff0, 1, out_d0, 1);
131  Vmath::Vvtvp (nqtot, df[1], 1, diff1, 1, out_d0, 1,
132  out_d0,1);
133  }
134 
135  if(out_d1.size())
136  {
137  Vmath::Vmul (nqtot,df[2],1,diff0,1, out_d1, 1);
138  Vmath::Vvtvp (nqtot,df[3],1,diff1,1, out_d1, 1, out_d1,1);
139  }
140 
141  if (out_d2.size())
142  {
143  Vmath::Vmul (nqtot,df[4],1,diff0,1, out_d2, 1);
144  Vmath::Vvtvp (nqtot,df[5],1,diff1,1, out_d2, 1, out_d2,1);
145  }
146  }
147  else // regular geometry
148  {
149  if (out_d0.size())
150  {
151  Vmath::Smul (nqtot, df[0][0], diff0, 1, out_d0, 1);
152  Blas::Daxpy (nqtot, df[1][0], diff1, 1, out_d0, 1);
153  }
154 
155  if (out_d1.size())
156  {
157  Vmath::Smul (nqtot, df[2][0], diff0, 1, out_d1, 1);
158  Blas::Daxpy (nqtot, df[3][0], diff1, 1, out_d1, 1);
159  }
160 
161  if (out_d2.size())
162  {
163  Vmath::Smul (nqtot, df[4][0], diff0, 1, out_d2, 1);
164  Blas::Daxpy (nqtot, df[5][0], diff1, 1, out_d2, 1);
165  }
166  }
167  }
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:167

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

Referenced by v_PhysDeriv().

◆ v_PhysDeriv() [2/2]

void Nektar::LocalRegions::QuadExp::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::StdQuadExp.

Definition at line 170 of file QuadExp.cpp.

174  {
175  switch (dir)
176  {
177  case 0:
178  {
179  v_PhysDeriv(inarray, outarray, NullNekDouble1DArray,
180  NullNekDouble1DArray);
181  }
182  break;
183  case 1:
184  {
185  v_PhysDeriv(inarray, NullNekDouble1DArray, outarray,
186  NullNekDouble1DArray);
187  }
188  break;
189  case 2:
190  {
191  v_PhysDeriv(inarray, NullNekDouble1DArray,
192  NullNekDouble1DArray, outarray);
193  }
194  break;
195  default:
196  {
197  ASSERTL1(false,"input dir is out of range");
198  }
199  break;
200  }
201  }
Nektar::LocalRegions::QuadExp::v_PhysDeriv
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.
Definition: QuadExp.cpp:111
Nektar::NullNekDouble1DArray
static Array< OneD, NekDouble > NullNekDouble1DArray
Definition: SharedArray.hpp:820

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

◆ v_PhysDirectionalDeriv()

void Nektar::LocalRegions::QuadExp::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/dx_v^s + d/dx_v^r

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 204 of file QuadExp.cpp.

208  {
209  int nquad0 = m_base[0]->GetNumPoints();
210  int nquad1 = m_base[1]->GetNumPoints();
211  int nqtot = nquad0*nquad1;
212 
213  const Array<TwoD, const NekDouble>& df = m_metricinfo->GetDerivFactors(GetPointsKeys());
214 
215  Array<OneD,NekDouble> diff0(2*nqtot);
216  Array<OneD,NekDouble> diff1(diff0+nqtot);
217 
218  StdQuadExp::v_PhysDeriv(inarray, diff0, diff1);
219 
220  if (m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
221  {
222  Array<OneD, Array<OneD, NekDouble> > tangmat(2);
223 
224  // d/dx_v^s = v_x*ds/dx + v_y*ds/dy + v_z*dx/dz
225  for (int i=0; i< 2; ++i)
226  {
227  tangmat[i] = Array<OneD, NekDouble>(nqtot,0.0);
228  for (int k=0; k<(m_geom->GetCoordim()); ++k)
229  {
230  Vmath::Vvtvp(nqtot,
231  &df[2*k+i][0], 1,
232  &direction[k*nqtot], 1,
233  &tangmat[i][0], 1,
234  &tangmat[i][0], 1);
235  }
236  }
237 
238  /// D_v = d/dx_v^s + d/dx_v^r
239  if (out.size())
240  {
241  Vmath::Vmul (nqtot,
242  &tangmat[0][0], 1,
243  &diff0[0], 1,
244  &out[0], 1);
245  Vmath::Vvtvp (nqtot,
246  &tangmat[1][0], 1,
247  &diff1[0], 1,
248  &out[0], 1,
249  &out[0], 1);
250  }
251 
252  }
253  else
254  {
255  ASSERTL1(m_metricinfo->GetGtype() ==
256  SpatialDomains::eDeformed,"Wrong route");
257  }
258  }

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

◆ v_PhysEvaluate()

NekDouble Nektar::LocalRegions::QuadExp::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 705 of file QuadExp.cpp.

708  {
709  Array<OneD,NekDouble> Lcoord = Array<OneD, NekDouble>(2);
710 
711  ASSERTL0(m_geom,"m_geom not defined");
712  m_geom->GetLocCoords(coord,Lcoord);
713 
714  return StdQuadExp::v_PhysEvaluate(Lcoord, physvals);
715  }

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

◆ v_ReduceOrderCoeffs()

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

Reimplemented from Nektar::StdRegions::StdQuadExp.

Definition at line 2238 of file QuadExp.cpp.

2242  {
2243  int n_coeffs = inarray.size();
2244 
2245  Array<OneD, NekDouble> coeff (n_coeffs);
2246  Array<OneD, NekDouble> coeff_tmp(n_coeffs, 0.0);
2247  Array<OneD, NekDouble> tmp, tmp2;
2248 
2249  int nmodes0 = m_base[0]->GetNumModes();
2250  int nmodes1 = m_base[1]->GetNumModes();
2251  int numMax = nmodes0;
2252 
2253  Vmath::Vcopy(n_coeffs,inarray,1,coeff_tmp,1);
2254 
2255  const LibUtilities::PointsKey Pkey0(
2256  nmodes0, LibUtilities::eGaussLobattoLegendre);
2257  const LibUtilities::PointsKey Pkey1(
2258  nmodes1, LibUtilities::eGaussLobattoLegendre);
2259  LibUtilities::BasisKey b0(
2260  m_base[0]->GetBasisType(), nmodes0, Pkey0);
2261  LibUtilities::BasisKey b1(
2262  m_base[1]->GetBasisType(), nmodes1, Pkey1);
2263  LibUtilities::BasisKey bortho0(
2264  LibUtilities::eOrtho_A, nmodes0, Pkey0);
2265  LibUtilities::BasisKey bortho1(
2266  LibUtilities::eOrtho_A, nmodes1, Pkey1);
2267 
2268  LibUtilities::InterpCoeff2D(
2269  b0, b1, coeff_tmp, bortho0, bortho1, coeff);
2270 
2271  Vmath::Zero(n_coeffs, coeff_tmp, 1);
2272 
2273  int cnt = 0;
2274  for (int i = 0; i < numMin+1; ++i)
2275  {
2276  Vmath::Vcopy(numMin,
2277  tmp = coeff+cnt,1,
2278  tmp2 = coeff_tmp+cnt,1);
2279 
2280  cnt = i*numMax;
2281  }
2282 
2283  LibUtilities::InterpCoeff2D(
2284  bortho0, bortho1, coeff_tmp,
2285  b0, b1, outarray);
2286  }
Nektar::LibUtilities::InterpCoeff2D
void InterpCoeff2D(const BasisKey &fbasis0, const BasisKey &fbasis1, const Array< OneD, const NekDouble > &from, const BasisKey &tbasis0, const BasisKey &tbasis1, Array< OneD, NekDouble > &to)
Definition: InterpCoeff.cpp:72
Nektar::LibUtilities::eOrtho_A
@ eOrtho_A
Principle Orthogonal Functions .
Definition: BasisType.h:45

References Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eOrtho_A, Nektar::StdRegions::StdExpansion::GetBasisType(), Nektar::LibUtilities::InterpCoeff2D(), Nektar::StdRegions::StdExpansion::m_base, Vmath::Vcopy(), and Vmath::Zero().

◆ v_StdPhysEvaluate()

NekDouble Nektar::LocalRegions::QuadExp::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 697 of file QuadExp.cpp.

700  {
701  // Evaluate point in local (eta) coordinates.
702  return StdQuadExp::v_PhysEvaluate(Lcoord,physvals);
703  }

◆ v_SVVLaplacianFilter()

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

Reimplemented from Nektar::StdRegions::StdQuadExp.

Definition at line 2379 of file QuadExp.cpp.

2382  {
2383  int nq = GetTotPoints();
2384 
2385  // Calculate sqrt of the Jacobian
2386  Array<OneD, const NekDouble> jac =
2387  m_metricinfo->GetJac(GetPointsKeys());
2388  Array<OneD, NekDouble> sqrt_jac(nq);
2389  if (m_metricinfo->GetGtype() == SpatialDomains::eDeformed)
2390  {
2391  Vmath::Vsqrt(nq,jac,1,sqrt_jac,1);
2392  }
2393  else
2394  {
2395  Vmath::Fill(nq,sqrt(jac[0]),sqrt_jac,1);
2396  }
2397 
2398  // Multiply array by sqrt(Jac)
2399  Vmath::Vmul(nq,sqrt_jac,1,array,1,array,1);
2400 
2401  // Apply std region filter
2402  StdQuadExp::v_SVVLaplacianFilter( array, mkey);
2403 
2404  // Divide by sqrt(Jac)
2405  Vmath::Vdiv(nq,array,1,sqrt_jac,1,array,1);
2406  }
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:257

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::QuadExp::v_WeakDerivMatrixOp ( const int  i,
const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  outarray,
const StdRegions::StdMatrixKey &  mkey 
)
protectedvirtual

Reimplemented from Nektar::StdRegions::StdQuadExp.

Definition at line 2174 of file QuadExp.cpp.

2179  {
2180  StdExpansion::WeakDerivMatrixOp_MatFree(i, inarray, outarray, mkey);
2181  }

◆ v_WeakDirectionalDerivMatrixOp()

void Nektar::LocalRegions::QuadExp::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 2184 of file QuadExp.cpp.

2188  {
2189  StdExpansion::WeakDirectionalDerivMatrixOp_MatFree(
2190  inarray, outarray, mkey);
2191  }

Member Data Documentation

◆ m_matrixManager

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

Definition at line 286 of file QuadExp.h.

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

◆ m_staticCondMatrixManager

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

Definition at line 287 of file QuadExp.h.

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

Generated on Wed Nov 24 2021 10:33:35 for Nektar++ by doxygen 1.9.1