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

#include <StdQuadExp.h>

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

Public Member Functions

 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...
 
virtual ~StdQuadExp () override
 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 () override
 
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)
 
NekDouble BaryTensorDeriv (const Array< OneD, NekDouble > &coord, const Array< OneD, const NekDouble > &inarray, std::array< NekDouble, 3 > &firstOrderDerivs)
 
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 () const
 
std::shared_ptr< StdExpansion > GetLinStdExp (void) const
 
int GetShapeDimension () const
 
bool IsBoundaryInteriorExpansion () const
 
bool IsNodalNonTensorialExp ()
 
void BwdTrans (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 This function performs the Backward transformation from coefficient space to physical space. More...
 
void FwdTrans (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 This function performs the Forward transformation from physical space to coefficient space. More...
 
void FwdTransBndConstrained (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
NekDouble Integral (const Array< OneD, const NekDouble > &inarray)
 This function integrates the specified function over the domain. More...
 
void FillMode (const int mode, Array< OneD, NekDouble > &outarray)
 This function fills the array outarray with the mode-th mode of the expansion. More...
 
void IProductWRTBase (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 this function calculates the inner product of a given function f with the different modes of the expansion More...
 
void IProductWRTBase (const Array< OneD, const NekDouble > &base, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, int coll_check)
 
void IProductWRTDerivBase (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
void IProductWRTDirectionalDerivBase (const Array< OneD, const NekDouble > &direction, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
int GetElmtId ()
 Get the element id of this expansion when used in a list by returning value of m_elmt_id. More...
 
void SetElmtId (const int id)
 Set the element id of this expansion when used in a list by returning value of m_elmt_id. More...
 
void GetCoords (Array< OneD, NekDouble > &coords_1, Array< OneD, NekDouble > &coords_2=NullNekDouble1DArray, Array< OneD, NekDouble > &coords_3=NullNekDouble1DArray)
 this function returns the physical coordinates of the quadrature points of the expansion More...
 
void GetCoord (const Array< OneD, const NekDouble > &Lcoord, Array< OneD, NekDouble > &coord)
 given the coordinates of a point of the element in the local collapsed coordinate system, this function calculates the physical coordinates of the point More...
 
DNekMatSharedPtr GetStdMatrix (const StdMatrixKey &mkey)
 
DNekBlkMatSharedPtr GetStdStaticCondMatrix (const StdMatrixKey &mkey)
 
void NormVectorIProductWRTBase (const Array< OneD, const NekDouble > &Fx, Array< OneD, NekDouble > &outarray)
 
void NormVectorIProductWRTBase (const Array< OneD, const NekDouble > &Fx, const Array< OneD, NekDouble > &Fy, Array< OneD, NekDouble > &outarray)
 
void NormVectorIProductWRTBase (const Array< OneD, const NekDouble > &Fx, const Array< OneD, const NekDouble > &Fy, const Array< OneD, const NekDouble > &Fz, Array< OneD, NekDouble > &outarray)
 
void NormVectorIProductWRTBase (const Array< OneD, const Array< OneD, NekDouble >> &Fvec, Array< OneD, NekDouble > &outarray)
 
DNekScalBlkMatSharedPtr GetLocStaticCondMatrix (const LocalRegions::MatrixKey &mkey)
 
void DropLocStaticCondMatrix (const LocalRegions::MatrixKey &mkey)
 
int CalcNumberOfCoefficients (const std::vector< unsigned int > &nummodes, int &modes_offset)
 
NekDouble StdPhysEvaluate (const Array< OneD, const NekDouble > &Lcoord, const Array< OneD, const NekDouble > &physvals)
 
int GetCoordim ()
 
void GetBoundaryMap (Array< OneD, unsigned int > &outarray)
 
void GetInteriorMap (Array< OneD, unsigned int > &outarray)
 
int GetVertexMap (const int localVertexId, bool useCoeffPacking=false)
 
void GetTraceToElementMap (const int tid, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray, Orientation traceOrient=eForwards, int P=-1, int Q=-1)
 
void GetTraceCoeffMap (const unsigned int traceid, Array< OneD, unsigned int > &maparray)
 
void GetElmtTraceToTraceMap (const unsigned int tid, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray, Orientation traceOrient=eForwards, int P=-1, int Q=-1)
 
void GetTraceInteriorToElementMap (const int tid, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray, const Orientation traceOrient=eForwards)
 
void GetTraceNumModes (const int tid, int &numModes0, int &numModes1, const Orientation traceOrient=eDir1FwdDir1_Dir2FwdDir2)
 
void MultiplyByQuadratureMetric (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
void MultiplyByStdQuadratureMetric (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
DNekMatSharedPtr CreateGeneralMatrix (const StdMatrixKey &mkey)
 this function generates the mass matrix \(\mathbf{M}[i][j] = \int \phi_i(\mathbf{x}) \phi_j(\mathbf{x}) d\mathbf{x}\) More...
 
void GeneralMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void MassMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void LaplacianMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void ReduceOrderCoeffs (int numMin, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
void SVVLaplacianFilter (Array< OneD, NekDouble > &array, const StdMatrixKey &mkey)
 
void ExponentialFilter (Array< OneD, NekDouble > &array, const NekDouble alpha, const NekDouble exponent, const NekDouble cutoff)
 
void LaplacianMatrixOp (const int k1, const int k2, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void WeakDerivMatrixOp (const int i, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void WeakDirectionalDerivMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void MassLevelCurvatureMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void LinearAdvectionDiffusionReactionMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey, bool addDiffusionTerm=true)
 
void HelmholtzMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
DNekMatSharedPtr GenMatrix (const StdMatrixKey &mkey)
 
void PhysDeriv (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_d0, Array< OneD, NekDouble > &out_d1=NullNekDouble1DArray, Array< OneD, NekDouble > &out_d2=NullNekDouble1DArray)
 
void PhysDeriv (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
void PhysDeriv_s (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_ds)
 
void PhysDeriv_n (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_dn)
 
void PhysDirectionalDeriv (const Array< OneD, const NekDouble > &inarray, const Array< OneD, const NekDouble > &direction, Array< OneD, NekDouble > &outarray)
 
void StdPhysDeriv (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_d0, Array< OneD, NekDouble > &out_d1=NullNekDouble1DArray, Array< OneD, NekDouble > &out_d2=NullNekDouble1DArray)
 
void StdPhysDeriv (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
NekDouble PhysEvaluate (const Array< OneD, const NekDouble > &coords, const Array< OneD, const NekDouble > &physvals)
 This function evaluates the expansion at a single (arbitrary) point of the domain. More...
 
NekDouble PhysEvaluate (const Array< OneD, NekDouble > &coord, const Array< OneD, const NekDouble > &inarray, std::array< NekDouble, 3 > &firstOrderDerivs)
 This function evaluates the first derivative of the expansion at a single (arbitrary) point of the domain. More...
 
NekDouble PhysEvaluate (const Array< OneD, NekDouble > &coord, const Array< OneD, const NekDouble > &inarray, std::array< NekDouble, 3 > &firstOrderDerivs, std::array< NekDouble, 6 > &secondOrderDerivs)
 
NekDouble PhysEvaluate (const Array< OneD, DNekMatSharedPtr > &I, const Array< OneD, const NekDouble > &physvals)
 This function evaluates the expansion at a single (arbitrary) point of the domain. More...
 
NekDouble PhysEvaluateBasis (const Array< OneD, const NekDouble > &coords, int mode)
 This function evaluates the basis function mode mode at a point coords of the domain. More...
 
void LocCoordToLocCollapsed (const Array< OneD, const NekDouble > &xi, Array< OneD, NekDouble > &eta)
 Convert local cartesian coordinate xi into local collapsed coordinates eta. More...
 
void LocCollapsedToLocCoord (const Array< OneD, const NekDouble > &eta, Array< OneD, NekDouble > &xi)
 Convert local collapsed coordinates eta into local cartesian coordinate xi. More...
 
virtual void v_NormVectorIProductWRTBase (const Array< OneD, const NekDouble > &Fx, Array< OneD, NekDouble > &outarray)
 
virtual void v_NormVectorIProductWRTBase (const Array< OneD, const NekDouble > &Fx, const Array< OneD, const NekDouble > &Fy, Array< OneD, NekDouble > &outarray)
 
virtual void v_NormVectorIProductWRTBase (const Array< OneD, const NekDouble > &Fx, const Array< OneD, const NekDouble > &Fy, const Array< OneD, const NekDouble > &Fz, Array< OneD, NekDouble > &outarray)
 
virtual void v_NormVectorIProductWRTBase (const Array< OneD, const Array< OneD, NekDouble >> &Fvec, Array< OneD, NekDouble > &outarray)
 
virtual DNekScalBlkMatSharedPtr v_GetLocStaticCondMatrix (const LocalRegions::MatrixKey &mkey)
 
virtual void v_DropLocStaticCondMatrix (const LocalRegions::MatrixKey &mkey)
 
NekDouble Linf (const Array< OneD, const NekDouble > &phys, const Array< OneD, const NekDouble > &sol=NullNekDouble1DArray)
 Function to evaluate the discrete \( L_\infty\) error \( |\epsilon|_\infty = \max |u - u_{exact}|\) where \( u_{exact}\) is given by the array sol. More...
 
NekDouble L2 (const Array< OneD, const NekDouble > &phys, const Array< OneD, const NekDouble > &sol=NullNekDouble1DArray)
 Function to evaluate the discrete \( L_2\) error, \( | \epsilon |_{2} = \left [ \int^1_{-1} [u - u_{exact}]^2 dx \right]^{1/2} d\xi_1 \) where \( u_{exact}\) is given by the array sol. More...
 
NekDouble H1 (const Array< OneD, const NekDouble > &phys, const Array< OneD, const NekDouble > &sol=NullNekDouble1DArray)
 Function to evaluate the discrete \( H^1\) error, \( | \epsilon |^1_{2} = \left [ \int^1_{-1} [u - u_{exact}]^2 + \nabla(u - u_{exact})\cdot\nabla(u - u_{exact})\cdot dx \right]^{1/2} d\xi_1 \) where \( u_{exact}\) is given by the array sol. More...
 
const LibUtilities::PointsKeyVector GetPointsKeys () const
 
DNekMatSharedPtr BuildInverseTransformationMatrix (const DNekScalMatSharedPtr &m_transformationmatrix)
 
void PhysInterpToSimplexEquiSpaced (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, int npset=-1)
 This function performs an interpolation from the physical space points provided at input into an array of equispaced points which are not the collapsed coordinate. So for a tetrahedron you will only get a tetrahedral number of values. More...
 
void GetSimplexEquiSpacedConnectivity (Array< OneD, int > &conn, bool standard=true)
 This function provides the connectivity of local simplices (triangles or tets) to connect the equispaced data points provided by PhysInterpToSimplexEquiSpaced. More...
 
void EquiSpacedToCoeffs (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 This function performs a projection/interpolation from the equispaced points sometimes used in post-processing onto the coefficient space. More...
 
template<class T >
std::shared_ptr< T > as ()
 
void IProductWRTBase_SumFac (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, bool multiplybyweights=true)
 
void GenStdMatBwdDeriv (const int dir, DNekMatSharedPtr &mat)
 

Protected Member Functions

NekDouble v_Integral (const Array< OneD, const NekDouble > &inarray) override
 Integrates the specified function over the domain. More...
 
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) override
 Calculate the derivative of the physical points. More...
 
virtual void v_PhysDeriv (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) override
 Calculate the derivative of the physical points in a given direction. More...
 
virtual void v_StdPhysDeriv (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_d0, Array< OneD, NekDouble > &out_d1, Array< OneD, NekDouble > &out_d2=NullNekDouble1DArray) override
 
virtual void v_StdPhysDeriv (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) override
 
void v_BwdTrans (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) override
 
virtual void v_FwdTransBndConstrained (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) override
 
virtual void v_BwdTrans_SumFac (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) override
 
virtual void v_BwdTrans_SumFacKernel (const Array< OneD, const NekDouble > &base0, const Array< OneD, const NekDouble > &base1, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, Array< OneD, NekDouble > &wsp, bool doCheckCollDir0, bool doCheckCollDir1) override
 
virtual void v_FwdTrans (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) override
 Transform a given function from physical quadrature space to coefficient space. More...
 
void v_IProductWRTBase (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) override
 Calculate the inner product of inarray with respect to the basis B=base0*base1 and put into outarray. More...
 
virtual void v_IProductWRTBase_SumFac (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, bool multiplybyweights=true) override
 
virtual void v_IProductWRTBase_SumFacKernel (const Array< OneD, const NekDouble > &base0, const Array< OneD, const NekDouble > &base1, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, Array< OneD, NekDouble > &wsp, bool doCheckCollDir0, bool doCheckCollDir1) override
 
virtual void v_IProductWRTDerivBase (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) override
 
virtual void v_IProductWRTDerivBase_SumFac (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) override
 
virtual void v_LocCoordToLocCollapsed (const Array< OneD, const NekDouble > &xi, Array< OneD, NekDouble > &eta) override
 
virtual void v_LocCollapsedToLocCoord (const Array< OneD, const NekDouble > &eta, Array< OneD, NekDouble > &xi) override
 
virtual void v_FillMode (const int mode, Array< OneD, NekDouble > &array) override
 Fill outarray with mode mode of expansion. More...
 
virtual int v_GetNverts () const final override
 
virtual int v_GetNtraces () const final override
 
virtual int v_GetTraceNcoeffs (const int i) const final override
 
virtual int v_GetTraceIntNcoeffs (const int i) const final override
 
virtual int v_GetTraceNumPoints (const int i) const final override
 
virtual int v_NumBndryCoeffs () const final override
 
virtual int v_NumDGBndryCoeffs () const final override
 
virtual int v_CalcNumberOfCoefficients (const std::vector< unsigned int > &nummodes, int &modes_offset) override
 
virtual const LibUtilities::BasisKey v_GetTraceBasisKey (const int i, const int j) const final override
 
virtual LibUtilities::ShapeType v_DetShapeType () const final override
 
virtual bool v_IsBoundaryInteriorExpansion () const override
 
virtual void v_GetCoords (Array< OneD, NekDouble > &coords_0, Array< OneD, NekDouble > &coords_1, Array< OneD, NekDouble > &coords_2) override
 
virtual NekDouble v_PhysEvaluateBasis (const Array< OneD, const NekDouble > &coords, int mode) override
 This function evaluates the basis function mode mode at a point coords of the domain. More...
 
virtual NekDouble v_PhysEvaluate (const Array< OneD, NekDouble > &coord, const Array< OneD, const NekDouble > &inarray, std::array< NekDouble, 3 > &firstOrderDerivs) override
 
virtual void v_GetBoundaryMap (Array< OneD, unsigned int > &outarray) override
 
virtual void v_GetInteriorMap (Array< OneD, unsigned int > &outarray) override
 
virtual int v_GetVertexMap (int localVertexId, bool useCoeffPacking=false) override
 
virtual void v_GetTraceCoeffMap (const unsigned int traceid, Array< OneD, unsigned int > &maparray) override
 Get the map of the coefficient location to teh local trace coefficients. More...
 
void v_GetTraceInteriorToElementMap (const int eid, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray, const Orientation edgeOrient=eForwards) override
 
virtual DNekMatSharedPtr v_GenMatrix (const StdMatrixKey &mkey) override
 
virtual DNekMatSharedPtr v_CreateStdMatrix (const StdMatrixKey &mkey) override
 
void v_MassMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey) override
 
virtual void v_LaplacianMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey) override
 
virtual void v_LaplacianMatrixOp (const int k1, const int k2, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey) override
 
virtual void v_WeakDerivMatrixOp (const int i, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey) override
 
virtual void v_HelmholtzMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey) override
 
virtual void v_SVVLaplacianFilter (Array< OneD, NekDouble > &array, const StdMatrixKey &mkey) override
 
virtual void v_ExponentialFilter (Array< OneD, NekDouble > &array, const NekDouble alpha, const NekDouble exponent, const NekDouble cutoff) override
 
virtual void v_ReduceOrderCoeffs (int numMin, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) override
 
void v_MultiplyByStdQuadratureMetric (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) override
 
virtual void v_GetSimplexEquiSpacedConnectivity (Array< OneD, int > &conn, bool standard=true) override
 
- Protected Member Functions inherited from Nektar::StdRegions::StdExpansion2D
virtual NekDouble v_PhysEvaluate (const Array< OneD, const NekDouble > &coords, const Array< OneD, const NekDouble > &physvals) override
 This function evaluates the expansion at a single (arbitrary) point of the domain. More...
 
virtual NekDouble v_PhysEvaluate (const Array< OneD, DNekMatSharedPtr > &I, const Array< OneD, const NekDouble > &physvals) override
 
virtual void v_LaplacianMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey) override
 
virtual void v_HelmholtzMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey) override
 
virtual void v_GetElmtTraceToTraceMap (const unsigned int eid, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray, Orientation edgeOrient, int P, int Q) override
 Determine the mapping to re-orientate the coefficients along the element trace (assumed to align with the standard element) into the orientation of the local trace given by edgeOrient. More...
 
virtual void v_GetTraceToElementMap (const int eid, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray, Orientation edgeOrient=eForwards, int P=-1, int Q=-1) override
 
virtual void v_GenStdMatBwdDeriv (const int dir, DNekMatSharedPtr &mat) override
 
- Protected Member Functions inherited from Nektar::StdRegions::StdExpansion
DNekMatSharedPtr CreateStdMatrix (const StdMatrixKey &mkey)
 
DNekBlkMatSharedPtr CreateStdStaticCondMatrix (const StdMatrixKey &mkey)
 Create the static condensation of a matrix when using a boundary interior decomposition. More...
 
void BwdTrans_SumFac (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
void IProductWRTDerivBase_SumFac (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
void IProductWRTDirectionalDerivBase_SumFac (const Array< OneD, const NekDouble > &direction, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
void GeneralMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void MassMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void LaplacianMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void LaplacianMatrixOp_MatFree_Kernel (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, Array< OneD, NekDouble > &wsp)
 
void LaplacianMatrixOp_MatFree_GenericImpl (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void LaplacianMatrixOp_MatFree (const int k1, const int k2, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void WeakDerivMatrixOp_MatFree (const int i, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void WeakDirectionalDerivMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void MassLevelCurvatureMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void LinearAdvectionDiffusionReactionMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey, bool addDiffusionTerm=true)
 
void HelmholtzMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
void HelmholtzMatrixOp_MatFree_GenericImpl (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
 
virtual void v_SetCoeffsToOrientation (StdRegions::Orientation dir, Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
 
virtual void v_SetCoeffsToOrientation (Array< OneD, NekDouble > &coeffs, StdRegions::Orientation dir)
 
virtual NekDouble v_StdPhysEvaluate (const Array< OneD, const NekDouble > &Lcoord, const Array< OneD, const NekDouble > &physvals)
 
template<int DIR, bool DERIV = false, bool DERIV2 = false>
NekDouble BaryEvaluate (const NekDouble &coord, const NekDouble *physvals, NekDouble &deriv, NekDouble &deriv2)
 This function performs the barycentric interpolation of the polynomial stored in coord at a point physvals using barycentric interpolation weights in direction. More...
 
template<int DIR>
NekDouble BaryEvaluateBasis (const NekDouble &coord, const int &mode)
 
template<int DIR, bool DERIV = false, bool DERIV2 = false>
NekDouble BaryEvaluate (const NekDouble &coord, const NekDouble *physvals)
 Helper function to pass an unused value by reference into BaryEvaluate. More...
 
template<int DIR, bool DERIV = false, bool DERIV2 = false>
NekDouble BaryEvaluate (const NekDouble &coord, const NekDouble *physvals, NekDouble &deriv)
 

Private Types

typedef std::shared_ptr< StdExpansion1D > StdExpansion1DSharedPtr
 

Additional Inherited Members

- Protected Attributes inherited from Nektar::StdRegions::StdExpansion
Array< OneD, LibUtilities::BasisSharedPtr > m_base
 
int m_elmt_id
 
int m_ncoeffs
 
LibUtilities::NekManager< StdMatrixKey, DNekMat, StdMatrixKey::opLess > m_stdMatrixManager
 
LibUtilities::NekManager< StdMatrixKey, DNekBlkMat, StdMatrixKey::opLess > m_stdStaticCondMatrixManager
 

Detailed Description

Definition at line 50 of file StdQuadExp.h.

Member Typedef Documentation

◆ StdExpansion1DSharedPtr

typedef std::shared_ptr<StdExpansion1D> Nektar::StdRegions::StdQuadExp::StdExpansion1DSharedPtr
private

Definition at line 53 of file StdQuadExp.h.

Constructor & Destructor Documentation

◆ StdQuadExp() [1/3]

Nektar::StdRegions::StdQuadExp::StdQuadExp ( )

Definition at line 49 of file StdQuadExp.cpp.

50 {
51 }

◆ StdQuadExp() [2/3]

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

Constructor using BasisKey class for quadrature points and order definition.

Definition at line 56 of file StdQuadExp.cpp.

58  : StdExpansion(Ba.GetNumModes() * Bb.GetNumModes(), 2, Ba, Bb),
59  StdExpansion2D(Ba.GetNumModes() * Bb.GetNumModes(), Ba, Bb)
60 {
61 }
Nektar::StdRegions::StdExpansion::StdExpansion
StdExpansion()
Default Constructor.
Definition: StdExpansion.cpp:46

◆ StdQuadExp() [3/3]

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

Copy Constructor.

Definition at line 64 of file StdQuadExp.cpp.

64  : StdExpansion(T), StdExpansion2D(T)
65 {
66 }

◆ ~StdQuadExp()

Nektar::StdRegions::StdQuadExp::~StdQuadExp ( )
overridevirtual

Destructor.

Definition at line 69 of file StdQuadExp.cpp.

70 {
71 }

Member Function Documentation

◆ v_BwdTrans()

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

Implements Nektar::StdRegions::StdExpansion.

Definition at line 150 of file StdQuadExp.cpp.

152 {
153  if (m_base[0]->Collocation() && m_base[1]->Collocation())
154  {
155  Vmath::Vcopy(m_base[0]->GetNumPoints() * m_base[1]->GetNumPoints(),
156  inarray, 1, outarray, 1);
157  }
158  else
159  {
160  StdQuadExp::v_BwdTrans_SumFac(inarray, outarray);
161  }
162 }
Nektar::StdRegions::StdExpansion::GetNumPoints
int GetNumPoints(const int dir) const
This function returns the number of quadrature points in the dir direction.
Definition: StdExpansion.h:224
Nektar::StdRegions::StdExpansion::m_base
Array< OneD, LibUtilities::BasisSharedPtr > m_base
Definition: StdExpansion.h:1172
Nektar::StdRegions::StdQuadExp::v_BwdTrans_SumFac
virtual void v_BwdTrans_SumFac(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) override
Definition: StdQuadExp.cpp:164
Vmath::Vcopy
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1255

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

◆ v_BwdTrans_SumFac()

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 164 of file StdQuadExp.cpp.

166 {
167  Array<OneD, NekDouble> wsp(m_base[0]->GetNumPoints() *
168  m_base[1]->GetNumModes());
169 
170  BwdTrans_SumFacKernel(m_base[0]->GetBdata(), m_base[1]->GetBdata(), inarray,
171  outarray, wsp, true, true);
172 }
Nektar::StdRegions::StdExpansion2D::BwdTrans_SumFacKernel
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)
Definition: StdExpansion2D.cpp:201

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

Referenced by v_BwdTrans().

◆ v_BwdTrans_SumFacKernel()

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

Implements Nektar::StdRegions::StdExpansion2D.

Definition at line 184 of file StdQuadExp.cpp.

190 {
191  int nquad0 = m_base[0]->GetNumPoints();
192  int nquad1 = m_base[1]->GetNumPoints();
193  int nmodes0 = m_base[0]->GetNumModes();
194  int nmodes1 = m_base[1]->GetNumModes();
195 
196  bool colldir0 = doCheckCollDir0 ? (m_base[0]->Collocation()) : false;
197  bool colldir1 = doCheckCollDir1 ? (m_base[1]->Collocation()) : false;
198 
199  if (colldir0 && colldir1)
200  {
201  Vmath::Vcopy(m_ncoeffs, inarray.get(), 1, outarray.get(), 1);
202  }
203  else if (colldir0)
204  {
205  Blas::Dgemm('N', 'T', nquad0, nquad1, nmodes1, 1.0, &inarray[0], nquad0,
206  base1.get(), nquad1, 0.0, &outarray[0], nquad0);
207  }
208  else if (colldir1)
209  {
210  Blas::Dgemm('N', 'N', nquad0, nmodes1, nmodes0, 1.0, base0.get(),
211  nquad0, &inarray[0], nmodes0, 0.0, &outarray[0], nquad0);
212  }
213  else
214  {
215  ASSERTL1(wsp.size() >= nquad0 * nmodes1,
216  "Workspace size is not sufficient");
217 
218  // Those two calls correpsond to the operation
219  // out = B0*in*Transpose(B1);
220  Blas::Dgemm('N', 'N', nquad0, nmodes1, nmodes0, 1.0, base0.get(),
221  nquad0, &inarray[0], nmodes0, 0.0, &wsp[0], nquad0);
222  Blas::Dgemm('N', 'T', nquad0, nquad1, nmodes1, 1.0, &wsp[0], nquad0,
223  base1.get(), nquad1, 0.0, &outarray[0], nquad0);
224  }
225 }
ASSERTL1
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode....
Definition: ErrorUtil.hpp:249
Blas::Dgemm
static void Dgemm(const char &transa, const char &transb, const int &m, const int &n, const int &k, const double &alpha, const double *a, const int &lda, const double *b, const int &ldb, const double &beta, double *c, const int &ldc)
BLAS level 3: Matrix-matrix multiply C = A x B where op(A)[m x k], op(B)[k x n], C[m x n] DGEMM perfo...
Definition: Blas.hpp:368

References ASSERTL1, Blas::Dgemm(), Nektar::StdRegions::StdExpansion::m_base, Nektar::StdRegions::StdExpansion::m_ncoeffs, and Vmath::Vcopy().

◆ v_CalcNumberOfCoefficients()

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 678 of file StdQuadExp.cpp.

680 {
681  int nmodes = nummodes[modes_offset] * nummodes[modes_offset + 1];
682  modes_offset += 2;
683 
684  return nmodes;
685 }

◆ v_CreateStdMatrix()

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::LocalRegions::QuadExp.

Definition at line 1354 of file StdQuadExp.cpp.

1355 {
1356  return GenMatrix(mkey);
1357 }
Nektar::StdRegions::StdExpansion::GenMatrix
DNekMatSharedPtr GenMatrix(const StdMatrixKey &mkey)
Definition: StdExpansion.h:843

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

◆ v_DetShapeType()

LibUtilities::ShapeType Nektar::StdRegions::StdQuadExp::v_DetShapeType ( ) const
finaloverrideprotectedvirtual

Implements Nektar::StdRegions::StdExpansion.

Definition at line 645 of file StdQuadExp.cpp.

646 {
647  return LibUtilities::eQuadrilateral;
648 }

References Nektar::LibUtilities::eQuadrilateral.

◆ v_ExponentialFilter()

void Nektar::StdRegions::StdQuadExp::v_ExponentialFilter ( Array< OneD, NekDouble > &  array,
const NekDouble  alpha,
const NekDouble  exponent,
const NekDouble  cutoff 
)
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 1465 of file StdQuadExp.cpp.

1469 {
1470  // Generate an orthogonal expansion
1471  int qa = m_base[0]->GetNumPoints();
1472  int qb = m_base[1]->GetNumPoints();
1473  int nmodesA = m_base[0]->GetNumModes();
1474  int nmodesB = m_base[1]->GetNumModes();
1475  int P = nmodesA - 1;
1476  int Q = nmodesB - 1;
1477 
1478  // Declare orthogonal basis.
1479  LibUtilities::PointsKey pa(qa, m_base[0]->GetPointsType());
1480  LibUtilities::PointsKey pb(qb, m_base[1]->GetPointsType());
1481 
1482  LibUtilities::BasisKey Ba(LibUtilities::eOrtho_A, nmodesA, pa);
1483  LibUtilities::BasisKey Bb(LibUtilities::eOrtho_A, nmodesB, pb);
1484  StdQuadExp OrthoExp(Ba, Bb);
1485 
1486  // Cutoff
1487  int Pcut = cutoff * P;
1488  int Qcut = cutoff * Q;
1489 
1490  // Project onto orthogonal space.
1491  Array<OneD, NekDouble> orthocoeffs(OrthoExp.GetNcoeffs());
1492  OrthoExp.FwdTrans(array, orthocoeffs);
1493 
1494  //
1495  NekDouble fac, fac1, fac2;
1496  for (int i = 0; i < nmodesA; ++i)
1497  {
1498  for (int j = 0; j < nmodesB; ++j)
1499  {
1500  // to filter out only the "high-modes"
1501  if (i > Pcut || j > Qcut)
1502  {
1503  fac1 = (NekDouble)(i - Pcut) / ((NekDouble)(P - Pcut));
1504  fac2 = (NekDouble)(j - Qcut) / ((NekDouble)(Q - Qcut));
1505  fac = max(fac1, fac2);
1506  fac = pow(fac, exponent);
1507  orthocoeffs[i * nmodesB + j] *= exp(-alpha * fac);
1508  }
1509  }
1510  }
1511 
1512  // backward transform to physical space
1513  OrthoExp.BwdTrans(orthocoeffs, array);
1514 }
Nektar::StdRegions::StdExpansion::GetPointsType
LibUtilities::PointsType GetPointsType(const int dir) const
This function returns the type of quadrature points used in the dir direction.
Definition: StdExpansion.h:211
Nektar::LibUtilities::eOrtho_A
@ eOrtho_A
Principle Orthogonal Functions .
Definition: BasisType.h:44
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:43

References Nektar::StdRegions::StdExpansion::BwdTrans(), Nektar::LibUtilities::eOrtho_A, Nektar::StdRegions::StdExpansion::FwdTrans(), Nektar::StdRegions::StdExpansion::GetNcoeffs(), Nektar::StdRegions::StdExpansion::GetPointsType(), Nektar::StdRegions::StdExpansion::m_base, and Nektar::LibUtilities::P.

◆ v_FillMode()

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

Fill outarray with mode mode of expansion.

Note for quadrilateral expansions _base0 modes run fastest

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 544 of file StdQuadExp.cpp.

545 {
546  int i;
547  int nquad0 = m_base[0]->GetNumPoints();
548  int nquad1 = m_base[1]->GetNumPoints();
549  Array<OneD, const NekDouble> base0 = m_base[0]->GetBdata();
550  Array<OneD, const NekDouble> base1 = m_base[1]->GetBdata();
551  int btmp0 = m_base[0]->GetNumModes();
552  int mode0 = mode % btmp0;
553  int mode1 = mode / btmp0;
554 
555  ASSERTL2(mode1 == (int)floor((1.0 * mode) / btmp0),
556  "Integer Truncation not Equiv to Floor");
557 
558  ASSERTL2(m_ncoeffs > mode,
559  "calling argument mode is larger than total expansion order");
560 
561  for (i = 0; i < nquad1; ++i)
562  {
563  Vmath::Vcopy(nquad0, (NekDouble *)(base0.get() + mode0 * nquad0), 1,
564  &outarray[0] + i * nquad0, 1);
565  }
566 
567  for (i = 0; i < nquad0; ++i)
568  {
569  Vmath::Vmul(nquad1, (NekDouble *)(base1.get() + mode1 * nquad1), 1,
570  &outarray[0] + i, nquad0, &outarray[0] + i, nquad0);
571  }
572 }
ASSERTL2
#define ASSERTL2(condition, msg)
Assert Level 2 – Debugging which is used FULLDEBUG compilation mode. This level assert is designed to...
Definition: ErrorUtil.hpp:272
Vmath::Vmul
void Vmul(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Multiply vector z = x*y.
Definition: Vmath.cpp:209

References ASSERTL2, Nektar::StdRegions::StdExpansion::m_base, Nektar::StdRegions::StdExpansion::m_ncoeffs, Vmath::Vcopy(), and Vmath::Vmul().

◆ v_FwdTrans()

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

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

See also
StdExpansion::FwdTrans

Implements Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::LocalRegions::QuadExp.

Definition at line 227 of file StdQuadExp.cpp.

229 {
230  if ((m_base[0]->Collocation()) && (m_base[1]->Collocation()))
231  {
232  Vmath::Vcopy(m_ncoeffs, inarray, 1, outarray, 1);
233  }
234  else
235  {
236  StdQuadExp::v_IProductWRTBase(inarray, outarray);
237 
238  // get Mass matrix inverse
239  StdMatrixKey masskey(eInvMass, DetShapeType(), *this);
240  DNekMatSharedPtr matsys = GetStdMatrix(masskey);
241 
242  // copy inarray in case inarray == outarray
243  NekVector<NekDouble> in(m_ncoeffs, outarray, eCopy);
244  NekVector<NekDouble> out(m_ncoeffs, outarray, eWrapper);
245 
246  out = (*matsys) * in;
247  }
248 }
Nektar::StdRegions::StdExpansion::GetStdMatrix
DNekMatSharedPtr GetStdMatrix(const StdMatrixKey &mkey)
Definition: StdExpansion.h:609
Nektar::StdRegions::StdExpansion::DetShapeType
LibUtilities::ShapeType DetShapeType() const
This function returns the shape of the expansion domain.
Definition: StdExpansion.h:373
Nektar::StdRegions::StdQuadExp::v_IProductWRTBase
void v_IProductWRTBase(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) override
Calculate the inner product of inarray with respect to the basis B=base0*base1 and put into outarray.
Definition: StdQuadExp.cpp:377
Nektar::DNekMatSharedPtr
std::shared_ptr< DNekMat > DNekMatSharedPtr
Definition: NekTypeDefs.hpp:75

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

◆ v_FwdTransBndConstrained()

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::LocalRegions::QuadExp.

Definition at line 250 of file StdQuadExp.cpp.

253 {
254  if ((m_base[0]->Collocation()) && (m_base[1]->Collocation()))
255  {
256  Vmath::Vcopy(m_ncoeffs, inarray, 1, outarray, 1);
257  }
258  else
259  {
260  int i, j;
261  int npoints[2] = {m_base[0]->GetNumPoints(), m_base[1]->GetNumPoints()};
262  int nmodes[2] = {m_base[0]->GetNumModes(), m_base[1]->GetNumModes()};
263 
264  fill(outarray.get(), outarray.get() + m_ncoeffs, 0.0);
265 
266  Array<OneD, NekDouble> physEdge[4];
267  Array<OneD, NekDouble> coeffEdge[4];
268  for (i = 0; i < 4; i++)
269  {
270  physEdge[i] = Array<OneD, NekDouble>(npoints[i % 2]);
271  coeffEdge[i] = Array<OneD, NekDouble>(nmodes[i % 2]);
272  }
273 
274  for (i = 0; i < npoints[0]; i++)
275  {
276  physEdge[0][i] = inarray[i];
277  physEdge[2][i] = inarray[npoints[0] * npoints[1] - 1 - i];
278  }
279 
280  for (i = 0; i < npoints[1]; i++)
281  {
282  physEdge[1][i] = inarray[npoints[0] - 1 + i * npoints[0]];
283  physEdge[3][i] =
284  inarray[(npoints[1] - 1) * npoints[0] - i * npoints[0]];
285  }
286 
287  StdSegExpSharedPtr segexp[2] = {
288  MemoryManager<StdRegions::StdSegExp>::AllocateSharedPtr(
289  m_base[0]->GetBasisKey()),
290  MemoryManager<StdRegions::StdSegExp>::AllocateSharedPtr(
291  m_base[1]->GetBasisKey())};
292 
293  Array<OneD, unsigned int> mapArray;
294  Array<OneD, int> signArray;
295  NekDouble sign;
296 
297  for (i = 0; i < 4; i++)
298  {
299  segexp[i % 2]->FwdTransBndConstrained(physEdge[i], coeffEdge[i]);
300 
301  GetTraceToElementMap(i, mapArray, signArray);
302  for (j = 0; j < nmodes[i % 2]; j++)
303  {
304  sign = (NekDouble)signArray[j];
305  outarray[mapArray[j]] = sign * coeffEdge[i][j];
306  }
307  }
308 
309  Array<OneD, NekDouble> tmp0(m_ncoeffs);
310  Array<OneD, NekDouble> tmp1(m_ncoeffs);
311 
312  StdMatrixKey masskey(eMass, DetShapeType(), *this);
313  MassMatrixOp(outarray, tmp0, masskey);
314  IProductWRTBase(inarray, tmp1);
315 
316  Vmath::Vsub(m_ncoeffs, tmp1, 1, tmp0, 1, tmp1, 1);
317 
318  // get Mass matrix inverse (only of interior DOF)
319  // use block (1,1) of the static condensed system
320  // note: this block alreay contains the inverse matrix
321  DNekMatSharedPtr matsys =
322  (m_stdStaticCondMatrixManager[masskey])->GetBlock(1, 1);
323 
324  int nBoundaryDofs = NumBndryCoeffs();
325  int nInteriorDofs = m_ncoeffs - nBoundaryDofs;
326 
327  Array<OneD, NekDouble> rhs(nInteriorDofs);
328  Array<OneD, NekDouble> result(nInteriorDofs);
329 
330  GetInteriorMap(mapArray);
331 
332  for (i = 0; i < nInteriorDofs; i++)
333  {
334  rhs[i] = tmp1[mapArray[i]];
335  }
336 
337  Blas::Dgemv('N', nInteriorDofs, nInteriorDofs, 1.0,
338  &(matsys->GetPtr())[0], nInteriorDofs, rhs.get(), 1, 0.0,
339  result.get(), 1);
340 
341  for (i = 0; i < nInteriorDofs; i++)
342  {
343  outarray[mapArray[i]] = result[i];
344  }
345  }
346 }
sign
#define sign(a, b)
return the sign(b)*a
Definition: Polylib.cpp:49
Nektar::MemoryManager::AllocateSharedPtr
static std::shared_ptr< DataType > AllocateSharedPtr(const Args &...args)
Allocate a shared pointer from the memory pool.
Definition: NekMemoryManager.hpp:168
Nektar::StdRegions::StdExpansion::MassMatrixOp
void MassMatrixOp(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
Definition: StdExpansion.h:758
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:534
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:690
Nektar::StdRegions::StdExpansion::GetInteriorMap
void GetInteriorMap(Array< OneD, unsigned int > &outarray)
Definition: StdExpansion.h:680
Nektar::StdRegions::StdExpansion::m_stdStaticCondMatrixManager
LibUtilities::NekManager< StdMatrixKey, DNekBlkMat, StdMatrixKey::opLess > m_stdStaticCondMatrixManager
Definition: StdExpansion.h:1179
Blas::Dgemv
static void Dgemv(const char &trans, const int &m, const int &n, const double &alpha, const double *a, const int &lda, const double *x, const int &incx, const double &beta, double *y, const int &incy)
BLAS level 2: Matrix vector multiply y = A x where A[m x n].
Definition: Blas.hpp:246
Nektar::StdRegions::StdSegExpSharedPtr
std::shared_ptr< StdSegExp > StdSegExpSharedPtr
Definition: StdSegExp.h:267
Vmath::Vsub
void Vsub(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Subtract vector z = x-y.
Definition: Vmath.cpp:419

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::StdRegions::StdExpansion::DetShapeType(), Blas::Dgemv(), Nektar::StdRegions::eMass, Nektar::StdRegions::StdExpansion::GetInteriorMap(), Nektar::StdRegions::StdExpansion::GetTraceToElementMap(), Nektar::StdRegions::StdExpansion::IProductWRTBase(), Nektar::StdRegions::StdExpansion::m_base, Nektar::StdRegions::StdExpansion::m_ncoeffs, Nektar::StdRegions::StdExpansion::m_stdStaticCondMatrixManager, Nektar::StdRegions::StdExpansion::MassMatrixOp(), Nektar::StdRegions::StdExpansion::NumBndryCoeffs(), sign, Vmath::Vcopy(), and Vmath::Vsub().

◆ v_GenMatrix()

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::LocalRegions::QuadExp.

Definition at line 1220 of file StdQuadExp.cpp.

1221 {
1222  int i;
1223  int order0 = GetBasisNumModes(0);
1224  int order1 = GetBasisNumModes(1);
1225  MatrixType mtype = mkey.GetMatrixType();
1226 
1227  DNekMatSharedPtr Mat;
1228 
1229  switch (mtype)
1230  {
1231  case ePhysInterpToEquiSpaced:
1232  {
1233  int nq0 = m_base[0]->GetNumPoints();
1234  int nq1 = m_base[1]->GetNumPoints();
1235  int nq;
1236 
1237  // take definition from key
1238  if (mkey.ConstFactorExists(eFactorConst))
1239  {
1240  nq = (int)mkey.GetConstFactor(eFactorConst);
1241  }
1242  else
1243  {
1244  nq = max(nq0, nq1);
1245  }
1246 
1247  int neq =
1248  LibUtilities::StdQuadData::getNumberOfCoefficients(nq, nq);
1249  Array<OneD, Array<OneD, NekDouble>> coords(neq);
1250  Array<OneD, NekDouble> coll(2);
1251  Array<OneD, DNekMatSharedPtr> I(2);
1252  Array<OneD, NekDouble> tmp(nq0);
1253 
1254  Mat = MemoryManager<DNekMat>::AllocateSharedPtr(neq, nq0 * nq1);
1255  int cnt = 0;
1256 
1257  for (int i = 0; i < nq; ++i)
1258  {
1259  for (int j = 0; j < nq; ++j, ++cnt)
1260  {
1261  coords[cnt] = Array<OneD, NekDouble>(2);
1262  coords[cnt][0] = -1.0 + 2 * j / (NekDouble)(nq - 1);
1263  coords[cnt][1] = -1.0 + 2 * i / (NekDouble)(nq - 1);
1264  }
1265  }
1266 
1267  for (int i = 0; i < neq; ++i)
1268  {
1269  LocCoordToLocCollapsed(coords[i], coll);
1270 
1271  I[0] = m_base[0]->GetI(coll);
1272  I[1] = m_base[1]->GetI(coll + 1);
1273 
1274  // interpolate first coordinate direction
1275  for (int j = 0; j < nq1; ++j)
1276  {
1277  NekDouble fac = (I[1]->GetPtr())[j];
1278  Vmath::Smul(nq0, fac, I[0]->GetPtr(), 1, tmp, 1);
1279 
1280  Vmath::Vcopy(nq0, &tmp[0], 1,
1281  Mat->GetRawPtr() + j * nq0 * neq + i, neq);
1282  }
1283  }
1284  break;
1285  }
1286  case eMass:
1287  {
1288  Mat = StdExpansion::CreateGeneralMatrix(mkey);
1289  // For Fourier basis set the imaginary component of mean mode
1290  // to have a unit diagonal component in mass matrix
1291  if (m_base[0]->GetBasisType() == LibUtilities::eFourier)
1292  {
1293  for (i = 0; i < order1; ++i)
1294  {
1295  (*Mat)(order0 * i + 1, i * order0 + 1) = 1.0;
1296  }
1297  }
1298 
1299  if (m_base[1]->GetBasisType() == LibUtilities::eFourier)
1300  {
1301  for (i = 0; i < order0; ++i)
1302  {
1303  (*Mat)(order0 + i, order0 + i) = 1.0;
1304  }
1305  }
1306  break;
1307  }
1308  case eFwdTrans:
1309  {
1310  Mat =
1311  MemoryManager<DNekMat>::AllocateSharedPtr(m_ncoeffs, m_ncoeffs);
1312  StdMatrixKey iprodkey(eIProductWRTBase, DetShapeType(), *this);
1313  DNekMat &Iprod = *GetStdMatrix(iprodkey);
1314  StdMatrixKey imasskey(eInvMass, DetShapeType(), *this);
1315  DNekMat &Imass = *GetStdMatrix(imasskey);
1316 
1317  (*Mat) = Imass * Iprod;
1318  break;
1319  }
1320  case eGaussDG:
1321  {
1322  ConstFactorMap factors = mkey.GetConstFactors();
1323 
1324  int edge = (int)factors[StdRegions::eFactorGaussEdge];
1325  int dir = (edge + 1) % 2;
1326  int nCoeffs = m_base[dir]->GetNumModes();
1327 
1328  const LibUtilities::PointsKey BS_p(
1329  nCoeffs, LibUtilities::eGaussGaussLegendre);
1330  const LibUtilities::BasisKey BS_k(LibUtilities::eGauss_Lagrange,
1331  nCoeffs, BS_p);
1332 
1333  Array<OneD, NekDouble> coords(1, 0.0);
1334  coords[0] = (edge == 0 || edge == 3) ? -1.0 : 1.0;
1335 
1336  LibUtilities::BasisSharedPtr basis =
1337  LibUtilities::BasisManager()[BS_k];
1338  DNekMatSharedPtr m_Ix = basis->GetI(coords);
1339 
1340  Mat = MemoryManager<DNekMat>::AllocateSharedPtr(1.0, nCoeffs);
1341  Vmath::Vcopy(nCoeffs, m_Ix->GetPtr(), 1, Mat->GetPtr(), 1);
1342  break;
1343  }
1344  default:
1345  {
1346  Mat = StdExpansion::CreateGeneralMatrix(mkey);
1347  break;
1348  }
1349  }
1350 
1351  return Mat;
1352 }
Nektar::StdRegions::StdExpansion::GetBasisType
LibUtilities::BasisType GetBasisType(const int dir) const
This function returns the type of basis used in the dir direction.
Definition: StdExpansion.h:162
Nektar::StdRegions::StdExpansion::LocCoordToLocCollapsed
void LocCoordToLocCollapsed(const Array< OneD, const NekDouble > &xi, Array< OneD, NekDouble > &eta)
Convert local cartesian coordinate xi into local collapsed coordinates eta.
Definition: StdExpansion.h:1001
Nektar::StdRegions::StdExpansion::CreateGeneralMatrix
DNekMatSharedPtr CreateGeneralMatrix(const StdMatrixKey &mkey)
this function generates the mass matrix
Definition: StdExpansion.cpp:255
Nektar::StdRegions::StdExpansion::GetBasisNumModes
int GetBasisNumModes(const int dir) const
This function returns the number of expansion modes in the dir direction.
Definition: StdExpansion.h:175
Nektar::LibUtilities::StdQuadData::getNumberOfCoefficients
int getNumberOfCoefficients(int Na, int Nb)
Definition: ShapeType.hpp:138
Nektar::LibUtilities::BasisManager
BasisManagerT & BasisManager(void)
Definition: ManagerAccess.cpp:48
Nektar::LibUtilities::BasisSharedPtr
std::shared_ptr< Basis > BasisSharedPtr
Definition: FoundationsFwd.hpp:71
Nektar::LibUtilities::eGaussGaussLegendre
@ eGaussGaussLegendre
1D Gauss-Gauss-Legendre quadrature points
Definition: PointsType.h:48
Nektar::LibUtilities::eGauss_Lagrange
@ eGauss_Lagrange
Lagrange Polynomials using the Gauss points.
Definition: BasisType.h:59
Nektar::LibUtilities::eFourier
@ eFourier
Fourier Expansion .
Definition: BasisType.h:57
Nektar::StdRegions::ConstFactorMap
std::map< ConstFactorType, NekDouble > ConstFactorMap
Definition: StdRegions.hpp:399
Nektar::DNekMat
NekMatrix< NekDouble, StandardMatrixTag > DNekMat
Definition: NekTypeDefs.hpp:50
Vmath::Smul
void Smul(int n, const T alpha, const T *x, const int incx, T *y, const int incy)
Scalar multiply y = alpha*x.
Definition: Vmath.cpp:248

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::LibUtilities::BasisManager(), Nektar::StdRegions::StdMatrixKey::ConstFactorExists(), Nektar::StdRegions::StdExpansion::CreateGeneralMatrix(), Nektar::StdRegions::StdExpansion::DetShapeType(), Nektar::StdRegions::eFactorConst, Nektar::StdRegions::eFactorGaussEdge, Nektar::LibUtilities::eFourier, Nektar::StdRegions::eFwdTrans, Nektar::LibUtilities::eGauss_Lagrange, Nektar::StdRegions::eGaussDG, Nektar::LibUtilities::eGaussGaussLegendre, Nektar::StdRegions::eInvMass, Nektar::StdRegions::eIProductWRTBase, Nektar::StdRegions::eMass, Nektar::StdRegions::ePhysInterpToEquiSpaced, Nektar::StdRegions::StdExpansion::GetBasisNumModes(), Nektar::StdRegions::StdExpansion::GetBasisType(), Nektar::StdRegions::StdMatrixKey::GetConstFactor(), Nektar::StdRegions::StdMatrixKey::GetConstFactors(), Nektar::StdRegions::StdMatrixKey::GetMatrixType(), Nektar::LibUtilities::StdQuadData::getNumberOfCoefficients(), Nektar::StdRegions::StdExpansion::GetStdMatrix(), Nektar::StdRegions::StdExpansion::LocCoordToLocCollapsed(), Nektar::StdRegions::StdExpansion::m_base, Nektar::StdRegions::StdExpansion::m_ncoeffs, Vmath::Smul(), and Vmath::Vcopy().

◆ v_GetBoundaryMap()

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 753 of file StdQuadExp.cpp.

754 {
755  int i;
756  int cnt = 0;
757  int nummodes0, nummodes1;
758  int value1 = 0, value2 = 0;
759  if (outarray.size() != NumBndryCoeffs())
760  {
761  outarray = Array<OneD, unsigned int>(NumBndryCoeffs());
762  }
763 
764  nummodes0 = m_base[0]->GetNumModes();
765  nummodes1 = m_base[1]->GetNumModes();
766 
767  const LibUtilities::BasisType Btype0 = GetBasisType(0);
768  const LibUtilities::BasisType Btype1 = GetBasisType(1);
769 
770  switch (Btype1)
771  {
772  case LibUtilities::eGLL_Lagrange:
773  case LibUtilities::eGauss_Lagrange:
774  value1 = nummodes0;
775  break;
776  case LibUtilities::eModified_A:
777  value1 = 2 * nummodes0;
778  break;
779  default:
780  ASSERTL0(0, "Mapping array is not defined for this expansion");
781  break;
782  }
783 
784  for (i = 0; i < value1; i++)
785  {
786  outarray[i] = i;
787  }
788  cnt = value1;
789 
790  switch (Btype0)
791  {
792  case LibUtilities::eGLL_Lagrange:
793  case LibUtilities::eGauss_Lagrange:
794  value2 = value1 + nummodes0 - 1;
795  break;
796  case LibUtilities::eModified_A:
797  value2 = value1 + 1;
798  break;
799  default:
800  ASSERTL0(0, "Mapping array is not defined for this expansion");
801  break;
802  }
803 
804  for (i = 0; i < nummodes1 - 2; i++)
805  {
806  outarray[cnt++] = value1 + i * nummodes0;
807  outarray[cnt++] = value2 + i * nummodes0;
808  }
809 
810  if (Btype1 == LibUtilities::eGLL_Lagrange ||
811  Btype1 == LibUtilities::eGauss_Lagrange)
812  {
813  for (i = nummodes0 * (nummodes1 - 1); i < GetNcoeffs(); i++)
814  {
815  outarray[cnt++] = i;
816  }
817  }
818 }
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:215
Nektar::StdRegions::StdExpansion::GetNcoeffs
int GetNcoeffs(void) const
This function returns the total number of coefficients used in the expansion.
Definition: StdExpansion.h:130
Nektar::LibUtilities::eGLL_Lagrange
@ eGLL_Lagrange
Lagrange for SEM basis .
Definition: BasisType.h:58
Nektar::LibUtilities::eModified_A
@ eModified_A
Principle Modified Functions .
Definition: BasisType.h:50

References ASSERTL0, Nektar::LibUtilities::eGauss_Lagrange, Nektar::LibUtilities::eGLL_Lagrange, Nektar::LibUtilities::eModified_A, Nektar::StdRegions::StdExpansion::GetBasisType(), Nektar::StdRegions::StdExpansion::GetNcoeffs(), Nektar::StdRegions::StdExpansion::m_base, and Nektar::StdRegions::StdExpansion::NumBndryCoeffs().

◆ v_GetCoords()

void Nektar::StdRegions::StdQuadExp::v_GetCoords ( Array< OneD, NekDouble > &  coords_0,
Array< OneD, NekDouble > &  coords_1,
Array< OneD, NekDouble > &  coords_2 
)
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::LocalRegions::QuadExp.

Definition at line 704 of file StdQuadExp.cpp.

707 {
708  boost::ignore_unused(coords_2);
709  Array<OneD, const NekDouble> z0 = m_base[0]->GetZ();
710  Array<OneD, const NekDouble> z1 = m_base[1]->GetZ();
711  int nq0 = GetNumPoints(0);
712  int nq1 = GetNumPoints(1);
713  int i;
714 
715  for (i = 0; i < nq1; ++i)
716  {
717  Blas::Dcopy(nq0, z0.get(), 1, &coords_0[0] + i * nq0, 1);
718  Vmath::Fill(nq0, z1[i], &coords_1[0] + i * nq0, 1);
719  }
720 }
Blas::Dcopy
static void Dcopy(const int &n, const double *x, const int &incx, double *y, const int &incy)
BLAS level 1: Copy x to y.
Definition: Blas.hpp:147
Vmath::Fill
void Fill(int n, const T alpha, T *x, const int incx)
Fill a vector with a constant value.
Definition: Vmath.cpp:45

References Blas::Dcopy(), Vmath::Fill(), Nektar::StdRegions::StdExpansion::GetNumPoints(), and Nektar::StdRegions::StdExpansion::m_base.

◆ v_GetInteriorMap()

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 820 of file StdQuadExp.cpp.

821 {
822  int i, j;
823  int cnt = 0;
824  int nummodes0, nummodes1;
825  int startvalue = 0;
826  if (outarray.size() != GetNcoeffs() - NumBndryCoeffs())
827  {
828  outarray = Array<OneD, unsigned int>(GetNcoeffs() - NumBndryCoeffs());
829  }
830 
831  nummodes0 = m_base[0]->GetNumModes();
832  nummodes1 = m_base[1]->GetNumModes();
833 
834  const LibUtilities::BasisType Btype0 = GetBasisType(0);
835  const LibUtilities::BasisType Btype1 = GetBasisType(1);
836 
837  switch (Btype1)
838  {
839  case LibUtilities::eGLL_Lagrange:
840  startvalue = nummodes0;
841  break;
842  case LibUtilities::eModified_A:
843  startvalue = 2 * nummodes0;
844  break;
845  default:
846  ASSERTL0(0, "Mapping array is not defined for this expansion");
847  break;
848  }
849 
850  switch (Btype0)
851  {
852  case LibUtilities::eGLL_Lagrange:
853  startvalue++;
854  break;
855  case LibUtilities::eModified_A:
856  startvalue += 2;
857  break;
858  default:
859  ASSERTL0(0, "Mapping array is not defined for this expansion");
860  break;
861  }
862 
863  for (i = 0; i < nummodes1 - 2; i++)
864  {
865  for (j = 0; j < nummodes0 - 2; j++)
866  {
867  outarray[cnt++] = startvalue + j;
868  }
869  startvalue += nummodes0;
870  }
871 }

References ASSERTL0, Nektar::LibUtilities::eGLL_Lagrange, Nektar::LibUtilities::eModified_A, Nektar::StdRegions::StdExpansion::GetBasisType(), Nektar::StdRegions::StdExpansion::GetNcoeffs(), Nektar::StdRegions::StdExpansion::m_base, and Nektar::StdRegions::StdExpansion::NumBndryCoeffs().

◆ v_GetNtraces()

int Nektar::StdRegions::StdQuadExp::v_GetNtraces ( ) const
finaloverrideprotectedvirtual

Implements Nektar::StdRegions::StdExpansion.

Definition at line 583 of file StdQuadExp.cpp.

584 {
585  return 4;
586 }

◆ v_GetNverts()

int Nektar::StdRegions::StdQuadExp::v_GetNverts ( ) const
finaloverrideprotectedvirtual

Implements Nektar::StdRegions::StdExpansion.

Definition at line 578 of file StdQuadExp.cpp.

579 {
580  return 4;
581 }

◆ v_GetSimplexEquiSpacedConnectivity()

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 1620 of file StdQuadExp.cpp.

1622 {
1623  boost::ignore_unused(standard);
1624 
1625  int np1 = m_base[0]->GetNumPoints();
1626  int np2 = m_base[1]->GetNumPoints();
1627  int np = max(np1, np2);
1628 
1629  conn = Array<OneD, int>(6 * (np - 1) * (np - 1));
1630 
1631  int row = 0;
1632  int rowp1 = 0;
1633  int cnt = 0;
1634  for (int i = 0; i < np - 1; ++i)
1635  {
1636  rowp1 += np;
1637  for (int j = 0; j < np - 1; ++j)
1638  {
1639  conn[cnt++] = row + j;
1640  conn[cnt++] = row + j + 1;
1641  conn[cnt++] = rowp1 + j;
1642 
1643  conn[cnt++] = rowp1 + j + 1;
1644  conn[cnt++] = rowp1 + j;
1645  conn[cnt++] = row + j + 1;
1646  }
1647  row += np;
1648  }
1649 }

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

◆ v_GetTraceBasisKey()

const LibUtilities::BasisKey Nektar::StdRegions::StdQuadExp::v_GetTraceBasisKey ( const int  i,
const int  j 
) const
finaloverrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 629 of file StdQuadExp.cpp.

631 {
632  boost::ignore_unused(j);
633  ASSERTL2((i >= 0) && (i <= 3), "edge id is out of range");
634 
635  if ((i == 0) || (i == 2))
636  {
637  return GetBasis(0)->GetBasisKey();
638  }
639  else
640  {
641  return GetBasis(1)->GetBasisKey();
642  }
643 }
Nektar::StdRegions::StdExpansion::GetBasis
const LibUtilities::BasisSharedPtr & GetBasis(int dir) const
This function gets the shared point to basis in the dir direction.
Definition: StdExpansion.h:118

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

◆ v_GetTraceCoeffMap()

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

Get the map of the coefficient location to teh local trace coefficients.

Reimplemented from Nektar::StdRegions::StdExpansion2D.

Definition at line 988 of file StdQuadExp.cpp.

990 {
991  ASSERTL1(traceid < 4, "traceid must be between 0 and 3");
992 
993  unsigned int i;
994  unsigned int order0 = m_base[0]->GetNumModes();
995  unsigned int order1 = m_base[1]->GetNumModes();
996  unsigned int numModes = (traceid % 2) ? order1 : order0;
997 
998  if (maparray.size() != numModes)
999  {
1000  maparray = Array<OneD, unsigned int>(numModes);
1001  }
1002 
1003  const LibUtilities::BasisType bType = GetBasisType(traceid % 2);
1004 
1005  if (bType == LibUtilities::eModified_A)
1006  {
1007  switch (traceid)
1008  {
1009  case 0:
1010  {
1011  for (i = 0; i < numModes; i++)
1012  {
1013  maparray[i] = i;
1014  }
1015  }
1016  break;
1017  case 1:
1018  {
1019  for (i = 0; i < numModes; i++)
1020  {
1021  maparray[i] = i * order0 + 1;
1022  }
1023  }
1024  break;
1025  case 2:
1026  {
1027  for (i = 0; i < numModes; i++)
1028  {
1029  maparray[i] = order0 + i;
1030  }
1031  }
1032  break;
1033  case 3:
1034  {
1035  for (i = 0; i < numModes; i++)
1036  {
1037  maparray[i] = i * order0;
1038  }
1039  }
1040  break;
1041  default:
1042  break;
1043  }
1044  }
1045  else if (bType == LibUtilities::eGLL_Lagrange ||
1046  bType == LibUtilities::eGauss_Lagrange)
1047  {
1048  switch (traceid)
1049  {
1050  case 0:
1051  {
1052  for (i = 0; i < numModes; i++)
1053  {
1054  maparray[i] = i;
1055  }
1056  }
1057  break;
1058  case 1:
1059  {
1060  for (i = 0; i < numModes; i++)
1061  {
1062  maparray[i] = (i + 1) * order0 - 1;
1063  }
1064  }
1065  break;
1066  case 2:
1067  {
1068  for (i = 0; i < numModes; i++)
1069  {
1070  maparray[i] = order0 * (order1 - 1) + i;
1071  }
1072  }
1073  break;
1074  case 3:
1075  {
1076  for (i = 0; i < numModes; i++)
1077  {
1078  maparray[i] = order0 * i;
1079  }
1080  }
1081  break;
1082  default:
1083  break;
1084  }
1085  }
1086  else
1087  {
1088  ASSERTL0(false, "Mapping not defined for this type of basis");
1089  }
1090 }

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

◆ v_GetTraceInteriorToElementMap()

void Nektar::StdRegions::StdQuadExp::v_GetTraceInteriorToElementMap ( const int  eid,
Array< OneD, unsigned int > &  maparray,
Array< OneD, int > &  signarray,
const Orientation  edgeOrient = eForwards 
)
overrideprotectedvirtual

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 1092 of file StdQuadExp.cpp.

1095 {
1096  int i;
1097  const int nummodes0 = m_base[0]->GetNumModes();
1098  const int nummodes1 = m_base[1]->GetNumModes();
1099  const int nEdgeIntCoeffs = GetTraceNcoeffs(eid) - 2;
1100  const LibUtilities::BasisType bType = GetBasisType(eid % 2);
1101 
1102  if (maparray.size() != nEdgeIntCoeffs)
1103  {
1104  maparray = Array<OneD, unsigned int>(nEdgeIntCoeffs);
1105  }
1106 
1107  if (signarray.size() != nEdgeIntCoeffs)
1108  {
1109  signarray = Array<OneD, int>(nEdgeIntCoeffs, 1);
1110  }
1111  else
1112  {
1113  fill(signarray.get(), signarray.get() + nEdgeIntCoeffs, 1);
1114  }
1115 
1116  if (bType == LibUtilities::eModified_A)
1117  {
1118  switch (eid)
1119  {
1120  case 0:
1121  {
1122  for (i = 0; i < nEdgeIntCoeffs; i++)
1123  {
1124  maparray[i] = i + 2;
1125  }
1126  }
1127  break;
1128  case 1:
1129  {
1130  for (i = 0; i < nEdgeIntCoeffs; i++)
1131  {
1132  maparray[i] = (i + 2) * nummodes0 + 1;
1133  }
1134  }
1135  break;
1136  case 2:
1137  {
1138  for (i = 0; i < nEdgeIntCoeffs; i++)
1139  {
1140  maparray[i] = nummodes0 + i + 2;
1141  }
1142  }
1143  break;
1144  case 3:
1145  {
1146  for (i = 0; i < nEdgeIntCoeffs; i++)
1147  {
1148  maparray[i] = (i + 2) * nummodes0;
1149  }
1150  }
1151  break;
1152  default:
1153  ASSERTL0(false, "eid must be between 0 and 3");
1154  break;
1155  }
1156 
1157  if (edgeOrient == eBackwards)
1158  {
1159  for (i = 1; i < nEdgeIntCoeffs; i += 2)
1160  {
1161  signarray[i] = -1;
1162  }
1163  }
1164  }
1165  else if (bType == LibUtilities::eGLL_Lagrange)
1166  {
1167  switch (eid)
1168  {
1169  case 0:
1170  {
1171  for (i = 0; i < nEdgeIntCoeffs; i++)
1172  {
1173  maparray[i] = i + 1;
1174  }
1175  }
1176  break;
1177  case 1:
1178  {
1179  for (i = 0; i < nEdgeIntCoeffs; i++)
1180  {
1181  maparray[i] = (i + 2) * nummodes0 - 1;
1182  }
1183  }
1184  break;
1185  case 2:
1186  {
1187  for (i = 0; i < nEdgeIntCoeffs; i++)
1188  {
1189  maparray[i] = nummodes0 * (nummodes1 - 1) + i + 1;
1190  }
1191  }
1192  break;
1193  case 3:
1194  {
1195  for (i = 0; i < nEdgeIntCoeffs; i++)
1196  {
1197  maparray[i] = nummodes0 * (i + 1);
1198  }
1199  }
1200  break;
1201  default:
1202  ASSERTL0(false, "eid must be between 0 and 3");
1203  break;
1204  }
1205  if (edgeOrient == eBackwards)
1206  {
1207  reverse(maparray.get(), maparray.get() + nEdgeIntCoeffs);
1208  }
1209  }
1210  else
1211  {
1212  ASSERTL0(false, "Mapping not defined for this type of basis");
1213  }
1214 }
Nektar::StdRegions::StdExpansion::GetTraceNcoeffs
int GetTraceNcoeffs(const int i) const
This function returns the number of expansion coefficients belonging to the i-th trace.
Definition: StdExpansion.h:267

References ASSERTL0, Nektar::StdRegions::eBackwards, Nektar::LibUtilities::eGLL_Lagrange, Nektar::LibUtilities::eModified_A, Nektar::StdRegions::StdExpansion::GetBasisType(), Nektar::StdRegions::StdExpansion::GetTraceNcoeffs(), and Nektar::StdRegions::StdExpansion::m_base.

◆ v_GetTraceIntNcoeffs()

int Nektar::StdRegions::StdQuadExp::v_GetTraceIntNcoeffs ( const int  i) const
finaloverrideprotectedvirtual

Implements Nektar::StdRegions::StdExpansion.

Definition at line 602 of file StdQuadExp.cpp.

603 {
604  ASSERTL2((i >= 0) && (i <= 4), "edge id is out of range");
605  if ((i == 0) || (i == 2))
606  {
607  return GetBasisNumModes(0) - 2;
608  }
609  else
610  {
611  return GetBasisNumModes(1) - 2;
612  }
613 }

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

◆ v_GetTraceNcoeffs()

int Nektar::StdRegions::StdQuadExp::v_GetTraceNcoeffs ( const int  i) const
finaloverrideprotectedvirtual

Implements Nektar::StdRegions::StdExpansion.

Definition at line 588 of file StdQuadExp.cpp.

589 {
590  ASSERTL2((i >= 0) && (i <= 3), "edge id is out of range");
591 
592  if ((i == 0) || (i == 2))
593  {
594  return GetBasisNumModes(0);
595  }
596  else
597  {
598  return GetBasisNumModes(1);
599  }
600 }

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

◆ v_GetTraceNumPoints()

int Nektar::StdRegions::StdQuadExp::v_GetTraceNumPoints ( const int  i) const
finaloverrideprotectedvirtual

Implements Nektar::StdRegions::StdExpansion.

Definition at line 615 of file StdQuadExp.cpp.

616 {
617  ASSERTL2((i >= 0) && (i <= 3), "edge id is out of range");
618 
619  if ((i == 0) || (i == 2))
620  {
621  return GetNumPoints(0);
622  }
623  else
624  {
625  return GetNumPoints(1);
626  }
627 }

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

◆ v_GetVertexMap()

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 873 of file StdQuadExp.cpp.

874 {
875  int localDOF = 0;
876 
877  if (useCoeffPacking == true)
878  {
879  switch (localVertexId)
880  {
881  case 0:
882  {
883  localDOF = 0;
884  }
885  break;
886  case 1:
887  {
888  if (m_base[0]->GetBasisType() == LibUtilities::eGLL_Lagrange)
889  {
890  localDOF = m_base[0]->GetNumModes() - 1;
891  }
892  else
893  {
894  localDOF = 1;
895  }
896  }
897  break;
898  case 2:
899  {
900  if (m_base[0]->GetBasisType() == LibUtilities::eGLL_Lagrange)
901  {
902  localDOF = m_base[0]->GetNumModes() *
903  (m_base[1]->GetNumModes() - 1);
904  }
905  else
906  {
907  localDOF = m_base[0]->GetNumModes();
908  }
909  }
910  break;
911  case 3:
912  {
913  if (m_base[0]->GetBasisType() == LibUtilities::eGLL_Lagrange)
914  {
915  localDOF =
916  m_base[0]->GetNumModes() * m_base[1]->GetNumModes() - 1;
917  }
918  else
919  {
920  localDOF = m_base[0]->GetNumModes() + 1;
921  }
922  }
923  break;
924  default:
925  ASSERTL0(false, "eid must be between 0 and 3");
926  break;
927  }
928  }
929  else
930  {
931  switch (localVertexId)
932  {
933  case 0:
934  {
935  localDOF = 0;
936  }
937  break;
938  case 1:
939  {
940  if (m_base[0]->GetBasisType() == LibUtilities::eGLL_Lagrange)
941  {
942  localDOF = m_base[0]->GetNumModes() - 1;
943  }
944  else
945  {
946  localDOF = 1;
947  }
948  }
949  break;
950  case 2:
951  {
952  if (m_base[0]->GetBasisType() == LibUtilities::eGLL_Lagrange)
953  {
954  localDOF =
955  m_base[0]->GetNumModes() * m_base[1]->GetNumModes() - 1;
956  }
957  else
958  {
959  localDOF = m_base[0]->GetNumModes() + 1;
960  }
961  }
962  break;
963  case 3:
964  {
965  if (m_base[0]->GetBasisType() == LibUtilities::eGLL_Lagrange)
966  {
967  localDOF = m_base[0]->GetNumModes() *
968  (m_base[1]->GetNumModes() - 1);
969  }
970  else
971  {
972  localDOF = m_base[0]->GetNumModes();
973  }
974  }
975  break;
976  default:
977  ASSERTL0(false, "eid must be between 0 and 3");
978  break;
979  }
980  }
981  return localDOF;
982 }

References ASSERTL0, Nektar::LibUtilities::eGLL_Lagrange, Nektar::StdRegions::StdExpansion::GetBasisType(), and Nektar::StdRegions::StdExpansion::m_base.

◆ v_HelmholtzMatrixOp()

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::LocalRegions::QuadExp.

Definition at line 1587 of file StdQuadExp.cpp.

1590 {
1591  StdQuadExp::v_HelmholtzMatrixOp_MatFree(inarray, outarray, mkey);
1592 }
Nektar::StdRegions::StdExpansion2D::v_HelmholtzMatrixOp_MatFree
virtual void v_HelmholtzMatrixOp_MatFree(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey) override
Definition: StdExpansion2D.cpp:323

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

◆ v_Integral()

NekDouble Nektar::StdRegions::StdQuadExp::v_Integral ( const Array< OneD, const NekDouble > &  inarray)
overrideprotectedvirtual

Integrates the specified function over the domain.

See also
StdRegions::StdExpansion::Integral.

Reimplemented from Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::LocalRegions::QuadExp.

Definition at line 77 of file StdQuadExp.cpp.

78 {
79  Array<OneD, const NekDouble> w0 = m_base[0]->GetW();
80  Array<OneD, const NekDouble> w1 = m_base[1]->GetW();
81 
82  return StdExpansion2D::Integral(inarray, w0, w1);
83 }
Nektar::StdRegions::StdExpansion2D::Integral
NekDouble Integral(const Array< OneD, const NekDouble > &inarray, const Array< OneD, const NekDouble > &w0, const Array< OneD, const NekDouble > &w1)
Definition: StdExpansion2D.cpp:174

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

◆ v_IProductWRTBase()

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

Calculate the inner product of inarray with respect to the basis B=base0*base1 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} \)

Implements Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::LocalRegions::QuadExp.

Definition at line 377 of file StdQuadExp.cpp.

379 {
380  if (m_base[0]->Collocation() && m_base[1]->Collocation())
381  {
382  MultiplyByQuadratureMetric(inarray, outarray);
383  }
384  else
385  {
386  StdQuadExp::v_IProductWRTBase_SumFac(inarray, outarray);
387  }
388 }
Nektar::StdRegions::StdExpansion::MultiplyByQuadratureMetric
void MultiplyByQuadratureMetric(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
Definition: StdExpansion.h:729
Nektar::StdRegions::StdQuadExp::v_IProductWRTBase_SumFac
virtual void v_IProductWRTBase_SumFac(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, bool multiplybyweights=true) override
Definition: StdQuadExp.cpp:390

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

Referenced by v_FwdTrans().

◆ v_IProductWRTBase_SumFac()

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::LocalRegions::QuadExp.

Definition at line 390 of file StdQuadExp.cpp.

393 {
394  int nquad0 = m_base[0]->GetNumPoints();
395  int nquad1 = m_base[1]->GetNumPoints();
396  int order0 = m_base[0]->GetNumModes();
397 
398  if (multiplybyweights)
399  {
400  Array<OneD, NekDouble> tmp(nquad0 * nquad1 + nquad1 * order0);
401  Array<OneD, NekDouble> wsp(tmp + nquad0 * nquad1);
402 
403  // multiply by integration constants
404  MultiplyByQuadratureMetric(inarray, tmp);
405  IProductWRTBase_SumFacKernel(m_base[0]->GetBdata(),
406  m_base[1]->GetBdata(), tmp, outarray, wsp,
407  true, true);
408  }
409  else
410  {
411  Array<OneD, NekDouble> wsp(nquad1 * order0);
412  IProductWRTBase_SumFacKernel(m_base[0]->GetBdata(),
413  m_base[1]->GetBdata(), inarray, outarray,
414  wsp, true, true);
415  }
416 }
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:212

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

Referenced by v_IProductWRTBase().

◆ v_IProductWRTBase_SumFacKernel()

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

Implements Nektar::StdRegions::StdExpansion2D.

Definition at line 466 of file StdQuadExp.cpp.

472 {
473  int nquad0 = m_base[0]->GetNumPoints();
474  int nquad1 = m_base[1]->GetNumPoints();
475  int nmodes0 = m_base[0]->GetNumModes();
476  int nmodes1 = m_base[1]->GetNumModes();
477 
478  bool colldir0 = doCheckCollDir0 ? (m_base[0]->Collocation()) : false;
479  bool colldir1 = doCheckCollDir1 ? (m_base[1]->Collocation()) : false;
480 
481  if (colldir0 && colldir1)
482  {
483  Vmath::Vcopy(m_ncoeffs, inarray.get(), 1, outarray.get(), 1);
484  }
485  else if (colldir0)
486  {
487  Blas::Dgemm('N', 'N', nmodes0, nmodes1, nquad1, 1.0, inarray.get(),
488  nmodes0, base1.get(), nquad1, 0.0, outarray.get(), nmodes0);
489  }
490  else if (colldir1)
491  {
492  Blas::Dgemm('T', 'N', nmodes0, nquad1, nquad0, 1.0, base0.get(), nquad0,
493  inarray.get(), nquad0, 0.0, outarray.get(), nmodes0);
494  }
495  else
496  {
497  ASSERTL1(wsp.size() >= nquad1 * nmodes0,
498  "Workspace size is not sufficient");
499 
500 #if 1
501  Blas::Dgemm('T', 'N', nmodes0, nquad1, nquad0, 1.0, base0.get(), nquad0,
502  inarray.get(), nquad0, 0.0, wsp.get(), nmodes0);
503 
504 #else
505  for (int i = 0; i < nmodes0; ++i)
506  {
507  for (int j = 0; j < nquad1; ++j)
508  {
509  wsp[j * nmodes0 + i] =
510  Blas::Ddot(nquad0, base0.get() + i * nquad0, 1,
511  inarray.get() + j * nquad0, 1);
512  }
513  }
514 #endif
515  Blas::Dgemm('N', 'N', nmodes0, nmodes1, nquad1, 1.0, wsp.get(), nmodes0,
516  base1.get(), nquad1, 0.0, outarray.get(), nmodes0);
517  }
518 }
Blas::Ddot
static double Ddot(const int &n, const double *x, const int &incx, const double *y, const int &incy)
BLAS level 1: output = .
Definition: Blas.hpp:182

References ASSERTL1, Blas::Ddot(), Blas::Dgemm(), Nektar::StdRegions::StdExpansion::m_base, Nektar::StdRegions::StdExpansion::m_ncoeffs, and Vmath::Vcopy().

◆ v_IProductWRTDerivBase()

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::LocalRegions::QuadExp.

Definition at line 418 of file StdQuadExp.cpp.

421 {
422  v_IProductWRTDerivBase_SumFac(dir, inarray, outarray);
423 }
Nektar::StdRegions::StdQuadExp::v_IProductWRTDerivBase_SumFac
virtual void v_IProductWRTDerivBase_SumFac(const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) override
Definition: StdQuadExp.cpp:425

References v_IProductWRTDerivBase_SumFac().

◆ v_IProductWRTDerivBase_SumFac()

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::LocalRegions::QuadExp.

Definition at line 425 of file StdQuadExp.cpp.

428 {
429  ASSERTL0((dir == 0) || (dir == 1), "input dir is out of range");
430 
431  int nquad0 = m_base[0]->GetNumPoints();
432  int nquad1 = m_base[1]->GetNumPoints();
433  int nqtot = nquad0 * nquad1;
434  int order0 = m_base[0]->GetNumModes();
435 
436  Array<OneD, NekDouble> tmp(nqtot + nquad1 * order0);
437  Array<OneD, NekDouble> wsp(tmp + nqtot);
438 
439  // multiply by integration constants
440  MultiplyByQuadratureMetric(inarray, tmp);
441 
442  if (dir) // dir == 1
443  {
444  IProductWRTBase_SumFacKernel(m_base[0]->GetBdata(),
445  m_base[1]->GetDbdata(), tmp, outarray, wsp,
446  true, false);
447  }
448  else // dir == 0
449  {
450  IProductWRTBase_SumFacKernel(m_base[0]->GetDbdata(),
451  m_base[1]->GetBdata(), tmp, outarray, wsp,
452  false, true);
453  }
454 }

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

Referenced by v_IProductWRTDerivBase().

◆ v_IsBoundaryInteriorExpansion()

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 687 of file StdQuadExp.cpp.

688 {
689  bool returnval = false;
690 
691  if ((m_base[0]->GetBasisType() == LibUtilities::eModified_A) ||
692  (m_base[0]->GetBasisType() == LibUtilities::eGLL_Lagrange))
693  {
694  if ((m_base[1]->GetBasisType() == LibUtilities::eModified_A) ||
695  (m_base[1]->GetBasisType() == LibUtilities::eGLL_Lagrange))
696  {
697  returnval = true;
698  }
699  }
700 
701  return returnval;
702 }

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

◆ v_LaplacianMatrixOp() [1/2]

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::LocalRegions::QuadExp.

Definition at line 1566 of file StdQuadExp.cpp.

1569 {
1570  StdQuadExp::v_LaplacianMatrixOp_MatFree(inarray, outarray, mkey);
1571 }
Nektar::StdRegions::StdExpansion2D::v_LaplacianMatrixOp_MatFree
virtual void v_LaplacianMatrixOp_MatFree(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey) override
Definition: StdExpansion2D.cpp:274

References Nektar::StdRegions::StdExpansion2D::v_LaplacianMatrixOp_MatFree().

◆ v_LaplacianMatrixOp() [2/2]

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::LocalRegions::QuadExp.

Definition at line 1573 of file StdQuadExp.cpp.

1576 {
1577  StdExpansion::LaplacianMatrixOp_MatFree(k1, k2, inarray, outarray, mkey);
1578 }
Nektar::StdRegions::StdExpansion::LaplacianMatrixOp_MatFree
void LaplacianMatrixOp_MatFree(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
Definition: StdExpansion.h:1240

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

◆ v_LocCollapsedToLocCoord()

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 531 of file StdQuadExp.cpp.

533 {
534  xi[0] = eta[0];
535  xi[1] = eta[1];
536 }

◆ v_LocCoordToLocCollapsed()

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 524 of file StdQuadExp.cpp.

526 {
527  eta[0] = xi[0];
528  eta[1] = xi[1];
529 }

◆ v_MassMatrixOp()

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::LocalRegions::QuadExp.

Definition at line 1559 of file StdQuadExp.cpp.

1562 {
1563  StdExpansion::MassMatrixOp_MatFree(inarray, outarray, mkey);
1564 }
Nektar::StdRegions::StdExpansion::MassMatrixOp_MatFree
void MassMatrixOp_MatFree(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
Definition: StdExpansion.cpp:668

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

◆ v_MultiplyByStdQuadratureMetric()

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 1595 of file StdQuadExp.cpp.

1598 {
1599  int i;
1600  int nquad0 = m_base[0]->GetNumPoints();
1601  int nquad1 = m_base[1]->GetNumPoints();
1602 
1603  const Array<OneD, const NekDouble> &w0 = m_base[0]->GetW();
1604  const Array<OneD, const NekDouble> &w1 = m_base[1]->GetW();
1605 
1606  // multiply by integration constants
1607  for (i = 0; i < nquad1; ++i)
1608  {
1609  Vmath::Vmul(nquad0, inarray.get() + i * nquad0, 1, w0.get(), 1,
1610  outarray.get() + i * nquad0, 1);
1611  }
1612 
1613  for (i = 0; i < nquad0; ++i)
1614  {
1615  Vmath::Vmul(nquad1, outarray.get() + i, nquad0, w1.get(), 1,
1616  outarray.get() + i, nquad0);
1617  }
1618 }

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

◆ v_NumBndryCoeffs()

int Nektar::StdRegions::StdQuadExp::v_NumBndryCoeffs ( ) const
finaloverrideprotectedvirtual

Implements Nektar::StdRegions::StdExpansion.

Definition at line 650 of file StdQuadExp.cpp.

651 {
652  ASSERTL1(GetBasisType(0) == LibUtilities::eModified_A ||
653  GetBasisType(0) == LibUtilities::eGLL_Lagrange ||
654  GetBasisType(0) == LibUtilities::eGauss_Lagrange,
655  "BasisType is not a boundary interior form");
656  ASSERTL1(GetBasisType(1) == LibUtilities::eModified_A ||
657  GetBasisType(1) == LibUtilities::eGLL_Lagrange ||
658  GetBasisType(0) == LibUtilities::eGauss_Lagrange,
659  "BasisType is not a boundary interior form");
660 
661  return 4 + 2 * (GetBasisNumModes(0) - 2) + 2 * (GetBasisNumModes(1) - 2);
662 }

References ASSERTL1, Nektar::LibUtilities::eGauss_Lagrange, Nektar::LibUtilities::eGLL_Lagrange, Nektar::LibUtilities::eModified_A, Nektar::StdRegions::StdExpansion::GetBasisNumModes(), and Nektar::StdRegions::StdExpansion::GetBasisType().

◆ v_NumDGBndryCoeffs()

int Nektar::StdRegions::StdQuadExp::v_NumDGBndryCoeffs ( ) const
finaloverrideprotectedvirtual

Implements Nektar::StdRegions::StdExpansion.

Definition at line 664 of file StdQuadExp.cpp.

665 {
666  ASSERTL1(GetBasisType(0) == LibUtilities::eModified_A ||
667  GetBasisType(0) == LibUtilities::eGLL_Lagrange ||
668  GetBasisType(0) == LibUtilities::eGauss_Lagrange,
669  "BasisType is not a boundary interior form");
670  ASSERTL1(GetBasisType(1) == LibUtilities::eModified_A ||
671  GetBasisType(1) == LibUtilities::eGLL_Lagrange ||
672  GetBasisType(0) == LibUtilities::eGauss_Lagrange,
673  "BasisType is not a boundary interior form");
674 
675  return 2 * GetBasisNumModes(0) + 2 * GetBasisNumModes(1);
676 }

References ASSERTL1, Nektar::LibUtilities::eGauss_Lagrange, Nektar::LibUtilities::eGLL_Lagrange, Nektar::LibUtilities::eModified_A, Nektar::StdRegions::StdExpansion::GetBasisNumModes(), and Nektar::StdRegions::StdExpansion::GetBasisType().

◆ v_PhysDeriv() [1/2]

void Nektar::StdRegions::StdQuadExp::v_PhysDeriv ( const Array< OneD, const NekDouble > &  inarray,
Array< OneD, NekDouble > &  out_d0,
Array< OneD, NekDouble > &  out_d1,
Array< OneD, NekDouble > &  out_d2 = NullNekDouble1DArray 
)
overrideprotectedvirtual

Calculate the derivative of the physical points.

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::LocalRegions::QuadExp.

Definition at line 95 of file StdQuadExp.cpp.

99 {
100  boost::ignore_unused(out_d2);
101  PhysTensorDeriv(inarray, out_d0, out_d1);
102 }
Nektar::StdRegions::StdExpansion2D::PhysTensorDeriv
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.
Definition: StdExpansion2D.cpp:68

References Nektar::StdRegions::StdExpansion2D::PhysTensorDeriv().

Referenced by v_StdPhysDeriv().

◆ v_PhysDeriv() [2/2]

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

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

See also
StdRegions::StdExpansion::PhysDeriv

Reimplemented from Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::LocalRegions::QuadExp.

Definition at line 104 of file StdQuadExp.cpp.

107 {
108  switch (dir)
109  {
110  case 0:
111  {
112  PhysTensorDeriv(inarray, outarray, NullNekDouble1DArray);
113  }
114  break;
115  case 1:
116  {
117  PhysTensorDeriv(inarray, NullNekDouble1DArray, outarray);
118  }
119  break;
120  default:
121  {
122  ASSERTL1(false, "input dir is out of range");
123  }
124  break;
125  }
126 }
Nektar::NullNekDouble1DArray
static Array< OneD, NekDouble > NullNekDouble1DArray
Definition: SharedArray.hpp:900

References ASSERTL1, Nektar::NullNekDouble1DArray, and Nektar::StdRegions::StdExpansion2D::PhysTensorDeriv().

◆ v_PhysEvaluate()

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

Reimplemented from Nektar::StdRegions::StdExpansion2D.

Reimplemented in Nektar::LocalRegions::QuadExp.

Definition at line 172 of file StdQuadExp.h.

176  {
177  return BaryTensorDeriv(coord, inarray, firstOrderDerivs);
178  }
Nektar::StdRegions::StdExpansion2D::BaryTensorDeriv
NekDouble BaryTensorDeriv(const Array< OneD, NekDouble > &coord, const Array< OneD, const NekDouble > &inarray, std::array< NekDouble, 3 > &firstOrderDerivs)
Definition: StdExpansion2D.h:103

References Nektar::StdRegions::StdExpansion2D::BaryTensorDeriv().

◆ v_PhysEvaluateBasis()

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

This function evaluates the basis function mode mode at a point coords of the domain.

This function uses barycentric interpolation with the tensor product separation of the basis function to improve performance.

Parameters
coordThe coordinate inside the standard region.
modeThe mode number to be evaluated.
Returns
The value of the basis function mode at coords.

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 734 of file StdQuadExp.cpp.

736 {
737  ASSERTL2(coords[0] > -1 - NekConstants::kNekZeroTol, "coord[0] < -1");
738  ASSERTL2(coords[0] < 1 + NekConstants::kNekZeroTol, "coord[0] > 1");
739  ASSERTL2(coords[1] > -1 - NekConstants::kNekZeroTol, "coord[1] < -1");
740  ASSERTL2(coords[1] < 1 + NekConstants::kNekZeroTol, "coord[1] > 1");
741 
742  const int nm0 = m_base[0]->GetNumModes();
743  const int nm1 = m_base[1]->GetNumModes();
744 
745  return StdExpansion::BaryEvaluateBasis<0>(coords[0], mode % nm1) *
746  StdExpansion::BaryEvaluateBasis<1>(coords[1], mode / nm0);
747 }
Nektar::NekConstants::kNekZeroTol
static const NekDouble kNekZeroTol
Definition: NektarUnivConsts.hpp:51

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

◆ v_ReduceOrderCoeffs()

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::LocalRegions::QuadExp.

Definition at line 1516 of file StdQuadExp.cpp.

1519 {
1520  int n_coeffs = inarray.size();
1521 
1522  Array<OneD, NekDouble> coeff(n_coeffs);
1523  Array<OneD, NekDouble> coeff_tmp(n_coeffs, 0.0);
1524  Array<OneD, NekDouble> tmp;
1525  Array<OneD, NekDouble> tmp2;
1526 
1527  int nmodes0 = m_base[0]->GetNumModes();
1528  int nmodes1 = m_base[1]->GetNumModes();
1529  int numMax = nmodes0;
1530 
1531  Vmath::Vcopy(n_coeffs, inarray, 1, coeff_tmp, 1);
1532 
1533  const LibUtilities::PointsKey Pkey0(nmodes0,
1534  LibUtilities::eGaussLobattoLegendre);
1535  const LibUtilities::PointsKey Pkey1(nmodes1,
1536  LibUtilities::eGaussLobattoLegendre);
1537 
1538  LibUtilities::BasisKey b0(m_base[0]->GetBasisType(), nmodes0, Pkey0);
1539  LibUtilities::BasisKey b1(m_base[1]->GetBasisType(), nmodes1, Pkey1);
1540 
1541  LibUtilities::BasisKey bortho0(LibUtilities::eOrtho_A, nmodes0, Pkey0);
1542  LibUtilities::BasisKey bortho1(LibUtilities::eOrtho_A, nmodes1, Pkey1);
1543 
1544  LibUtilities::InterpCoeff2D(b0, b1, coeff_tmp, bortho0, bortho1, coeff);
1545 
1546  Vmath::Zero(n_coeffs, coeff_tmp, 1);
1547 
1548  int cnt = 0;
1549  for (int i = 0; i < numMin + 1; ++i)
1550  {
1551  Vmath::Vcopy(numMin, tmp = coeff + cnt, 1, tmp2 = coeff_tmp + cnt, 1);
1552 
1553  cnt = i * numMax;
1554  }
1555 
1556  LibUtilities::InterpCoeff2D(bortho0, bortho1, coeff_tmp, b0, b1, outarray);
1557 }
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:71
Nektar::LibUtilities::eGaussLobattoLegendre
@ eGaussLobattoLegendre
1D Gauss-Lobatto-Legendre quadrature points
Definition: PointsType.h:53
Vmath::Zero
void Zero(int n, T *x, const int incx)
Zero vector.
Definition: Vmath.cpp:492

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_StdPhysDeriv() [1/2]

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 128 of file StdQuadExp.cpp.

132 {
133  boost::ignore_unused(out_d2);
134  // PhysTensorDeriv(inarray, out_d0, out_d1);
135  StdQuadExp::v_PhysDeriv(inarray, out_d0, out_d1);
136 }
Nektar::StdRegions::StdQuadExp::v_PhysDeriv
void v_PhysDeriv(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_d0, Array< OneD, NekDouble > &out_d1, Array< OneD, NekDouble > &out_d2=NullNekDouble1DArray) override
Calculate the derivative of the physical points.
Definition: StdQuadExp.cpp:95

References v_PhysDeriv().

◆ v_StdPhysDeriv() [2/2]

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Definition at line 138 of file StdQuadExp.cpp.

141 {
142  // PhysTensorDeriv(inarray, outarray);
143  StdQuadExp::v_PhysDeriv(dir, inarray, outarray);
144 }

References v_PhysDeriv().

◆ v_SVVLaplacianFilter()

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::LocalRegions::QuadExp.

Definition at line 1363 of file StdQuadExp.cpp.

1365 {
1366  // Generate an orthonogal expansion
1367  int qa = m_base[0]->GetNumPoints();
1368  int qb = m_base[1]->GetNumPoints();
1369  int nmodes_a = m_base[0]->GetNumModes();
1370  int nmodes_b = m_base[1]->GetNumModes();
1371  int nmodes = min(nmodes_a, nmodes_b);
1372  // Declare orthogonal basis.
1373  LibUtilities::PointsKey pa(qa, m_base[0]->GetPointsType());
1374  LibUtilities::PointsKey pb(qb, m_base[1]->GetPointsType());
1375 
1376  LibUtilities::BasisKey Ba(LibUtilities::eOrtho_A, nmodes_a, pa);
1377  LibUtilities::BasisKey Bb(LibUtilities::eOrtho_A, nmodes_b, pb);
1378  StdQuadExp OrthoExp(Ba, Bb);
1379 
1380  // SVV parameters loaded from the .xml case file
1381  Array<OneD, NekDouble> orthocoeffs(OrthoExp.GetNcoeffs());
1382 
1383  // project onto modal space.
1384  OrthoExp.FwdTrans(array, orthocoeffs);
1385 
1386  if (mkey.ConstFactorExists(
1387  eFactorSVVPowerKerDiffCoeff)) // Rodrigo's power kernel
1388  {
1389  NekDouble cutoff = mkey.GetConstFactor(eFactorSVVCutoffRatio);
1390  NekDouble SvvDiffCoeff =
1391  mkey.GetConstFactor(eFactorSVVPowerKerDiffCoeff) *
1392  mkey.GetConstFactor(eFactorSVVDiffCoeff);
1393 
1394  for (int j = 0; j < nmodes_a; ++j)
1395  {
1396  for (int k = 0; k < nmodes_b; ++k)
1397  {
1398  // linear space but makes high modes very negative
1399  NekDouble fac = std::max(
1400  pow((1.0 * j) / (nmodes_a - 1), cutoff * nmodes_a),
1401  pow((1.0 * k) / (nmodes_b - 1), cutoff * nmodes_b));
1402 
1403  orthocoeffs[j * nmodes_b + k] *= SvvDiffCoeff * fac;
1404  }
1405  }
1406  }
1407  else if (mkey.ConstFactorExists(
1408  eFactorSVVDGKerDiffCoeff)) // Rodrigo/mansoor's DG kernel
1409  {
1410  NekDouble SvvDiffCoeff = mkey.GetConstFactor(eFactorSVVDGKerDiffCoeff) *
1411  mkey.GetConstFactor(eFactorSVVDiffCoeff);
1412  int max_ab = max(nmodes_a - kSVVDGFiltermodesmin,
1413  nmodes_b - kSVVDGFiltermodesmin);
1414  max_ab = max(max_ab, 0);
1415  max_ab = min(max_ab, kSVVDGFiltermodesmax - kSVVDGFiltermodesmin);
1416 
1417  for (int j = 0; j < nmodes_a; ++j)
1418  {
1419  for (int k = 0; k < nmodes_b; ++k)
1420  {
1421  int maxjk = max(j, k);
1422  maxjk = min(maxjk, kSVVDGFiltermodesmax - 1);
1423 
1424  orthocoeffs[j * nmodes_b + k] *=
1425  SvvDiffCoeff * kSVVDGFilter[max_ab][maxjk];
1426  }
1427  }
1428  }
1429  else
1430  {
1431  NekDouble SvvDiffCoeff = mkey.GetConstFactor(eFactorSVVDiffCoeff);
1432  // Exponential Kernel implementation
1433  int cutoff = (int)(mkey.GetConstFactor(eFactorSVVCutoffRatio) *
1434  min(nmodes_a, nmodes_b));
1435 
1436  // counters for scanning through orthocoeffs array
1437  int cnt = 0;
1438 
1439  //------"New" Version August 22nd '13--------------------
1440  for (int j = 0; j < nmodes_a; ++j)
1441  {
1442  for (int k = 0; k < nmodes_b; ++k)
1443  {
1444  if (j + k >= cutoff) // to filter out only the "high-modes"
1445  {
1446  orthocoeffs[j * nmodes_b + k] *=
1447  (SvvDiffCoeff *
1448  exp(-(j + k - nmodes) * (j + k - nmodes) /
1449  ((NekDouble)((j + k - cutoff + 1) *
1450  (j + k - cutoff + 1)))));
1451  }
1452  else
1453  {
1454  orthocoeffs[j * nmodes_b + k] *= 0.0;
1455  }
1456  cnt++;
1457  }
1458  }
1459  }
1460 
1461  // backward transform to physical space
1462  OrthoExp.BwdTrans(orthocoeffs, array);
1463 }
Nektar::StdRegions::kSVVDGFiltermodesmin
const int kSVVDGFiltermodesmin
Definition: StdRegions.hpp:469
Nektar::StdRegions::kSVVDGFiltermodesmax
const int kSVVDGFiltermodesmax
Definition: StdRegions.hpp:470
Nektar::StdRegions::kSVVDGFilter
const NekDouble kSVVDGFilter[9][11]
Definition: StdRegions.hpp:472

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

◆ v_WeakDerivMatrixOp()

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

Reimplemented from Nektar::StdRegions::StdExpansion.

Reimplemented in Nektar::LocalRegions::QuadExp.

Definition at line 1580 of file StdQuadExp.cpp.

1583 {
1584  StdExpansion::WeakDerivMatrixOp_MatFree(i, inarray, outarray, mkey);
1585 }
Nektar::StdRegions::StdExpansion::WeakDerivMatrixOp_MatFree
void WeakDerivMatrixOp_MatFree(const int i, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey)
Definition: StdExpansion.cpp:820

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

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