#include <Expansion2D.h>
Inheritance diagram for Nektar::LocalRegions::Expansion2D:
Public Member Functions | |
| Expansion2D (SpatialDomains::Geometry2DSharedPtr pGeom) | |
| virtual | ~Expansion2D () override=default |
| DNekScalMatSharedPtr | CreateMatrix (const MatrixKey &mkey) |
| void | SetTraceToGeomOrientation (Array< OneD, ExpansionSharedPtr > &EdgeExp, Array< OneD, NekDouble > &inout) |
| Array< OneD, unsigned int > | GetTraceInverseBoundaryMap (int eid) |
| void | AddNormTraceInt (const int dir, Array< OneD, ExpansionSharedPtr > &EdgeExp, Array< OneD, Array< OneD, NekDouble > > &edgeCoeffs, Array< OneD, NekDouble > &outarray) |
| void | AddNormTraceInt (const int dir, Array< OneD, const NekDouble > &inarray, Array< OneD, ExpansionSharedPtr > &EdgeExp, Array< OneD, NekDouble > &outarray, const StdRegions::VarCoeffMap &varcoeffs) |
| void | AddEdgeBoundaryInt (const int edge, ExpansionSharedPtr &EdgeExp, Array< OneD, NekDouble > &edgePhys, Array< OneD, NekDouble > &outarray, const StdRegions::VarCoeffMap &varcoeffs=StdRegions::NullVarCoeffMap) |
| void | AddHDGHelmholtzEdgeTerms (const NekDouble tau, const int edge, Array< OneD, ExpansionSharedPtr > &EdgeExp, Array< OneD, NekDouble > &edgePhys, const StdRegions::VarCoeffMap &dirForcing, Array< OneD, NekDouble > &outarray) |
| void | AddHDGHelmholtzTraceTerms (const NekDouble tau, const Array< OneD, const NekDouble > &inarray, Array< OneD, ExpansionSharedPtr > &EdgeExp, const StdRegions::VarCoeffMap &dirForcing, Array< OneD, NekDouble > &outarray) |
| SpatialDomains::Geometry2DSharedPtr | GetGeom2D () const |
| void | ReOrientEdgePhysMap (const int nvert, const StdRegions::Orientation orient, const int nq0, Array< OneD, int > &idmap) |
| virtual DNekMatSharedPtr | v_GenMatrix (const StdRegions::StdMatrixKey &mkey) override |
| virtual void | v_GenTraceExp (const int traceid, ExpansionSharedPtr &exp) override |
 Public Member Functions inherited from Nektar::LocalRegions::Expansion | |
| Expansion (SpatialDomains::GeometrySharedPtr pGeom) | |
| Expansion (const Expansion &pSrc) | |
| virtual | ~Expansion () |
| void | SetTraceExp (const int traceid, ExpansionSharedPtr &f) |
| ExpansionSharedPtr | GetTraceExp (const int traceid) |
| DNekScalMatSharedPtr | GetLocMatrix (const LocalRegions::MatrixKey &mkey) |
| void | DropLocMatrix (const LocalRegions::MatrixKey &mkey) |
| DNekScalMatSharedPtr | GetLocMatrix (const StdRegions::MatrixType mtype, const StdRegions::ConstFactorMap &factors=StdRegions::NullConstFactorMap, const StdRegions::VarCoeffMap &varcoeffs=StdRegions::NullVarCoeffMap) |
| SpatialDomains::GeometrySharedPtr | GetGeom () const |
| void | Reset () |
| IndexMapValuesSharedPtr | CreateIndexMap (const IndexMapKey &ikey) |
| DNekScalBlkMatSharedPtr | CreateStaticCondMatrix (const MatrixKey &mkey) |
| const SpatialDomains::GeomFactorsSharedPtr & | GetMetricInfo () const |
| DNekMatSharedPtr | BuildTransformationMatrix (const DNekScalMatSharedPtr &r_bnd, const StdRegions::MatrixType matrixType) |
| DNekMatSharedPtr | BuildVertexMatrix (const DNekScalMatSharedPtr &r_bnd) |
| void | ExtractDataToCoeffs (const NekDouble *data, const std::vector< unsigned int > &nummodes, const int nmodes_offset, NekDouble *coeffs, std::vector< LibUtilities::BasisType > &fromType) |
| void | AddEdgeNormBoundaryInt (const int edge, const std::shared_ptr< Expansion > &EdgeExp, const Array< OneD, const NekDouble > &Fx, const Array< OneD, const NekDouble > &Fy, Array< OneD, NekDouble > &outarray) |
| void | AddEdgeNormBoundaryInt (const int edge, const std::shared_ptr< Expansion > &EdgeExp, const Array< OneD, const NekDouble > &Fn, Array< OneD, NekDouble > &outarray) |
| void | AddFaceNormBoundaryInt (const int face, const std::shared_ptr< Expansion > &FaceExp, const Array< OneD, const NekDouble > &Fn, Array< OneD, NekDouble > &outarray) |
| void | DGDeriv (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, ExpansionSharedPtr > &EdgeExp, Array< OneD, Array< OneD, NekDouble > > &coeffs, Array< OneD, NekDouble > &outarray) |
| NekDouble | VectorFlux (const Array< OneD, Array< OneD, NekDouble > > &vec) |
| void | NormalTraceDerivFactors (Array< OneD, Array< OneD, NekDouble > > &factors, Array< OneD, Array< OneD, NekDouble > > &d0factors, Array< OneD, Array< OneD, NekDouble > > &d1factors) |
| IndexMapValuesSharedPtr | GetIndexMap (const IndexMapKey &ikey) |
| void | AlignVectorToCollapsedDir (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray) |
| ExpansionSharedPtr | GetLeftAdjacentElementExp () const |
| ExpansionSharedPtr | GetRightAdjacentElementExp () const |
| int | GetLeftAdjacentElementTrace () const |
| int | GetRightAdjacentElementTrace () const |
| void | SetAdjacentElementExp (int traceid, ExpansionSharedPtr &e) |
| StdRegions::Orientation | GetTraceOrient (int trace) |
| void | SetCoeffsToOrientation (StdRegions::Orientation dir, Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) |
| void | DivideByQuadratureMetric (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) |
| Divided by the metric jacobi and quadrature weights. More... | |
| void | GetTraceQFactors (const int trace, Array< OneD, NekDouble > &outarray) |
| Extract the metric factors to compute the contravariant fluxes along edge edge and stores them into outarray following the local edge orientation (i.e. anticlockwise convention). More... | |
| void | GetTracePhysVals (const int trace, const StdRegions::StdExpansionSharedPtr &TraceExp, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, StdRegions::Orientation orient=StdRegions::eNoOrientation) |
| void | GetTracePhysMap (const int edge, Array< OneD, int > &outarray) |
| void | ReOrientTracePhysMap (const StdRegions::Orientation orient, Array< OneD, int > &idmap, const int nq0, const int nq1) |
| const NormalVector & | GetTraceNormal (const int id) |
| void | ComputeTraceNormal (const int id) |
| const Array< OneD, const NekDouble > & | GetPhysNormals (void) |
| void | SetPhysNormals (Array< OneD, const NekDouble > &normal) |
| void | SetUpPhysNormals (const int trace) |
| void | AddRobinMassMatrix (const int traceid, const Array< OneD, const NekDouble > &primCoeffs, DNekMatSharedPtr &inoutmat) |
| void | TraceNormLen (const int traceid, NekDouble &h, NekDouble &p) |
| void | AddRobinTraceContribution (const int traceid, const Array< OneD, const NekDouble > &primCoeffs, const Array< OneD, NekDouble > &incoeffs, Array< OneD, NekDouble > &coeffs) |
| const Array< OneD, const NekDouble > & | GetElmtBndNormDirElmtLen (const int nbnd) const |
| void | StdDerivBaseOnTraceMat (Array< OneD, DNekMatSharedPtr > &DerivMat) |
| Public Member Functions inherited from Nektar::StdRegions::StdExpansion | |
| StdExpansion () | |
| Default Constructor. More... | |
| StdExpansion (const int numcoeffs, const int numbases, const LibUtilities::BasisKey &Ba=LibUtilities::NullBasisKey, const LibUtilities::BasisKey &Bb=LibUtilities::NullBasisKey, const LibUtilities::BasisKey &Bc=LibUtilities::NullBasisKey) | |
| Constructor. More... | |
| StdExpansion (const StdExpansion &T) | |
| Copy Constructor. More... | |
| virtual | ~StdExpansion () |
| Destructor. More... | |
| int | GetNumBases () const |
| This function returns the number of 1D bases used in the expansion. More... | |
| const Array< OneD, const LibUtilities::BasisSharedPtr > & | GetBase () const |
| This function gets the shared point to basis. More... | |
| const LibUtilities::BasisSharedPtr & | GetBasis (int dir) const |
| This function gets the shared point to basis in the dir direction. More... | |
| int | GetNcoeffs (void) const |
| This function returns the total number of coefficients used in the expansion. More... | |
| int | GetTotPoints () const |
| This function returns the total number of quadrature points used in the element. More... | |
| LibUtilities::BasisType | GetBasisType (const int dir) const |
| This function returns the type of basis used in the dir direction. More... | |
| int | GetBasisNumModes (const int dir) const |
| This function returns the number of expansion modes in the dir direction. More... | |
| int | EvalBasisNumModesMax (void) const |
| This function returns the maximum number of expansion modes over all local directions. More... | |
| LibUtilities::PointsType | GetPointsType (const int dir) const |
| This function returns the type of quadrature points used in the dir direction. More... | |
| int | GetNumPoints (const int dir) const |
| This function returns the number of quadrature points in the dir direction. More... | |
| const Array< OneD, const NekDouble > & | GetPoints (const int dir) const |
| This function returns a pointer to the array containing the quadrature points in dir direction. More... | |
| int | GetNverts () const |
| This function returns the number of vertices of the expansion domain. More... | |
| int | GetTraceNcoeffs (const int i) const |
| This function returns the number of expansion coefficients belonging to the i-th trace. More... | |
| int | GetTraceIntNcoeffs (const int i) const |
| int | GetTraceNumPoints (const int i) const |
| This function returns the number of quadrature points belonging to the i-th trace. More... | |
| const LibUtilities::BasisKey | GetTraceBasisKey (const int i, int k=-1) const |
| This function returns the basis key belonging to the i-th trace. More... | |
| LibUtilities::PointsKey | GetTracePointsKey (const int i, int k=-1) const |
| This function returns the basis key belonging to the i-th trace. More... | |
| int | NumBndryCoeffs (void) const |
| int | NumDGBndryCoeffs (void) const |
| const LibUtilities::PointsKey | GetNodalPointsKey () const |
| This function returns the type of expansion Nodal point type if defined. More... | |
| int | GetNtraces () const |
| Returns the number of trace elements connected to this element. More... | |
| LibUtilities::ShapeType | DetShapeType () const |
| This function returns the shape of the expansion domain. More... | |
| std::shared_ptr< StdExpansion > | GetStdExp () const |
| std::shared_ptr< StdExpansion > | GetLinStdExp (void) const |
| int | GetShapeDimension () const |
| bool | IsBoundaryInteriorExpansion () const |
| bool | IsNodalNonTensorialExp () |
| void | BwdTrans (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) |
| This function performs the Backward transformation from coefficient space to physical space. More... | |
| void | FwdTrans (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) |
| This function performs the Forward transformation from physical space to coefficient space. More... | |
| void | FwdTransBndConstrained (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) |
| NekDouble | Integral (const Array< OneD, const NekDouble > &inarray) |
| This function integrates the specified function over the domain. More... | |
| void | FillMode (const int mode, Array< OneD, NekDouble > &outarray) |
| This function fills the array outarray with the mode-th mode of the expansion. More... | |
| void | IProductWRTBase (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) |
| this function calculates the inner product of a given function f with the different modes of the expansion More... | |
| void | IProductWRTBase (const Array< OneD, const NekDouble > &base, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, int coll_check) |
| void | IProductWRTDerivBase (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) |
| void | IProductWRTDirectionalDerivBase (const Array< OneD, const NekDouble > &direction, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) |
| int | GetElmtId () |
| Get the element id of this expansion when used in a list by returning value of m_elmt_id. More... | |
| void | SetElmtId (const int id) |
| Set the element id of this expansion when used in a list by returning value of m_elmt_id. More... | |
| void | GetCoords (Array< OneD, NekDouble > &coords_1, Array< OneD, NekDouble > &coords_2=NullNekDouble1DArray, Array< OneD, NekDouble > &coords_3=NullNekDouble1DArray) |
| this function returns the physical coordinates of the quadrature points of the expansion More... | |
| void | GetCoord (const Array< OneD, const NekDouble > &Lcoord, Array< OneD, NekDouble > &coord) |
| given the coordinates of a point of the element in the local collapsed coordinate system, this function calculates the physical coordinates of the point More... | |
| DNekMatSharedPtr | GetStdMatrix (const StdMatrixKey &mkey) |
| DNekBlkMatSharedPtr | GetStdStaticCondMatrix (const StdMatrixKey &mkey) |
| void | NormVectorIProductWRTBase (const Array< OneD, const NekDouble > &Fx, Array< OneD, NekDouble > &outarray) |
| void | NormVectorIProductWRTBase (const Array< OneD, const NekDouble > &Fx, const Array< OneD, NekDouble > &Fy, Array< OneD, NekDouble > &outarray) |
| void | NormVectorIProductWRTBase (const Array< OneD, const NekDouble > &Fx, const Array< OneD, const NekDouble > &Fy, const Array< OneD, const NekDouble > &Fz, Array< OneD, NekDouble > &outarray) |
| void | NormVectorIProductWRTBase (const Array< OneD, const Array< OneD, NekDouble > > &Fvec, Array< OneD, NekDouble > &outarray) |
| DNekScalBlkMatSharedPtr | GetLocStaticCondMatrix (const LocalRegions::MatrixKey &mkey) |
| void | DropLocStaticCondMatrix (const LocalRegions::MatrixKey &mkey) |
| int | CalcNumberOfCoefficients (const std::vector< unsigned int > &nummodes, int &modes_offset) |
| NekDouble | StdPhysEvaluate (const Array< OneD, const NekDouble > &Lcoord, const Array< OneD, const NekDouble > &physvals) |
| int | GetCoordim () |
| void | GetBoundaryMap (Array< OneD, unsigned int > &outarray) |
| void | GetInteriorMap (Array< OneD, unsigned int > &outarray) |
| int | GetVertexMap (const int localVertexId, bool useCoeffPacking=false) |
| void | GetTraceToElementMap (const int tid, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray, Orientation traceOrient=eForwards, int P=-1, int Q=-1) |
| void | GetTraceCoeffMap (const unsigned int traceid, Array< OneD, unsigned int > &maparray) |
| void | GetElmtTraceToTraceMap (const unsigned int tid, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray, Orientation traceOrient=eForwards, int P=-1, int Q=-1) |
| void | GetTraceInteriorToElementMap (const int tid, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray, const Orientation traceOrient=eForwards) |
| void | GetTraceNumModes (const int tid, int &numModes0, int &numModes1, const Orientation traceOrient=eDir1FwdDir1_Dir2FwdDir2) |
| void | MultiplyByQuadratureMetric (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) |
| void | MultiplyByStdQuadratureMetric (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) |
| DNekMatSharedPtr | CreateGeneralMatrix (const StdMatrixKey &mkey) |
| this function generates the mass matrix \(\mathbf{M}[i][j] =
\int \phi_i(\mathbf{x}) \phi_j(\mathbf{x}) d\mathbf{x}\) More... | |
| void | GeneralMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey) |
| void | MassMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey) |
| void | LaplacianMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey) |
| void | ReduceOrderCoeffs (int numMin, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) |
| void | SVVLaplacianFilter (Array< OneD, NekDouble > &array, const StdMatrixKey &mkey) |
| void | ExponentialFilter (Array< OneD, NekDouble > &array, const NekDouble alpha, const NekDouble exponent, const NekDouble cutoff) |
| void | LaplacianMatrixOp (const int k1, const int k2, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey) |
| void | WeakDerivMatrixOp (const int i, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey) |
| void | WeakDirectionalDerivMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey) |
| void | MassLevelCurvatureMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey) |
| void | LinearAdvectionMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey) |
| void | LinearAdvectionDiffusionReactionMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey, bool addDiffusionTerm=true) |
| void | HelmholtzMatrixOp (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey) |
| DNekMatSharedPtr | GenMatrix (const StdMatrixKey &mkey) |
| void | PhysDeriv (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_d0, Array< OneD, NekDouble > &out_d1=NullNekDouble1DArray, Array< OneD, NekDouble > &out_d2=NullNekDouble1DArray) |
| void | PhysDeriv (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) |
| void | PhysDeriv_s (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_ds) |
| void | PhysDeriv_n (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_dn) |
| void | PhysDirectionalDeriv (const Array< OneD, const NekDouble > &inarray, const Array< OneD, const NekDouble > &direction, Array< OneD, NekDouble > &outarray) |
| void | StdPhysDeriv (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_d0, Array< OneD, NekDouble > &out_d1=NullNekDouble1DArray, Array< OneD, NekDouble > &out_d2=NullNekDouble1DArray) |
| void | StdPhysDeriv (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) |
| NekDouble | PhysEvaluate (const Array< OneD, const NekDouble > &coords, const Array< OneD, const NekDouble > &physvals) |
| This function evaluates the expansion at a single (arbitrary) point of the domain. More... | |
| NekDouble | PhysEvaluate (const Array< OneD, NekDouble > &coord, const Array< OneD, const NekDouble > &inarray, std::array< NekDouble, 3 > &firstOrderDerivs) |
| This function evaluates the first derivative of the expansion at a single (arbitrary) point of the domain. More... | |
| NekDouble | PhysEvaluate (const Array< OneD, NekDouble > &coord, const Array< OneD, const NekDouble > &inarray, std::array< NekDouble, 3 > &firstOrderDerivs, std::array< NekDouble, 6 > &secondOrderDerivs) |
| NekDouble | PhysEvaluate (const Array< OneD, DNekMatSharedPtr > &I, const Array< OneD, const NekDouble > &physvals) |
| This function evaluates the expansion at a single (arbitrary) point of the domain. More... | |
| NekDouble | PhysEvaluateBasis (const Array< OneD, const NekDouble > &coords, int mode) |
This function evaluates the basis function mode mode at a point coords of the domain. More... | |
| void | LocCoordToLocCollapsed (const Array< OneD, const NekDouble > &xi, Array< OneD, NekDouble > &eta) |
| Convert local cartesian coordinate xi into local collapsed coordinates eta. More... | |
| void | LocCollapsedToLocCoord (const Array< OneD, const NekDouble > &eta, Array< OneD, NekDouble > &xi) |
| Convert local collapsed coordinates eta into local cartesian coordinate xi. More... | |
| virtual int | v_CalcNumberOfCoefficients (const std::vector< unsigned int > &nummodes, int &modes_offset) |
| virtual void | v_NormVectorIProductWRTBase (const Array< OneD, const NekDouble > &Fx, Array< OneD, NekDouble > &outarray) |
| virtual void | v_NormVectorIProductWRTBase (const Array< OneD, const NekDouble > &Fx, const Array< OneD, const NekDouble > &Fy, Array< OneD, NekDouble > &outarray) |
| virtual void | v_NormVectorIProductWRTBase (const Array< OneD, const NekDouble > &Fx, const Array< OneD, const NekDouble > &Fy, const Array< OneD, const NekDouble > &Fz, Array< OneD, NekDouble > &outarray) |
| virtual void | v_NormVectorIProductWRTBase (const Array< OneD, const Array< OneD, NekDouble > > &Fvec, Array< OneD, NekDouble > &outarray) |
| virtual DNekScalBlkMatSharedPtr | v_GetLocStaticCondMatrix (const LocalRegions::MatrixKey &mkey) |
| virtual void | v_DropLocStaticCondMatrix (const LocalRegions::MatrixKey &mkey) |
| NekDouble | Linf (const Array< OneD, const NekDouble > &phys, const Array< OneD, const NekDouble > &sol=NullNekDouble1DArray) |
| Function to evaluate the discrete \( L_\infty\) error \( |\epsilon|_\infty = \max |u - u_{exact}|\) where \(
u_{exact}\) is given by the array sol. More... | |
| NekDouble | L2 (const Array< OneD, const NekDouble > &phys, const Array< OneD, const NekDouble > &sol=NullNekDouble1DArray) |
| Function to evaluate the discrete \( L_2\) error, \( | \epsilon |_{2} = \left [ \int^1_{-1} [u - u_{exact}]^2
dx \right]^{1/2} d\xi_1 \) where \( u_{exact}\) is given by the array sol. More... | |
| NekDouble | H1 (const Array< OneD, const NekDouble > &phys, const Array< OneD, const NekDouble > &sol=NullNekDouble1DArray) |
| Function to evaluate the discrete \( H^1\) error, \( | \epsilon |^1_{2} = \left [ \int^1_{-1} [u -
u_{exact}]^2 + \nabla(u - u_{exact})\cdot\nabla(u -
u_{exact})\cdot dx \right]^{1/2} d\xi_1 \) where \(
u_{exact}\) is given by the array sol. More... | |
| const LibUtilities::PointsKeyVector | GetPointsKeys () const |
| DNekMatSharedPtr | BuildInverseTransformationMatrix (const DNekScalMatSharedPtr &m_transformationmatrix) |
| void | PhysInterpToSimplexEquiSpaced (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, int npset=-1) |
| This function performs an interpolation from the physical space points provided at input into an array of equispaced points which are not the collapsed coordinate. So for a tetrahedron you will only get a tetrahedral number of values. More... | |
| void | GetSimplexEquiSpacedConnectivity (Array< OneD, int > &conn, bool standard=true) |
| This function provides the connectivity of local simplices (triangles or tets) to connect the equispaced data points provided by PhysInterpToSimplexEquiSpaced. More... | |
| void | EquiSpacedToCoeffs (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) |
| This function performs a projection/interpolation from the equispaced points sometimes used in post-processing onto the coefficient space. More... | |
| template<class T > | |
| std::shared_ptr< T > | as () |
| void | IProductWRTBase_SumFac (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, bool multiplybyweights=true) |
| void | GenStdMatBwdDeriv (const int dir, DNekMatSharedPtr &mat) |
| Public Member Functions inherited from Nektar::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) |
Protected Member Functions | |
| virtual void | v_DGDeriv (const int dir, const Array< OneD, const NekDouble > &incoeffs, Array< OneD, ExpansionSharedPtr > &EdgeExp, Array< OneD, Array< OneD, NekDouble > > &edgeCoeffs, Array< OneD, NekDouble > &out_d) override |
| virtual void | v_AddEdgeNormBoundaryInt (const int edge, const ExpansionSharedPtr &EdgeExp, const Array< OneD, const NekDouble > &Fx, const Array< OneD, const NekDouble > &Fy, Array< OneD, NekDouble > &outarray) override |
| virtual void | v_AddEdgeNormBoundaryInt (const int edge, const ExpansionSharedPtr &EdgeExp, const Array< OneD, const NekDouble > &Fn, Array< OneD, NekDouble > &outarray) override |
| virtual void | v_AddRobinMassMatrix (const int edgeid, const Array< OneD, const NekDouble > &primCoeffs, DNekMatSharedPtr &inoutmat) override |
| virtual void | v_AddRobinTraceContribution (const int traceid, const Array< OneD, const NekDouble > &primCoeffs, const Array< OneD, NekDouble > &incoeffs, Array< OneD, NekDouble > &coeffs) override |
| virtual DNekMatSharedPtr | v_BuildVertexMatrix (const DNekScalMatSharedPtr &r_bnd) override |
| virtual void | v_ReOrientTracePhysMap (const StdRegions::Orientation orient, Array< OneD, int > &idmap, const int nq0, const int nq1) override |
| virtual void | v_SetUpPhysNormals (const int edge) override |
| virtual NekDouble | v_VectorFlux (const Array< OneD, Array< OneD, NekDouble > > &vec) override |
| virtual void | v_TraceNormLen (const int traceid, NekDouble &h, NekDouble &p) override |
| Protected Member Functions inherited from Nektar::LocalRegions::Expansion | |
| void | ComputeLaplacianMetric () |
| void | ComputeQuadratureMetric () |
| void | ComputeGmatcdotMF (const Array< TwoD, const NekDouble > &df, const Array< OneD, const NekDouble > &direction, Array< OneD, Array< OneD, NekDouble > > &dfdir) |
| Array< OneD, NekDouble > | GetMF (const int dir, const int shapedim, const StdRegions::VarCoeffMap &varcoeffs) |
| Array< OneD, NekDouble > | GetMFDiv (const int dir, const StdRegions::VarCoeffMap &varcoeffs) |
| Array< OneD, NekDouble > | GetMFMag (const int dir, const StdRegions::VarCoeffMap &varcoeffs) |
| virtual void | v_MultiplyByQuadratureMetric (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) override |
| virtual void | v_DivideByQuadratureMetric (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) |
| virtual void | v_ComputeLaplacianMetric () |
| virtual int | v_GetCoordim () const override |
| virtual void | v_GetCoords (Array< OneD, NekDouble > &coords_1, Array< OneD, NekDouble > &coords_2, Array< OneD, NekDouble > &coords_3) override |
| virtual DNekScalMatSharedPtr | v_GetLocMatrix (const LocalRegions::MatrixKey &mkey) |
| virtual void | v_DropLocMatrix (const LocalRegions::MatrixKey &mkey) |
| virtual DNekMatSharedPtr | v_BuildTransformationMatrix (const DNekScalMatSharedPtr &r_bnd, const StdRegions::MatrixType matrixType) |
| virtual DNekMatSharedPtr | v_BuildVertexMatrix (const DNekScalMatSharedPtr &r_bnd) |
| virtual void | v_ExtractDataToCoeffs (const NekDouble *data, const std::vector< unsigned int > &nummodes, const int nmodes_offset, NekDouble *coeffs, std::vector< LibUtilities::BasisType > &fromType) |
| virtual void | v_AddEdgeNormBoundaryInt (const int edge, const std::shared_ptr< Expansion > &EdgeExp, const Array< OneD, const NekDouble > &Fx, const Array< OneD, const NekDouble > &Fy, Array< OneD, NekDouble > &outarray) |
| virtual void | v_AddEdgeNormBoundaryInt (const int edge, const std::shared_ptr< Expansion > &EdgeExp, const Array< OneD, const NekDouble > &Fn, Array< OneD, NekDouble > &outarray) |
| virtual void | v_AddFaceNormBoundaryInt (const int face, const std::shared_ptr< Expansion > &FaceExp, const Array< OneD, const NekDouble > &Fn, Array< OneD, NekDouble > &outarray) |
| virtual void | v_DGDeriv (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, ExpansionSharedPtr > &EdgeExp, Array< OneD, Array< OneD, NekDouble > > &coeffs, Array< OneD, NekDouble > &outarray) |
| virtual NekDouble | v_VectorFlux (const Array< OneD, Array< OneD, NekDouble > > &vec) |
| virtual void | v_NormalTraceDerivFactors (Array< OneD, Array< OneD, NekDouble > > &factors, Array< OneD, Array< OneD, NekDouble > > &d0factors, Array< OneD, Array< OneD, NekDouble > > &d1factors) |
| virtual void | v_AlignVectorToCollapsedDir (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, Array< OneD, NekDouble > > &outarray) |
| virtual StdRegions::Orientation | v_GetTraceOrient (int trace) |
| virtual void | v_SetCoeffsToOrientation (StdRegions::Orientation dir, Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) override |
| virtual void | v_GetTraceQFactors (const int trace, Array< OneD, NekDouble > &outarray) |
| virtual void | v_GetTracePhysVals (const int trace, const StdRegions::StdExpansionSharedPtr &TraceExp, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, StdRegions::Orientation orient) |
| virtual void | v_GetTracePhysMap (const int edge, Array< OneD, int > &outarray) |
| virtual void | v_ReOrientTracePhysMap (const StdRegions::Orientation orient, Array< OneD, int > &idmap, const int nq0, const int nq1=-1) |
| virtual void | v_ComputeTraceNormal (const int id) |
| virtual const Array< OneD, const NekDouble > & | v_GetPhysNormals () |
| virtual void | v_SetPhysNormals (Array< OneD, const NekDouble > &normal) |
| virtual void | v_SetUpPhysNormals (const int id) |
| virtual void | v_AddRobinMassMatrix (const int face, const Array< OneD, const NekDouble > &primCoeffs, DNekMatSharedPtr &inoutmat) |
| virtual void | v_AddRobinTraceContribution (const int traceid, const Array< OneD, const NekDouble > &primCoeffs, const Array< OneD, NekDouble > &incoeffs, Array< OneD, NekDouble > &coeffs) |
| virtual void | v_TraceNormLen (const int traceid, NekDouble &h, NekDouble &p) |
| virtual void | v_GenTraceExp (const int traceid, ExpansionSharedPtr &exp) |
| Protected Member Functions inherited from Nektar::StdRegions::StdExpansion | |
| DNekMatSharedPtr | CreateStdMatrix (const StdMatrixKey &mkey) |
| DNekBlkMatSharedPtr | CreateStdStaticCondMatrix (const StdMatrixKey &mkey) |
| Create the static condensation of a matrix when using a boundary interior decomposition. More... | |
| void | BwdTrans_SumFac (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) |
| void | IProductWRTDerivBase_SumFac (const int dir, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) |
| void | IProductWRTDirectionalDerivBase_SumFac (const Array< OneD, const NekDouble > &direction, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) |
| void | GeneralMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey) |
| void | MassMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey) |
| void | LaplacianMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey) |
| void | LaplacianMatrixOp_MatFree_Kernel (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, Array< OneD, NekDouble > &wsp) |
| void | LaplacianMatrixOp_MatFree_GenericImpl (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey) |
| void | LaplacianMatrixOp_MatFree (const int k1, const int k2, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey) |
| void | WeakDerivMatrixOp_MatFree (const int i, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey) |
| void | WeakDirectionalDerivMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey) |
| void | MassLevelCurvatureMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey) |
| void | LinearAdvectionMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey) |
| void | LinearAdvectionDiffusionReactionMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey, bool addDiffusionTerm=true) |
| void | HelmholtzMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey) |
| void | HelmholtzMatrixOp_MatFree_GenericImpl (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdMatrixKey &mkey) |
| virtual void | v_SetCoeffsToOrientation (StdRegions::Orientation dir, Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) |
| virtual void | v_SetCoeffsToOrientation (Array< OneD, NekDouble > &coeffs, StdRegions::Orientation dir) |
| virtual NekDouble | v_StdPhysEvaluate (const Array< OneD, const NekDouble > &Lcoord, const Array< OneD, const NekDouble > &physvals) |
| virtual void | v_GenStdMatBwdDeriv (const int dir, DNekMatSharedPtr &mat) |
| virtual void | v_MultiplyByStdQuadratureMetric (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray) |
| template<int DIR, bool DERIV = false, bool DERIV2 = false> | |
| NekDouble | BaryEvaluate (const NekDouble &coord, const NekDouble *physvals, NekDouble &deriv, NekDouble &deriv2) |
This function performs the barycentric interpolation of the polynomial stored in coord at a point physvals using barycentric interpolation weights in direction. More... | |
| template<int DIR> | |
| NekDouble | BaryEvaluateBasis (const NekDouble &coord, const int &mode) |
| template<int DIR, bool DERIV = false, bool DERIV2 = false> | |
| NekDouble | BaryEvaluate (const NekDouble &coord, const NekDouble *physvals) |
| Helper function to pass an unused value by reference into BaryEvaluate. More... | |
| template<int DIR, bool DERIV = false, bool DERIV2 = false> | |
| NekDouble | BaryEvaluate (const NekDouble &coord, const NekDouble *physvals, NekDouble &deriv) |
| Protected Member Functions inherited from Nektar::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 NekDouble | v_PhysEvaluate (const Array< OneD, NekDouble > &coord, const Array< OneD, const NekDouble > &inarray, std::array< NekDouble, 3 > &firstOrderDerivs) override |
| virtual void | v_BwdTrans_SumFacKernel (const Array< OneD, const NekDouble > &base0, const Array< OneD, const NekDouble > &base1, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, Array< OneD, NekDouble > &wsp, bool doCheckCollDir0, bool doCheckCollDir1)=0 |
| 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)=0 |
| virtual void | v_LaplacianMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey) override |
| virtual void | v_HelmholtzMatrixOp_MatFree (const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, const StdRegions::StdMatrixKey &mkey) override |
| virtual void | v_GetTraceCoeffMap (const unsigned int traceid, Array< OneD, unsigned int > &maparray) 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 |
Private Member Functions | |
| void | GetPhysEdgeVarCoeffsFromElement (const int edge, ExpansionSharedPtr &EdgeExp, const Array< OneD, const NekDouble > &varcoeff, Array< OneD, NekDouble > &outarray) |
| Array< OneD, NekDouble > | GetnEdgecdotMF (const int dir, const int edge, ExpansionSharedPtr &EdgeExp_e, const Array< OneD, const Array< OneD, NekDouble > > &normals, const StdRegions::VarCoeffMap &varcoeffs) |
Detailed Description
Definition at line 59 of file Expansion2D.h.
Constructor & Destructor Documentation
◆ Expansion2D()
| Nektar::LocalRegions::Expansion2D::Expansion2D | ( | SpatialDomains::Geometry2DSharedPtr | pGeom | ) |
Definition at line 54 of file Expansion2D.cpp.
56{
57}
Expansion(SpatialDomains::GeometrySharedPtr pGeom)
Definition: Expansion.cpp:47
◆ ~Expansion2D()
|
overridevirtualdefault |
Member Function Documentation
◆ AddEdgeBoundaryInt()
|
inline |
For a given edge add the \tilde{F}_1j contributions
@TODO Variable coeffs
Definition at line 1008 of file Expansion2D.cpp.
1013{
1014 int i;
1015 int order_e = EdgeExp->GetNcoeffs();
1016 int nquad_e = EdgeExp->GetNumPoints(0);
1017 Array<OneD, unsigned int> map;
1018 Array<OneD, int> sign;
1019 Array<OneD, NekDouble> coeff(order_e);
1020
1022
1024 StdRegions::eVarCoeffD11,
1025 StdRegions::eVarCoeffD22};
1026 StdRegions::VarCoeffMap::const_iterator x;
1027
1028 /// @TODO Variable coeffs
1029 if ((x = varcoeffs.find(VarCoeff[0])) != varcoeffs.end())
1030 {
1031 Array<OneD, NekDouble> work(nquad_e);
1032 GetPhysEdgeVarCoeffsFromElement(edge, EdgeExp, x->second.GetValue(),
1033 work);
1034 Vmath::Vmul(nquad_e, work, 1, edgePhys, 1, edgePhys, 1);
1035 }
1036
1037 EdgeExp->IProductWRTBase(edgePhys, coeff);
1038
1039 // add data to out array
1040 for (i = 0; i < order_e; ++i)
1041 {
1042 outarray[map[i]] += sign[i] * coeff[i];
1043 }
1044}
void GetPhysEdgeVarCoeffsFromElement(const int edge, ExpansionSharedPtr &EdgeExp, const Array< OneD, const NekDouble > &varcoeff, Array< OneD, NekDouble > &outarray)
Definition: Expansion2D.cpp:1226
virtual StdRegions::Orientation v_GetTraceOrient(int trace)
Definition: Expansion.cpp:817
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
void Vmul(int n, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
Multiply vector z = x*y.
Definition: Vmath.cpp:207
References Nektar::StdRegions::eVarCoeffD00, Nektar::StdRegions::eVarCoeffD11, Nektar::StdRegions::eVarCoeffD22, GetPhysEdgeVarCoeffsFromElement(), Nektar::StdRegions::StdExpansion::GetTraceToElementMap(), sign, Nektar::LocalRegions::Expansion::v_GetTraceOrient(), and Vmath::Vmul().
Referenced by AddNormTraceInt().
◆ AddHDGHelmholtzEdgeTerms()
|
inline |
@TODO: What direction to use here??
@TODO: Document this (probably not needed)
Definition at line 1079 of file Expansion2D.cpp.
1083{
1085 int i, j, n;
1086 int nquad_e = EdgeExp[edge]->GetNumPoints(0);
1087 int order_e = EdgeExp[edge]->GetNcoeffs();
1090
1091 Array<OneD, NekDouble> inval(nquad_e);
1092 Array<OneD, NekDouble> outcoeff(order_e);
1093 Array<OneD, NekDouble> tmpcoeff(ncoeffs);
1094
1095 const Array<OneD, const Array<OneD, NekDouble>> &normals =
1096 GetTraceNormal(edge);
1097
1098 Array<OneD, unsigned int> emap;
1099 Array<OneD, int> sign;
1100
1102
1105
1107
1109 StdRegions::eWeakDeriv1,
1110 StdRegions::eWeakDeriv2};
1111
1113 StdRegions::eVarCoeffD11,
1114 StdRegions::eVarCoeffD22};
1115
1116 StdRegions::VarCoeffMap::const_iterator x;
1117 /// @TODO: What direction to use here??
1118 if ((x = varcoeffs.find(VarCoeff[0])) != varcoeffs.end())
1119 {
1120 Array<OneD, NekDouble> work(nquad_e);
1121 GetPhysEdgeVarCoeffsFromElement(edge, EdgeExp[edge],
1122 x->second.GetValue(), work);
1123 Vmath::Vmul(nquad_e, work, 1, edgePhys, 1, edgePhys, 1);
1124 }
1125
1126 //================================================================
1127 // Add F = \tau <phi_i,in_phys>
1128 // Fill edge and take inner product
1129 EdgeExp[edge]->IProductWRTBase(edgePhys, outcoeff);
1130 // add data to out array
1131 for (i = 0; i < order_e; ++i)
1132 {
1133 outarray[emap[i]] += sign[i] * tau * outcoeff[i];
1134 }
1135 //================================================================
1136
1137 //===============================================================
1138 // Add -\sum_i D_i^T M^{-1} G_i + E_i M^{-1} G_i =
1139 // \sum_i D_i M^{-1} G_i term
1140
1141 // Two independent direction
1142 DNekScalMatSharedPtr invMass;
1143 for (n = 0; n < coordim; ++n)
1144 {
1145 if (mmf)
1146 {
1147 StdRegions::VarCoeffMap Weight;
1149
1151 StdRegions::NullConstFactorMap, Weight);
1152
1153 invMass = GetLocMatrix(invMasskey);
1154
1155 Array<OneD, NekDouble> ncdotMF_e =
1156 GetnEdgecdotMF(n, edge, EdgeExp[edge], normals, varcoeffs);
1157
1158 Vmath::Vmul(nquad_e, ncdotMF_e, 1, edgePhys, 1, inval, 1);
1159 }
1160 else
1161 {
1162 Vmath::Vmul(nquad_e, normals[n], 1, edgePhys, 1, inval, 1);
1164 }
1165
1166 // Multiply by variable coefficient
1167 /// @TODO: Document this (probably not needed)
1168 // StdRegions::VarCoeffMap::const_iterator x;
1169 // if ((x = varcoeffs.find(VarCoeff[n])) !=
1170 // varcoeffs.end())
1171 // {
1172 // GetPhysEdgeVarCoeffsFromElement(edge,EdgeExp[edge],x->second,varcoeff_work);
1173 // Vmath::Vmul(nquad_e,varcoeff_work,1,EdgeExp[edge]->GetPhys(),1,EdgeExp[edge]->UpdatePhys(),1);
1174 // }
1175
1176 EdgeExp[edge]->IProductWRTBase(inval, outcoeff);
1177
1178 // M^{-1} G
1179 for (i = 0; i < ncoeffs; ++i)
1180 {
1181 tmpcoeff[i] = 0;
1182 for (j = 0; j < order_e; ++j)
1183 {
1184 tmpcoeff[i] += (*invMass)(i, emap[j]) * sign[j] * outcoeff[j];
1185 }
1186 }
1187
1188 if (mmf)
1189 {
1190 StdRegions::VarCoeffMap VarCoeffDirDeriv;
1191 VarCoeffDirDeriv[StdRegions::eVarCoeffMF] =
1192 GetMF(n, coordim, varcoeffs);
1193 VarCoeffDirDeriv[StdRegions::eVarCoeffMFDiv] =
1194 GetMFDiv(n, varcoeffs);
1195
1198 VarCoeffDirDeriv);
1199
1201
1202 Coeffs = Coeffs + Dmat * Tmpcoeff;
1203 }
1204 else
1205 {
1206 if (varcoeffs.find(VarCoeff[n]) != varcoeffs.end())
1207 {
1209 StdRegions::NullConstFactorMap, varcoeffs);
1210
1212 Coeffs = Coeffs + Dmat * Tmpcoeff;
1213 }
1214 else
1215 {
1217 Coeffs = Coeffs + Dmat * Tmpcoeff;
1218 }
1219 }
1220 }
1221}
Array< OneD, NekDouble > GetnEdgecdotMF(const int dir, const int edge, ExpansionSharedPtr &EdgeExp_e, const Array< OneD, const Array< OneD, NekDouble > > &normals, const StdRegions::VarCoeffMap &varcoeffs)
Definition: Expansion2D.cpp:2271
Array< OneD, NekDouble > GetMFMag(const int dir, const StdRegions::VarCoeffMap &varcoeffs)
Definition: Expansion.cpp:714
StdRegions::Orientation GetTraceOrient(int trace)
Definition: Expansion.h:170
DNekScalMatSharedPtr GetLocMatrix(const LocalRegions::MatrixKey &mkey)
Definition: Expansion.cpp:88
Array< OneD, NekDouble > GetMFDiv(const int dir, const StdRegions::VarCoeffMap &varcoeffs)
Definition: Expansion.cpp:691
const NormalVector & GetTraceNormal(const int id)
Definition: Expansion.cpp:255
Array< OneD, NekDouble > GetMF(const int dir, const int shapedim, const StdRegions::VarCoeffMap &varcoeffs)
Definition: Expansion.cpp:638
int GetNcoeffs(void) const
This function returns the total number of coefficients used in the expansion.
Definition: StdExpansion.h:130
LibUtilities::ShapeType DetShapeType() const
This function returns the shape of the expansion domain.
Definition: StdExpansion.h:373
static ConstFactorMap NullConstFactorMap
Definition: StdRegions.hpp:409
std::map< StdRegions::VarCoeffType, VarCoeffEntry > VarCoeffMap
Definition: StdRegions.hpp:352
NekMatrix< NekMatrix< NekDouble, StandardMatrixTag >, ScaledMatrixTag > DNekScalMat
Definition: NekMatrixFwd.hpp:67
std::shared_ptr< DNekScalMat > DNekScalMatSharedPtr
Definition: NekMatrixFwd.hpp:68
References Nektar::StdRegions::StdExpansion::DetShapeType(), Nektar::StdRegions::eInvMass, Nektar::StdRegions::eVarCoeffD00, Nektar::StdRegions::eVarCoeffD11, Nektar::StdRegions::eVarCoeffD22, Nektar::StdRegions::eVarCoeffMass, Nektar::StdRegions::eVarCoeffMF, Nektar::StdRegions::eVarCoeffMF1x, Nektar::StdRegions::eVarCoeffMFDiv, Nektar::StdRegions::eWeakDeriv0, Nektar::StdRegions::eWeakDeriv1, Nektar::StdRegions::eWeakDeriv2, Nektar::StdRegions::eWeakDirectionalDeriv, Nektar::eWrapper, Nektar::StdRegions::StdExpansion::GetCoordim(), Nektar::LocalRegions::Expansion::GetLocMatrix(), Nektar::LocalRegions::Expansion::GetMF(), Nektar::LocalRegions::Expansion::GetMFDiv(), Nektar::LocalRegions::Expansion::GetMFMag(), Nektar::StdRegions::StdExpansion::GetNcoeffs(), GetnEdgecdotMF(), GetPhysEdgeVarCoeffsFromElement(), Nektar::LocalRegions::Expansion::GetTraceNormal(), Nektar::LocalRegions::Expansion::GetTraceOrient(), Nektar::StdRegions::StdExpansion::GetTraceToElementMap(), Nektar::StdRegions::NullConstFactorMap, sign, and Vmath::Vmul().
Referenced by AddHDGHelmholtzTraceTerms().
◆ AddHDGHelmholtzTraceTerms()
|
inline |
Definition at line 1049 of file Expansion2D.cpp.
1053{
1054 ASSERTL0(&inarray[0] != &outarray[0],
1055 "Input and output arrays use the same memory");
1056
1058 Array<OneD, const NekDouble> tmp;
1059
1060 cnt = 0;
1061
1062 for (e = 0; e < nedges; ++e)
1063 {
1064 order_e = EdgeExp[e]->GetNcoeffs();
1065 Array<OneD, NekDouble> edgeCoeffs(order_e);
1066 Array<OneD, NekDouble> edgePhys(EdgeExp[e]->GetTotPoints());
1067
1068 Vmath::Vcopy(order_e, tmp = inarray + cnt, 1, edgeCoeffs, 1);
1069 EdgeExp[e]->BwdTrans(edgeCoeffs, edgePhys);
1070 AddHDGHelmholtzEdgeTerms(tau, e, EdgeExp, edgePhys, dirForcing,
1071 outarray);
1072
1073 cnt += order_e;
1074 }
1075}
void AddHDGHelmholtzEdgeTerms(const NekDouble tau, const int edge, Array< OneD, ExpansionSharedPtr > &EdgeExp, Array< OneD, NekDouble > &edgePhys, const StdRegions::VarCoeffMap &dirForcing, Array< OneD, NekDouble > &outarray)
Definition: Expansion2D.cpp:1079
int GetTotPoints() const
This function returns the total number of quadrature points used in the element.
Definition: StdExpansion.h:140
int GetNtraces() const
Returns the number of trace elements connected to this element.
Definition: StdExpansion.h:357
void Vcopy(int n, const T *x, const int incx, T *y, const int incy)
Definition: Vmath.cpp:1191
References AddHDGHelmholtzEdgeTerms(), ASSERTL0, Nektar::StdRegions::StdExpansion::GetNtraces(), Nektar::StdRegions::StdExpansion::GetTotPoints(), and Vmath::Vcopy().
Referenced by v_GenMatrix().
◆ AddNormTraceInt() [1/2]
|
inline |
Computes the C matrix entries due to the presence of the identity matrix in Eqn. 32.
@TODO: Document this
Definition at line 920 of file Expansion2D.cpp.
925{
926 int i, e, cnt;
927 int order_e, nquad_e;
929
930 cnt = 0;
931 for (e = 0; e < nedges; ++e)
932 {
933 order_e = EdgeExp[e]->GetNcoeffs();
934 nquad_e = EdgeExp[e]->GetNumPoints(0);
935
936 const Array<OneD, const Array<OneD, NekDouble>> &normals =
937 GetTraceNormal(e);
938 Array<OneD, NekDouble> edgeCoeffs(order_e);
939 Array<OneD, NekDouble> edgePhys(nquad_e);
940
941 for (i = 0; i < order_e; ++i)
942 {
943 edgeCoeffs[i] = inarray[i + cnt];
944 }
945 cnt += order_e;
946
947 EdgeExp[e]->BwdTrans(edgeCoeffs, edgePhys);
948
949 // Multiply by variable coefficient
950 /// @TODO: Document this
951 // StdRegions::VarCoeffType VarCoeff[3] = {StdRegions::eVarCoeffD00,
952 // StdRegions::eVarCoeffD11,
953 // StdRegions::eVarCoeffD22};
954 // StdRegions::VarCoeffMap::const_iterator x;
955 // Array<OneD, NekDouble> varcoeff_work(nquad_e);
956
957 // if ((x = varcoeffs.find(VarCoeff[dir])) != varcoeffs.end())
958 // {
959 // GetPhysEdgeVarCoeffsFromElement(e,EdgeExp[e],x->second,varcoeff_work);
960 // Vmath::Vmul(nquad_e,varcoeff_work,1,EdgeExp[e]->GetPhys(),1,EdgeExp[e]->UpdatePhys(),1);
961 // }
962
964 {
965 // MMF case
966 Array<OneD, NekDouble> ncdotMF_e =
967 GetnEdgecdotMF(dir, e, EdgeExp[e], normals, varcoeffs);
968
969 Vmath::Vmul(nquad_e, ncdotMF_e, 1, edgePhys, 1, edgePhys, 1);
970 }
971 else
972 {
973 Vmath::Vmul(nquad_e, normals[dir], 1, edgePhys, 1, edgePhys, 1);
974 }
975
976 AddEdgeBoundaryInt(e, EdgeExp[e], edgePhys, outarray, varcoeffs);
977 }
978}
void AddEdgeBoundaryInt(const int edge, ExpansionSharedPtr &EdgeExp, Array< OneD, NekDouble > &edgePhys, Array< OneD, NekDouble > &outarray, const StdRegions::VarCoeffMap &varcoeffs=StdRegions::NullVarCoeffMap)
Definition: Expansion2D.cpp:1008
References AddEdgeBoundaryInt(), Nektar::StdRegions::eVarCoeffMF1x, GetnEdgecdotMF(), Nektar::StdRegions::StdExpansion::GetNtraces(), Nektar::LocalRegions::Expansion::GetTraceNormal(), and Vmath::Vmul().
◆ AddNormTraceInt() [2/2]
|
inline |
Definition at line 980 of file Expansion2D.cpp.
984{
985 int e;
986 int nquad_e;
988
989 for (e = 0; e < nedges; ++e)
990 {
991 nquad_e = EdgeExp[e]->GetNumPoints(0);
992
993 Array<OneD, NekDouble> edgePhys(nquad_e);
994 const Array<OneD, const Array<OneD, NekDouble>> &normals =
995 GetTraceNormal(e);
996
997 EdgeExp[e]->BwdTrans(edgeCoeffs[e], edgePhys);
998
999 Vmath::Vmul(nquad_e, normals[dir], 1, edgePhys, 1, edgePhys, 1);
1000
1001 AddEdgeBoundaryInt(e, EdgeExp[e], edgePhys, outarray);
1002 }
1003}
References AddEdgeBoundaryInt(), Nektar::StdRegions::StdExpansion::GetNtraces(), Nektar::LocalRegions::Expansion::GetTraceNormal(), and Vmath::Vmul().
Referenced by v_DGDeriv(), and v_GenMatrix().
◆ CreateMatrix()
| DNekScalMatSharedPtr Nektar::LocalRegions::Expansion2D::CreateMatrix | ( | const MatrixKey & | mkey | ) |
Definition at line 59 of file Expansion2D.cpp.
60{
61 DNekScalMatSharedPtr returnval;
63
65 "Geometric information is not set up");
66
67 switch (mkey.GetMatrixType())
68 {
70 {
72 (mkey.HasVarCoeff(StdRegions::eVarCoeffMass)))
73 {
74 NekDouble one = 1.0;
76
77 returnval =
78 MemoryManager<DNekScalMat>::AllocateSharedPtr(one, mat);
79 }
80 else
81 {
84
85 returnval =
86 MemoryManager<DNekScalMat>::AllocateSharedPtr(jac, mat);
87 }
88 }
89 break;
91 {
92 MatrixKey masskey(mkey, StdRegions::eMass);
94
95 // Generate a local copy of traceMat
96 MatrixKey key(mkey, StdRegions::eNormDerivOnTrace);
98
100 "Need to specify eFactorGJP to construct "
101 "a HelmholtzGJP matrix");
102
104
105 factor /= MassMat.Scale();
106
107 int ntot = MassMat.GetRows() * MassMat.GetColumns();
108
109 Vmath::Svtvp(ntot, factor, &NDTraceMat->GetPtr()[0], 1,
110 MassMat.GetRawPtr(), 1, &NDTraceMat->GetPtr()[0], 1);
111
112 returnval = MemoryManager<DNekScalMat>::AllocateSharedPtr(
113 MassMat.Scale(), NDTraceMat);
114 }
115 break;
117 {
119 {
120 NekDouble one = 1.0;
121 StdRegions::StdMatrixKey masskey(StdRegions::eMass,
124 mat->Invert();
125
126 returnval =
127 MemoryManager<DNekScalMat>::AllocateSharedPtr(one, mat);
128 }
129 else
130 {
133
134 returnval =
135 MemoryManager<DNekScalMat>::AllocateSharedPtr(fac, mat);
136 }
137 }
138 break;
142 {
144 (mkey.HasVarCoeff(StdRegions::eVarCoeffLaplacian)) ||
145 (mkey.HasVarCoeff(StdRegions::eVarCoeffD00)) ||
146 (mkey.HasVarCoeff(StdRegions::eVarCoeffD01)) ||
147 (mkey.HasVarCoeff(StdRegions::eVarCoeffD02)) ||
148 (mkey.HasVarCoeff(StdRegions::eVarCoeffD11)) ||
149 (mkey.HasVarCoeff(StdRegions::eVarCoeffD12)) ||
150 (mkey.HasVarCoeff(StdRegions::eVarCoeffD22)))
151 {
152 NekDouble one = 1.0;
154
155 returnval =
156 MemoryManager<DNekScalMat>::AllocateSharedPtr(one, mat);
157 }
158 else
159 {
161 Array<TwoD, const NekDouble> df =
162 m_metricinfo->GetDerivFactors(ptsKeys);
163 int dir = 0;
165 dir = 0;
167 dir = 1;
169 dir = 2;
170
171 MatrixKey deriv0key(StdRegions::eWeakDeriv0,
172 mkey.GetShapeType(), *this);
173 MatrixKey deriv1key(StdRegions::eWeakDeriv1,
174 mkey.GetShapeType(), *this);
175
178
179 int rows = deriv0.GetRows();
180 int cols = deriv1.GetColumns();
181
182 DNekMatSharedPtr WeakDeriv =
183 MemoryManager<DNekMat>::AllocateSharedPtr(rows, cols);
184 (*WeakDeriv) =
185 df[2 * dir][0] * deriv0 + df[2 * dir + 1][0] * deriv1;
186
187 returnval = MemoryManager<DNekScalMat>::AllocateSharedPtr(
188 jac, WeakDeriv);
189 }
190 }
191 break;
193 {
195 mkey.GetNVarCoeff())
196 {
197 NekDouble one = 1.0;
199
200 returnval =
201 MemoryManager<DNekScalMat>::AllocateSharedPtr(one, mat);
202 }
203 else
204 {
205 int shapedim = 2;
206
207 // dfdirxi = tan_{xi_x} * d \xi/dx
208 // + tan_{xi_y} * d \xi/dy
209 // + tan_{xi_z} * d \xi/dz
210 // dfdireta = tan_{eta_x} * d \eta/dx
211 // + tan_{xi_y} * d \xi/dy
212 // + tan_{xi_z} * d \xi/dz
214 Array<TwoD, const NekDouble> df =
215 m_metricinfo->GetDerivFactors(ptsKeys);
216
217 Array<OneD, NekDouble> direction =
218 mkey.GetVarCoeff(StdRegions::eVarCoeffMF);
219
220 // d / dx = df[0]*deriv0 + df[1]*deriv1
221 // d / dy = df[2]*deriv0 + df[3]*deriv1
222 // d / dz = df[4]*deriv0 + df[5]*deriv1
223
224 // dfdir[dir] = e \cdot (d/dx, d/dy, d/dz)
225 // = (e^0 * df[0] + e^1 * df[2]
226 // + e^2 * df[4]) * deriv0
227 // + (e^0 * df[1] + e^1 * df[3]
228 // + e^2 * df[5]) * deriv1
229 // dfdir[dir] = e^0 * df[2 * 0 + dir]
230 // + e^1 * df[2 * 1 + dir]
231 // + e^2 * df [ 2 * 2 + dir]
232 Array<OneD, Array<OneD, NekDouble>> dfdir(shapedim);
233 Expansion::ComputeGmatcdotMF(df, direction, dfdir);
234
235 StdRegions::VarCoeffMap dfdirxi;
236 StdRegions::VarCoeffMap dfdireta;
237
238 dfdirxi[StdRegions::eVarCoeffWeakDeriv] = dfdir[0];
239 dfdireta[StdRegions::eVarCoeffWeakDeriv] = dfdir[1];
240
241 MatrixKey derivxikey(StdRegions::eWeakDeriv0,
242 mkey.GetShapeType(), *this,
243 StdRegions::NullConstFactorMap, dfdirxi);
244 MatrixKey derivetakey(StdRegions::eWeakDeriv1,
245 mkey.GetShapeType(), *this,
246 StdRegions::NullConstFactorMap, dfdireta);
247
250
251 int rows = derivxi.GetRows();
252 int cols = deriveta.GetColumns();
253
254 DNekMatSharedPtr WeakDirDeriv =
255 MemoryManager<DNekMat>::AllocateSharedPtr(rows, cols);
256
257 (*WeakDirDeriv) = derivxi + deriveta;
258
259 // Add (\nabla \cdot e^k ) Mass
260 StdRegions::VarCoeffMap DiveMass;
261 DiveMass[StdRegions::eVarCoeffMass] =
262 mkey.GetVarCoeff(StdRegions::eVarCoeffMFDiv);
263 StdRegions::StdMatrixKey stdmasskey(
265 StdRegions::NullConstFactorMap, DiveMass);
266
268
269 (*WeakDirDeriv) = (*WeakDirDeriv) + (*DiveMassmat);
270
271 returnval = MemoryManager<DNekScalMat>::AllocateSharedPtr(
272 jac, WeakDirDeriv);
273 }
274 break;
275 }
277 {
279 (mkey.HasVarCoeff(StdRegions::eVarCoeffLaplacian)) ||
280 (mkey.HasVarCoeff(StdRegions::eVarCoeffD00)) ||
281 (mkey.HasVarCoeff(StdRegions::eVarCoeffD01)) ||
282 (mkey.HasVarCoeff(StdRegions::eVarCoeffD10)) ||
283 (mkey.HasVarCoeff(StdRegions::eVarCoeffD02)) ||
284 (mkey.HasVarCoeff(StdRegions::eVarCoeffD20)) ||
285 (mkey.HasVarCoeff(StdRegions::eVarCoeffD11)) ||
286 (mkey.HasVarCoeff(StdRegions::eVarCoeffD12)) ||
287 (mkey.HasVarCoeff(StdRegions::eVarCoeffD21)) ||
288 (mkey.HasVarCoeff(StdRegions::eVarCoeffD22)) ||
289 (mkey.ConstFactorExists(StdRegions::eFactorSVVCutoffRatio)))
290 {
291 NekDouble one = 1.0;
293
294 returnval =
295 MemoryManager<DNekScalMat>::AllocateSharedPtr(one, mat);
296 }
297 else
298 {
299 MatrixKey lap00key(StdRegions::eLaplacian00,
300 mkey.GetShapeType(), *this);
301 MatrixKey lap01key(StdRegions::eLaplacian01,
302 mkey.GetShapeType(), *this);
303 MatrixKey lap11key(StdRegions::eLaplacian11,
304 mkey.GetShapeType(), *this);
305
309
311 Array<TwoD, const NekDouble> gmat =
312 m_metricinfo->GetGmat(ptsKeys);
313
314 int rows = lap00.GetRows();
315 int cols = lap00.GetColumns();
316
317 DNekMatSharedPtr lap =
318 MemoryManager<DNekMat>::AllocateSharedPtr(rows, cols);
319
320 (*lap) = gmat[0][0] * lap00 +
321 gmat[1][0] * (lap01 + Transpose(lap01)) +
322 gmat[3][0] * lap11;
323
324 returnval =
325 MemoryManager<DNekScalMat>::AllocateSharedPtr(jac, lap);
326 }
327 }
328 break;
330 {
332
333 returnval = MemoryManager<DNekScalMat>::AllocateSharedPtr(1.0, mat);
334 }
335 break;
337 {
339
340 MatrixKey masskey(mkey, StdRegions::eMass);
342
343 MatrixKey lapkey(mkey, StdRegions::eLaplacian);
345
346 int rows = LapMat.GetRows();
347 int cols = LapMat.GetColumns();
348
349 DNekMatSharedPtr helm =
350 MemoryManager<DNekMat>::AllocateSharedPtr(rows, cols);
351
352 NekDouble one = 1.0;
353 (*helm) = LapMat + factor * MassMat;
354
355 returnval =
356 MemoryManager<DNekScalMat>::AllocateSharedPtr(one, helm);
357 }
358 break;
360 {
361 MatrixKey helmkey(mkey, StdRegions::eHelmholtz);
363
364 // Generate a local copy of traceMat
365 MatrixKey key(mkey, StdRegions::eNormDerivOnTrace);
367
369 "Need to specify eFactorGJP to construct "
370 "a HelmholtzGJP matrix");
371
373
374 factor /= HelmMat.Scale();
375
376 int ntot = HelmMat.GetRows() * HelmMat.GetColumns();
377
378 Vmath::Svtvp(ntot, factor, &NDTraceMat->GetPtr()[0], 1,
379 HelmMat.GetRawPtr(), 1, &NDTraceMat->GetPtr()[0], 1);
380
381 returnval = MemoryManager<DNekScalMat>::AllocateSharedPtr(
382 HelmMat.Scale(), NDTraceMat);
383 }
384 break;
386 {
388
389 // Construct mass matrix (Check for varcoeffs)
392 {
393 masskey = MatrixKey(mkey, StdRegions::eMass);
394 }
396
397 // Construct laplacian matrix (Check for varcoeffs)
399 mkey.GetConstFactors());
401 (mkey.HasVarCoeff(StdRegions::eVarCoeffD00)) ||
402 (mkey.HasVarCoeff(StdRegions::eVarCoeffD01)) ||
403 (mkey.HasVarCoeff(StdRegions::eVarCoeffD10)) ||
404 (mkey.HasVarCoeff(StdRegions::eVarCoeffD02)) ||
405 (mkey.HasVarCoeff(StdRegions::eVarCoeffD20)) ||
406 (mkey.HasVarCoeff(StdRegions::eVarCoeffD11)) ||
407 (mkey.HasVarCoeff(StdRegions::eVarCoeffD12)) ||
408 (mkey.HasVarCoeff(StdRegions::eVarCoeffD21)) ||
409 (mkey.HasVarCoeff(StdRegions::eVarCoeffD22)))
410 {
411 lapkey = MatrixKey(mkey, StdRegions::eLaplacian);
412 }
414
415 // Construct advection matrix
416 // (assume advection velocity defined and non-zero)
417 // Could check L2(AdvectionVelocity) or HasVarCoeff
418 MatrixKey advkey(mkey, StdRegions::eLinearAdvection);
420
421 int rows = LapMat.GetRows();
422 int cols = LapMat.GetColumns();
423
424 DNekMatSharedPtr adr =
425 MemoryManager<DNekMat>::AllocateSharedPtr(rows, cols);
426
427 NekDouble one = 1.0;
428 (*adr) = LapMat - lambda * MassMat + AdvMat;
429
430 returnval = MemoryManager<DNekScalMat>::AllocateSharedPtr(one, adr);
431
432 // Clear memory (Repeat varcoeff checks)
433 DropLocMatrix(advkey);
435 {
436 DropLocMatrix(masskey);
437 }
439 (mkey.HasVarCoeff(StdRegions::eVarCoeffD00)) ||
440 (mkey.HasVarCoeff(StdRegions::eVarCoeffD01)) ||
441 (mkey.HasVarCoeff(StdRegions::eVarCoeffD10)) ||
442 (mkey.HasVarCoeff(StdRegions::eVarCoeffD02)) ||
443 (mkey.HasVarCoeff(StdRegions::eVarCoeffD20)) ||
444 (mkey.HasVarCoeff(StdRegions::eVarCoeffD11)) ||
445 (mkey.HasVarCoeff(StdRegions::eVarCoeffD12)) ||
446 (mkey.HasVarCoeff(StdRegions::eVarCoeffD21)) ||
447 (mkey.HasVarCoeff(StdRegions::eVarCoeffD22)))
448 {
449 DropLocMatrix(lapkey);
450 }
451 }
452 break;
454 {
455 // Copied mostly from ADR solve to have fine-grain control
456 // over updating only advection matrix, relevant for performance!
458
459 // Construct mass matrix (Check for varcoeffs)
462 {
463 masskey = MatrixKey(mkey, StdRegions::eMass);
464 }
466
467 // Construct laplacian matrix (Check for varcoeffs)
469 mkey.GetConstFactors());
471 (mkey.HasVarCoeff(StdRegions::eVarCoeffD00)) ||
472 (mkey.HasVarCoeff(StdRegions::eVarCoeffD01)) ||
473 (mkey.HasVarCoeff(StdRegions::eVarCoeffD10)) ||
474 (mkey.HasVarCoeff(StdRegions::eVarCoeffD02)) ||
475 (mkey.HasVarCoeff(StdRegions::eVarCoeffD20)) ||
476 (mkey.HasVarCoeff(StdRegions::eVarCoeffD11)) ||
477 (mkey.HasVarCoeff(StdRegions::eVarCoeffD12)) ||
478 (mkey.HasVarCoeff(StdRegions::eVarCoeffD21)) ||
479 (mkey.HasVarCoeff(StdRegions::eVarCoeffD22)))
480 {
481 lapkey = MatrixKey(mkey, StdRegions::eLaplacian);
482 }
484
485 // Construct advection matrix
486 // (assume advection velocity defined and non-zero)
487 // Could check L2(AdvectionVelocity) or HasVarCoeff
488 MatrixKey advkey(mkey, StdRegions::eLinearAdvection);
490
491 // Generate a local copy of traceMat
492 MatrixKey gjpkey(StdRegions::eNormDerivOnTrace, mkey.GetShapeType(),
493 *this, mkey.GetConstFactors());
495
498 "Need to specify eFactorGJP to construct "
499 "a LinearAdvectionDiffusionReactionGJP matrix");
500
501 int rows = LapMat.GetRows();
502 int cols = LapMat.GetColumns();
503
504 DNekMatSharedPtr adr =
505 MemoryManager<DNekMat>::AllocateSharedPtr(rows, cols);
506
507 NekDouble one = 1.0;
508 (*adr) =
509 LapMat - lambda * MassMat + AdvMat + gjpfactor * NDTraceMat;
510
511 returnval = MemoryManager<DNekScalMat>::AllocateSharedPtr(one, adr);
512
513 // Clear memory
514 DropLocMatrix(advkey);
516 {
517 DropLocMatrix(masskey);
518 }
520 (mkey.HasVarCoeff(StdRegions::eVarCoeffD00)) ||
521 (mkey.HasVarCoeff(StdRegions::eVarCoeffD01)) ||
522 (mkey.HasVarCoeff(StdRegions::eVarCoeffD10)) ||
523 (mkey.HasVarCoeff(StdRegions::eVarCoeffD02)) ||
524 (mkey.HasVarCoeff(StdRegions::eVarCoeffD20)) ||
525 (mkey.HasVarCoeff(StdRegions::eVarCoeffD11)) ||
526 (mkey.HasVarCoeff(StdRegions::eVarCoeffD12)) ||
527 (mkey.HasVarCoeff(StdRegions::eVarCoeffD21)) ||
528 (mkey.HasVarCoeff(StdRegions::eVarCoeffD22)))
529 {
530 DropLocMatrix(lapkey);
531 }
532 }
533 break;
535 {
536 NekDouble one = 1.0;
538
539 returnval = MemoryManager<DNekScalMat>::AllocateSharedPtr(one, mat);
540 }
541 break;
543 {
545 {
546 NekDouble one = 1.0;
548
549 returnval =
550 MemoryManager<DNekScalMat>::AllocateSharedPtr(one, mat);
551 }
552 else
553 {
556
557 returnval =
558 MemoryManager<DNekScalMat>::AllocateSharedPtr(jac, mat);
559 }
560 }
561 break;
565 {
567 {
568 NekDouble one = 1.0;
570
571 returnval =
572 MemoryManager<DNekScalMat>::AllocateSharedPtr(one, mat);
573 }
574 else
575 {
577
578 const Array<TwoD, const NekDouble> &df =
579 m_metricinfo->GetDerivFactors(ptsKeys);
580 int dir = 0;
582 dir = 0;
584 dir = 1;
586 dir = 2;
587
588 MatrixKey iProdDeriv0Key(StdRegions::eIProductWRTDerivBase0,
589 mkey.GetShapeType(), *this);
590 MatrixKey iProdDeriv1Key(StdRegions::eIProductWRTDerivBase1,
591 mkey.GetShapeType(), *this);
592
595
596 int rows = stdiprod0.GetRows();
597 int cols = stdiprod1.GetColumns();
598
599 DNekMatSharedPtr mat =
600 MemoryManager<DNekMat>::AllocateSharedPtr(rows, cols);
601 (*mat) =
602 df[2 * dir][0] * stdiprod0 + df[2 * dir + 1][0] * stdiprod1;
603
604 returnval =
605 MemoryManager<DNekScalMat>::AllocateSharedPtr(jac, mat);
606 }
607 }
608 break;
609
611 {
612 NekDouble one = 1.0;
613
615 *this, mkey.GetConstFactors(), mkey.GetVarCoeffs());
616
618
619 mat->Invert();
620
621 returnval = MemoryManager<DNekScalMat>::AllocateSharedPtr(one, mat);
622 }
623 break;
625 {
627 "Matrix only setup for quad elements currently");
628 DNekMatSharedPtr m_Ix;
629 Array<OneD, NekDouble> coords(1, 0.0);
632
633 coords[0] = (edge == 0 || edge == 3) ? -1.0 : 1.0;
634
635 m_Ix = m_base[(edge + 1) % 2]->GetI(coords);
636
637 returnval =
638 MemoryManager<DNekScalMat>::AllocateSharedPtr(1.0, m_Ix);
639 }
640 break;
642 {
643 NekDouble one = 1.0;
644 MatrixKey helmkey(StdRegions::eHelmholtz, mkey.GetShapeType(),
645 *this, mkey.GetConstFactors(),
646 mkey.GetVarCoeffs());
647 DNekScalBlkMatSharedPtr helmStatCond =
648 GetLocStaticCondMatrix(helmkey);
651
652 returnval = MemoryManager<DNekScalMat>::AllocateSharedPtr(one, R);
653 }
654 break;
655 default:
656 {
657 NekDouble one = 1.0;
659
660 returnval = MemoryManager<DNekScalMat>::AllocateSharedPtr(one, mat);
661 }
662 break;
663 }
664
665 return returnval;
666}
#define ASSERTL1(condition, msg)
Assert Level 1 – Debugging which is used whether in FULLDEBUG or DEBUG compilation mode....
Definition: ErrorUtil.hpp:249
#define ASSERTL2(condition, msg)
Assert Level 2 – Debugging which is used FULLDEBUG compilation mode. This level assert is designed to...
Definition: ErrorUtil.hpp:272
virtual DNekMatSharedPtr v_GenMatrix(const StdRegions::StdMatrixKey &mkey) override
Definition: Expansion2D.cpp:1259
void DropLocMatrix(const LocalRegions::MatrixKey &mkey)
Definition: Expansion.cpp:94
DNekMatSharedPtr BuildVertexMatrix(const DNekScalMatSharedPtr &r_bnd)
Definition: Expansion.cpp:105
void ComputeGmatcdotMF(const Array< TwoD, const NekDouble > &df, const Array< OneD, const NekDouble > &direction, Array< OneD, Array< OneD, NekDouble > > &dfdir)
Definition: Expansion.cpp:608
SpatialDomains::GeomFactorsSharedPtr m_metricinfo
Definition: Expansion.h:276
static std::shared_ptr< DataType > AllocateSharedPtr(const Args &...args)
Allocate a shared pointer from the memory pool.
Definition: NekMemoryManager.hpp:168
DNekMatSharedPtr GetStdMatrix(const StdMatrixKey &mkey)
Definition: StdExpansion.h:609
const LibUtilities::PointsKeyVector GetPointsKeys() const
Definition: StdExpansion.h:1101
DNekScalBlkMatSharedPtr GetLocStaticCondMatrix(const LocalRegions::MatrixKey &mkey)
Definition: StdExpansion.h:647
DNekMatSharedPtr GenMatrix(const StdMatrixKey &mkey)
Definition: StdExpansion.h:850
Array< OneD, LibUtilities::BasisSharedPtr > m_base
Definition: StdExpansion.h:1179
std::vector< PointsKey > PointsKeyVector
Definition: Points.h:236
@ eLinearAdvectionDiffusionReaction
Definition: StdRegions.hpp:110
@ eLinearAdvectionDiffusionReactionGJP
Definition: StdRegions.hpp:111
@ eInvLaplacianWithUnityMean
Definition: StdRegions.hpp:102
std::map< ConstFactorType, NekDouble > ConstFactorMap
Definition: StdRegions.hpp:408
StdRegions::ConstFactorMap factors
Definition: TestVarcoeffHashing.cpp:52
std::shared_ptr< DNekScalBlkMat > DNekScalBlkMatSharedPtr
Definition: NekTypeDefs.hpp:79
NekMatrix< InnerMatrixType, BlockMatrixTag > Transpose(NekMatrix< InnerMatrixType, BlockMatrixTag > &rhs)
Definition: BlockMatrix.hpp:235
void Svtvp(int n, const T alpha, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
svtvp (scalar times vector plus vector): z = alpha*x + y
Definition: Vmath.cpp:617
References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL1, ASSERTL2, Nektar::LocalRegions::Expansion::BuildVertexMatrix(), Nektar::LocalRegions::Expansion::ComputeGmatcdotMF(), Nektar::StdRegions::StdMatrixKey::ConstFactorExists(), Nektar::StdRegions::StdExpansion::DetShapeType(), Nektar::LocalRegions::Expansion::DropLocMatrix(), Nektar::SpatialDomains::eDeformed, Nektar::StdRegions::eFactorGaussEdge, Nektar::StdRegions::eFactorGJP, Nektar::StdRegions::eFactorLambda, Nektar::StdRegions::eFactorSVVCutoffRatio, Nektar::StdRegions::eHelmholtz, Nektar::StdRegions::eHelmholtzGJP, Nektar::StdRegions::eHybridDGHelmholtz, Nektar::StdRegions::eInterpGauss, Nektar::StdRegions::eInvHybridDGHelmholtz, Nektar::StdRegions::eInvLaplacianWithUnityMean, Nektar::StdRegions::eInvMass, Nektar::StdRegions::eIProductWRTBase, Nektar::StdRegions::eIProductWRTDerivBase0, Nektar::StdRegions::eIProductWRTDerivBase1, Nektar::StdRegions::eIProductWRTDerivBase2, Nektar::StdRegions::eLaplacian, Nektar::StdRegions::eLaplacian00, Nektar::StdRegions::eLaplacian01, Nektar::StdRegions::eLaplacian11, Nektar::StdRegions::eLinearAdvection, Nektar::StdRegions::eLinearAdvectionDiffusionReaction, Nektar::StdRegions::eLinearAdvectionDiffusionReactionGJP, Nektar::StdRegions::eMass, Nektar::StdRegions::eMassGJP, Nektar::SpatialDomains::eNoGeomType, Nektar::StdRegions::eNormDerivOnTrace, Nektar::StdRegions::ePreconLinearSpace, Nektar::LibUtilities::eQuadrilateral, Nektar::StdRegions::eVarCoeffD00, Nektar::StdRegions::eVarCoeffD01, Nektar::StdRegions::eVarCoeffD02, Nektar::StdRegions::eVarCoeffD10, Nektar::StdRegions::eVarCoeffD11, Nektar::StdRegions::eVarCoeffD12, Nektar::StdRegions::eVarCoeffD20, Nektar::StdRegions::eVarCoeffD21, Nektar::StdRegions::eVarCoeffD22, Nektar::StdRegions::eVarCoeffLaplacian, Nektar::StdRegions::eVarCoeffMass, Nektar::StdRegions::eVarCoeffMF, Nektar::StdRegions::eVarCoeffMFDiv, Nektar::StdRegions::eVarCoeffWeakDeriv, Nektar::StdRegions::eWeakDeriv0, Nektar::StdRegions::eWeakDeriv1, Nektar::StdRegions::eWeakDeriv2, Nektar::StdRegions::eWeakDirectionalDeriv, Nektar::VarcoeffHashingTest::factors, Nektar::StdRegions::StdExpansion::GenMatrix(), Nektar::StdRegions::StdMatrixKey::GetConstFactor(), Nektar::StdRegions::StdMatrixKey::GetConstFactors(), Nektar::LocalRegions::Expansion::GetLocMatrix(), Nektar::StdRegions::StdExpansion::GetLocStaticCondMatrix(), Nektar::StdRegions::StdMatrixKey::GetMatrixType(), Nektar::StdRegions::StdMatrixKey::GetNVarCoeff(), Nektar::StdRegions::StdExpansion::GetPointsKeys(), Nektar::StdRegions::StdMatrixKey::GetShapeType(), Nektar::StdRegions::StdExpansion::GetStdMatrix(), Nektar::StdRegions::StdMatrixKey::GetVarCoeff(), Nektar::StdRegions::StdMatrixKey::GetVarCoeffs(), Nektar::StdRegions::StdMatrixKey::HasVarCoeff(), Nektar::StdRegions::StdExpansion::m_base, Nektar::LocalRegions::Expansion::m_metricinfo, Nektar::StdRegions::NullConstFactorMap, Vmath::Svtvp(), Nektar::Transpose(), and v_GenMatrix().
◆ GetGeom2D()
|
inline |
Definition at line 172 of file Expansion2D.h.
References Nektar::LocalRegions::Expansion::m_geom.
Referenced by GetTraceInverseBoundaryMap(), Nektar::LocalRegions::QuadExp::v_FwdTransBndConstrained(), Nektar::LocalRegions::TriExp::v_FwdTransBndConstrained(), and Nektar::LocalRegions::TriExp::v_GetTraceOrient().
◆ GetnEdgecdotMF()
|
private |
Definition at line 2271 of file Expansion2D.cpp.
2275{
2276 int nquad_e = EdgeExp_e->GetNumPoints(0);
2280 int nqtot = nquad0 * nquad1;
2281
2282 StdRegions::VarCoeffType MMFCoeffs[15] = {
2290 StdRegions::eVarCoeffMF3Mag};
2291
2292 StdRegions::VarCoeffMap::const_iterator MFdir;
2293
2294 Array<OneD, NekDouble> ncdotMF(nqtot, 0.0);
2295 Array<OneD, NekDouble> tmp(nqtot);
2296 Array<OneD, NekDouble> tmp_e(nquad_e);
2297 for (int k = 0; k < coordim; k++)
2298 {
2299 MFdir = varcoeffs.find(MMFCoeffs[dir * 5 + k]);
2300 tmp = MFdir->second.GetValue();
2301
2302 GetPhysEdgeVarCoeffsFromElement(edge, EdgeExp_e, tmp, tmp_e);
2303
2304 Vmath::Vvtvp(nquad_e, &tmp_e[0], 1, &normals[k][0], 1, &ncdotMF[0], 1,
2305 &ncdotMF[0], 1);
2306 }
2307 return ncdotMF;
2308}
void Vvtvp(int n, const T *w, const int incw, const T *x, const int incx, const T *y, const int incy, T *z, const int incz)
vvtvp (vector times vector plus vector): z = w*x + y
Definition: Vmath.cpp:569
References Nektar::StdRegions::eVarCoeffMF1Div, Nektar::StdRegions::eVarCoeffMF1Mag, Nektar::StdRegions::eVarCoeffMF1x, Nektar::StdRegions::eVarCoeffMF1y, Nektar::StdRegions::eVarCoeffMF1z, Nektar::StdRegions::eVarCoeffMF2Div, Nektar::StdRegions::eVarCoeffMF2Mag, Nektar::StdRegions::eVarCoeffMF2x, Nektar::StdRegions::eVarCoeffMF2y, Nektar::StdRegions::eVarCoeffMF2z, Nektar::StdRegions::eVarCoeffMF3Div, Nektar::StdRegions::eVarCoeffMF3Mag, Nektar::StdRegions::eVarCoeffMF3x, Nektar::StdRegions::eVarCoeffMF3y, Nektar::StdRegions::eVarCoeffMF3z, Nektar::StdRegions::StdExpansion::GetCoordim(), GetPhysEdgeVarCoeffsFromElement(), Nektar::StdRegions::StdExpansion::m_base, and Vmath::Vvtvp().
Referenced by AddHDGHelmholtzEdgeTerms(), AddNormTraceInt(), and v_GenMatrix().
◆ GetPhysEdgeVarCoeffsFromElement()
|
private |
Extracts the variable coefficients along an edge
Definition at line 1226 of file Expansion2D.cpp.
1230{
1231 Array<OneD, NekDouble> tmp(GetNcoeffs());
1232 Array<OneD, NekDouble> edgetmp(EdgeExp->GetNcoeffs());
1233
1234 // FwdTrans varcoeffs
1235 FwdTrans(varcoeff, tmp);
1236
1237 // Map to edge
1238 Array<OneD, unsigned int> emap;
1239 Array<OneD, int> sign;
1242
1243 for (unsigned int i = 0; i < EdgeExp->GetNcoeffs(); ++i)
1244 {
1245 edgetmp[i] = tmp[emap[i]];
1246 }
1247
1248 // BwdTrans
1249 EdgeExp->BwdTrans(edgetmp, outarray);
1250}
void FwdTrans(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray)
This function performs the Forward transformation from physical space to coefficient space.
Definition: StdExpansion.h:1806
References Nektar::StdRegions::StdExpansion::FwdTrans(), Nektar::StdRegions::StdExpansion::GetNcoeffs(), Nektar::LocalRegions::Expansion::GetTraceOrient(), Nektar::StdRegions::StdExpansion::GetTraceToElementMap(), and sign.
Referenced by AddEdgeBoundaryInt(), AddHDGHelmholtzEdgeTerms(), GetnEdgecdotMF(), and v_GenMatrix().
◆ GetTraceInverseBoundaryMap()
| Array< OneD, unsigned int > Nektar::LocalRegions::Expansion2D::GetTraceInverseBoundaryMap | ( | int | eid | ) |
Definition at line 2193 of file Expansion2D.cpp.
2194{
2195 int n, j;
2196 int nEdgeCoeffs;
2198
2199 Array<OneD, unsigned int> bmap(nBndCoeffs);
2200 GetBoundaryMap(bmap);
2201
2202 // Map from full system to statically condensed system (i.e reverse
2203 // GetBoundaryMap)
2204 map<int, int> invmap;
2205 for (j = 0; j < nBndCoeffs; ++j)
2206 {
2207 invmap[bmap[j]] = j;
2208 }
2209
2210 // Number of interior edge coefficients
2211 nEdgeCoeffs = GetTraceNcoeffs(eid) - 2;
2212
2214
2215 Array<OneD, unsigned int> edgemaparray(nEdgeCoeffs);
2216 Array<OneD, unsigned int> maparray(nEdgeCoeffs);
2217 Array<OneD, int> signarray(nEdgeCoeffs, 1);
2218 StdRegions::Orientation eOrient = geom->GetEorient(eid);
2219
2220 // maparray is the location of the edge within the matrix
2221 GetTraceInteriorToElementMap(eid, maparray, signarray, eOrient);
2222
2223 for (n = 0; n < nEdgeCoeffs; ++n)
2224 {
2225 edgemaparray[n] = invmap[maparray[n]];
2226 }
2227
2228 return edgemaparray;
2229}
SpatialDomains::Geometry2DSharedPtr GetGeom2D() const
Definition: Expansion2D.h:172
void GetBoundaryMap(Array< OneD, unsigned int > &outarray)
Definition: StdExpansion.h:675
int NumBndryCoeffs(void) const
Definition: StdExpansion.h:328
void GetTraceInteriorToElementMap(const int tid, Array< OneD, unsigned int > &maparray, Array< OneD, int > &signarray, const Orientation traceOrient=eForwards)
Definition: StdExpansion.h:714
int GetTraceNcoeffs(const int i) const
This function returns the number of expansion coefficients belonging to the i-th trace.
Definition: StdExpansion.h:267
std::shared_ptr< Geometry2D > Geometry2DSharedPtr
Definition: Geometry.h:65
References Nektar::StdRegions::StdExpansion::GetBoundaryMap(), GetGeom2D(), Nektar::StdRegions::StdExpansion::GetTraceInteriorToElementMap(), Nektar::StdRegions::StdExpansion::GetTraceNcoeffs(), and Nektar::StdRegions::StdExpansion::NumBndryCoeffs().
◆ ReOrientEdgePhysMap()
| void Nektar::LocalRegions::Expansion2D::ReOrientEdgePhysMap | ( | const int | nvert, |
| const StdRegions::Orientation | orient, | ||
| const int | nq0, | ||
| Array< OneD, int > & | idmap | ||
| ) |
◆ SetTraceToGeomOrientation()
| void Nektar::LocalRegions::Expansion2D::SetTraceToGeomOrientation | ( | Array< OneD, ExpansionSharedPtr > & | EdgeExp, |
| Array< OneD, NekDouble > & | inout | ||
| ) |
Definition at line 901 of file Expansion2D.cpp.
903{
904 int i, cnt = 0;
906 Array<OneD, NekDouble> e_tmp;
907
908 for (i = 0; i < nedges; ++i)
909 {
910 EdgeExp[i]->SetCoeffsToOrientation(
911 GetTraceOrient(i), e_tmp = inout + cnt, e_tmp = inout + cnt);
912 cnt += GetTraceNcoeffs(i);
913 }
914}
References Nektar::StdRegions::StdExpansion::GetNtraces(), Nektar::StdRegions::StdExpansion::GetTraceNcoeffs(), and Nektar::LocalRegions::Expansion::GetTraceOrient().
Referenced by v_GenMatrix().
◆ v_AddEdgeNormBoundaryInt() [1/2]
|
overrideprotectedvirtual |
Definition at line 726 of file Expansion2D.cpp.
729{
730 int i;
731
733 {
735 m_requireNeg.resize(nedges);
736
737 for (i = 0; i < nedges; ++i)
738 {
740
742
743 if (edgeExp->GetRightAdjacentElementExp())
744 {
745 if (edgeExp->GetRightAdjacentElementExp()
746 ->GetGeom()
747 ->GetGlobalID() == GetGeom()->GetGlobalID())
748 {
750 }
751 }
752 }
753 }
754
757
759
760 // Order of the element
761 int order_e = map->size();
762 // Order of the trace
763 int n_coeffs = EdgeExp->GetNcoeffs();
764
765 Array<OneD, NekDouble> edgeCoeffs(n_coeffs);
766 if (n_coeffs != order_e) // Going to orthogonal space
767 {
768 EdgeExp->FwdTrans(Fn, edgeCoeffs);
769 Expansion1DSharedPtr locExp = EdgeExp->as<Expansion1D>();
770
772 {
773 Vmath::Neg(n_coeffs, edgeCoeffs, 1);
774 }
775
776 Array<OneD, NekDouble> coeff(n_coeffs, 0.0);
777 LibUtilities::BasisType btype =
779 LibUtilities::BasisKey bkey_ortho(btype,
780 EdgeExp->GetBasis(0)->GetNumModes(),
781 EdgeExp->GetBasis(0)->GetPointsKey());
782 LibUtilities::BasisKey bkey(EdgeExp->GetBasis(0)->GetBasisType(),
783 EdgeExp->GetBasis(0)->GetNumModes(),
784 EdgeExp->GetBasis(0)->GetPointsKey());
785 LibUtilities::InterpCoeff1D(bkey, edgeCoeffs, bkey_ortho, coeff);
786
787 // Cutting high frequencies
788 for (i = order_e; i < n_coeffs; i++)
789 {
790 coeff[i] = 0.0;
791 }
792
793 LibUtilities::InterpCoeff1D(bkey_ortho, coeff, bkey, edgeCoeffs);
794
795 StdRegions::StdMatrixKey masskey(StdRegions::eMass,
796 LibUtilities::eSegment, *EdgeExp);
797 EdgeExp->MassMatrixOp(edgeCoeffs, edgeCoeffs, masskey);
798 }
799 else
800 {
801 EdgeExp->IProductWRTBase(Fn, edgeCoeffs);
802
803 Expansion1DSharedPtr locExp = EdgeExp->as<Expansion1D>();
804
806 {
807 Vmath::Neg(n_coeffs, edgeCoeffs, 1);
808 }
809 }
810
811 // Implementation for all the basis except Gauss points
813 {
814 // add data to outarray if forward edge normal is outwards
815 for (i = 0; i < order_e; ++i)
816 {
817 outarray[(*map)[i].index] += (*map)[i].sign * edgeCoeffs[i];
818 }
819 }
820 else
821 {
822 int nCoeffs0, nCoeffs1;
823 int j;
824
829
831
832 switch (edge)
833 {
834 case 0:
835 {
836 nCoeffs1 = m_base[1]->GetNumModes();
837
838 for (i = 0; i < order_e; ++i)
839 {
840 for (j = 0; j < nCoeffs1; j++)
841 {
842 outarray[(*map)[i].index + j * order_e] +=
843 mat_gauss->GetPtr()[j] * (*map)[i].sign *
844 edgeCoeffs[i];
845 }
846 }
847 break;
848 }
849 case 1:
850 {
851 nCoeffs0 = m_base[0]->GetNumModes();
852
853 for (i = 0; i < order_e; ++i)
854 {
855 for (j = 0; j < nCoeffs0; j++)
856 {
857 outarray[(*map)[i].index - j] +=
858 mat_gauss->GetPtr()[order_e - 1 - j] *
859 (*map)[i].sign * edgeCoeffs[i];
860 }
861 }
862 break;
863 }
864 case 2:
865 {
866 nCoeffs1 = m_base[1]->GetNumModes();
867
868 for (i = 0; i < order_e; ++i)
869 {
870 for (j = 0; j < nCoeffs1; j++)
871 {
872 outarray[(*map)[i].index - j * order_e] +=
873 mat_gauss->GetPtr()[order_e - 1 - j] *
874 (*map)[i].sign * edgeCoeffs[i];
875 }
876 }
877 break;
878 }
879 case 3:
880 {
881 nCoeffs0 = m_base[0]->GetNumModes();
882
883 for (i = 0; i < order_e; ++i)
884 {
885 for (j = 0; j < nCoeffs0; j++)
886 {
887 outarray[(*map)[i].index + j] +=
888 mat_gauss->GetPtr()[j] * (*map)[i].sign *
889 edgeCoeffs[i];
890 }
891 }
892 break;
893 }
894 default:
896 break;
897 }
898 }
899}
std::vector< bool > m_requireNeg
Definition: Expansion2D.h:118
SpatialDomains::GeometrySharedPtr GetGeom() const
Definition: Expansion.cpp:171
std::map< int, ExpansionWeakPtr > m_traceExp
Definition: Expansion.h:274
IndexMapValuesSharedPtr GetIndexMap(const IndexMapKey &ikey)
Definition: Expansion.h:148
LibUtilities::NekManager< StdMatrixKey, DNekMat, StdMatrixKey::opLess > m_stdMatrixManager
Definition: StdExpansion.h:1184
int GetBasisNumModes(const int dir) const
This function returns the number of expansion modes in the dir direction.
Definition: StdExpansion.h:175
void InterpCoeff1D(const BasisKey &fbasis0, const Array< OneD, const NekDouble > &from, const BasisKey &tbasis0, Array< OneD, NekDouble > &to)
Definition: InterpCoeff.cpp:44
std::shared_ptr< Expansion > ExpansionSharedPtr
Definition: Expansion.h:68
std::shared_ptr< IndexMapValues > IndexMapValuesSharedPtr
Definition: IndexMapKey.h:128
std::shared_ptr< Expansion1D > Expansion1DSharedPtr
Definition: Expansion1D.h:52
References ASSERTL0, Nektar::StdRegions::StdExpansion::DetShapeType(), Nektar::LocalRegions::eEdgeToElement, Nektar::StdRegions::eFactorGaussEdge, Nektar::LibUtilities::eGauss_Lagrange, Nektar::StdRegions::eGaussDG, Nektar::StdRegions::eMass, Nektar::LibUtilities::eSegment, Nektar::VarcoeffHashingTest::factors, Nektar::StdRegions::StdExpansion::GetBasisNumModes(), Nektar::LocalRegions::Expansion::GetGeom(), Nektar::LocalRegions::Expansion::GetIndexMap(), Nektar::StdRegions::StdExpansion::GetNtraces(), Nektar::LocalRegions::Expansion::GetTraceOrient(), Nektar::LibUtilities::InterpCoeff1D(), Nektar::StdRegions::StdExpansion::m_base, m_requireNeg, Nektar::StdRegions::StdExpansion::m_stdMatrixManager, Nektar::LocalRegions::Expansion::m_traceExp, and Vmath::Neg().
◆ v_AddEdgeNormBoundaryInt() [2/2]
|
overrideprotectedvirtual |
Definition at line 668 of file Expansion2D.cpp.
672{
674
675 const Array<OneD, const Array<OneD, NekDouble>> normals =
676 GetTraceNormal(edge);
677
679 {
681 m_requireNeg.resize(nedges);
682
683 for (int i = 0; i < nedges; ++i)
684 {
686
688
689 if (edgeExp->GetRightAdjacentElementExp())
690 {
691 if (edgeExp->GetRightAdjacentElementExp()
692 ->GetGeom()
693 ->GetGlobalID() == GetGeom()->GetGlobalID())
694 {
696 }
697 }
698 }
699 }
700
701 // We allow the case of mixed polynomial order by supporting only
702 // those modes on the edge common to both adjoining elements. This
703 // is enforced here by taking the minimum size and padding with
704 // zeros.
705 int nquad_e = min(EdgeExp->GetNumPoints(0), int(normals[0].size()));
706
707 int nEdgePts = EdgeExp->GetTotPoints();
708 Array<OneD, NekDouble> edgePhys(nEdgePts);
709 Vmath::Vmul(nquad_e, normals[0], 1, Fx, 1, edgePhys, 1);
710 Vmath::Vvtvp(nquad_e, normals[1], 1, Fy, 1, edgePhys, 1, edgePhys, 1);
711
712 Expansion1DSharedPtr locExp = EdgeExp->as<Expansion1D>();
713
715 {
716 if (locExp->GetRightAdjacentElementExp()->GetGeom()->GetGlobalID() ==
717 m_geom->GetGlobalID())
718 {
719 Vmath::Neg(nquad_e, edgePhys, 1);
720 }
721 }
722
723 AddEdgeNormBoundaryInt(edge, EdgeExp, edgePhys, outarray);
724}
void AddEdgeNormBoundaryInt(const int edge, const std::shared_ptr< Expansion > &EdgeExp, const Array< OneD, const NekDouble > &Fx, const Array< OneD, const NekDouble > &Fy, Array< OneD, NekDouble > &outarray)
Definition: Expansion.cpp:118
References Nektar::LocalRegions::Expansion::AddEdgeNormBoundaryInt(), ASSERTL1, Nektar::StdRegions::StdExpansion::GetCoordim(), Nektar::LocalRegions::Expansion::GetGeom(), Nektar::StdRegions::StdExpansion::GetNtraces(), Nektar::LocalRegions::Expansion::GetTraceNormal(), Nektar::LocalRegions::Expansion::m_geom, m_requireNeg, Nektar::LocalRegions::Expansion::m_traceExp, Vmath::Neg(), Vmath::Vmul(), and Vmath::Vvtvp().
◆ v_AddRobinMassMatrix()
|
overrideprotectedvirtual |
Reimplemented from Nektar::LocalRegions::Expansion.
Definition at line 1989 of file Expansion2D.cpp.
1992{
1994 "Not set up for non boundary-interior expansions");
1995 ASSERTL1(inoutmat->GetRows() == inoutmat->GetColumns(),
1996 "Assuming that input matrix was square");
1997 int i, j;
1998 int id1, id2;
2000 int order_e = edgeExp->GetNcoeffs();
2001
2002 Array<OneD, unsigned int> map;
2003 Array<OneD, int> sign;
2004
2005 StdRegions::VarCoeffMap varcoeffs;
2006 varcoeffs[StdRegions::eVarCoeffMass] = primCoeffs;
2007
2009 *edgeExp, StdRegions::NullConstFactorMap,
2010 varcoeffs);
2011 DNekScalMat &edgemat = *edgeExp->GetLocMatrix(mkey);
2012
2013 // Now need to identify a map which takes the local edge
2014 // mass matrix to the matrix stored in inoutmat;
2015 // This can currently be deduced from the size of the matrix
2016
2017 // - if inoutmat.m_rows() == v_NCoeffs() it is a full
2018 // matrix system
2019
2020 // - if inoutmat.m_rows() == v_NumBndCoeffs() it is a
2021 // boundary CG system
2022
2023 // - if inoutmat.m_rows() == v_NumDGBndCoeffs() it is a
2024 // trace DG system
2025 int rows = inoutmat->GetRows();
2026
2028 {
2030 }
2032 {
2034 Array<OneD, unsigned int> bmap(nbndry);
2035
2037
2038 GetBoundaryMap(bmap);
2039
2040 for (i = 0; i < order_e; ++i)
2041 {
2042 for (j = 0; j < nbndry; ++j)
2043 {
2044 if (map[i] == bmap[j])
2045 {
2046 map[i] = j;
2047 break;
2048 }
2049 }
2051 }
2052 }
2054 {
2055 // possibly this should be a separate method
2056 int cnt = 0;
2057 map = Array<OneD, unsigned int>(order_e);
2058 sign = Array<OneD, int>(order_e, 1);
2059
2060 for (i = 0; i < edge; ++i)
2061 {
2062 cnt += GetTraceNcoeffs(i);
2063 }
2064
2065 for (i = 0; i < order_e; ++i)
2066 {
2067 map[i] = cnt++;
2068 }
2069 // check for mapping reversal
2071 {
2072 switch (edgeExp->GetBasis(0)->GetBasisType())
2073 {
2075 reverse(map.get(), map.get() + order_e);
2076 break;
2078 reverse(map.get(), map.get() + order_e);
2079 break;
2081 {
2082 swap(map[0], map[1]);
2083 for (i = 3; i < order_e; i += 2)
2084 {
2085 sign[i] = -1;
2086 }
2087 }
2088 break;
2089 default:
2091 "Edge boundary type not valid for this method");
2092 }
2093 }
2094 }
2095 else
2096 {
2098 }
2099
2100 for (i = 0; i < order_e; ++i)
2101 {
2102 id1 = map[i];
2103 for (j = 0; j < order_e; ++j)
2104 {
2105 id2 = map[j];
2107 }
2108 }
2109}
int NumDGBndryCoeffs(void) const
Definition: StdExpansion.h:333
bool IsBoundaryInteriorExpansion() const
Definition: StdExpansion.h:393
References ASSERTL0, ASSERTL1, Nektar::StdRegions::eBackwards, Nektar::LibUtilities::eGauss_Lagrange, Nektar::LibUtilities::eGLL_Lagrange, Nektar::StdRegions::eMass, Nektar::LibUtilities::eModified_A, Nektar::LibUtilities::eSegment, Nektar::StdRegions::eVarCoeffMass, Nektar::StdRegions::StdExpansion::GetBoundaryMap(), Nektar::StdRegions::StdExpansion::GetNcoeffs(), Nektar::StdRegions::StdExpansion::GetTraceNcoeffs(), Nektar::LocalRegions::Expansion::GetTraceOrient(), Nektar::StdRegions::StdExpansion::GetTraceToElementMap(), Nektar::StdRegions::StdExpansion::IsBoundaryInteriorExpansion(), Nektar::LocalRegions::Expansion::m_traceExp, Nektar::StdRegions::NullConstFactorMap, Nektar::StdRegions::StdExpansion::NumBndryCoeffs(), Nektar::StdRegions::StdExpansion::NumDGBndryCoeffs(), sign, and Nektar::LocalRegions::Expansion::v_GetTraceOrient().
◆ v_AddRobinTraceContribution()
|
overrideprotectedvirtual |
Given an edge and vector of element coefficients:
- maps those elemental coefficients corresponding to the edge into an edge-vector.
- resets the element coefficients
- multiplies the edge vector by the edge mass matrix
- maps the edge coefficients back onto the elemental coefficients
Reimplemented from Nektar::LocalRegions::Expansion.
Definition at line 2119 of file Expansion2D.cpp.
2122{
2124 "Not set up for non boundary-interior expansions");
2125 int i;
2127 int order_e = edgeExp->GetNcoeffs();
2128
2129 Array<OneD, unsigned int> map;
2130 Array<OneD, int> sign;
2131
2132 StdRegions::VarCoeffMap varcoeffs;
2133 varcoeffs[StdRegions::eVarCoeffMass] = primCoeffs;
2134
2136 *edgeExp, StdRegions::NullConstFactorMap,
2137 varcoeffs);
2138 DNekScalMat &edgemat = *edgeExp->GetLocMatrix(mkey);
2139
2140 NekVector<NekDouble> vEdgeCoeffs(order_e);
2141
2143
2144 for (i = 0; i < order_e; ++i)
2145 {
2146 vEdgeCoeffs[i] = incoeffs[map[i]] * sign[i];
2147 }
2148
2149 vEdgeCoeffs = edgemat * vEdgeCoeffs;
2150
2151 for (i = 0; i < order_e; ++i)
2152 {
2153 coeffs[map[i]] += vEdgeCoeffs[i] * sign[i];
2154 }
2155}
References ASSERTL1, Nektar::StdRegions::eMass, Nektar::LibUtilities::eSegment, Nektar::StdRegions::eVarCoeffMass, Nektar::StdRegions::StdExpansion::GetTraceToElementMap(), Nektar::StdRegions::StdExpansion::IsBoundaryInteriorExpansion(), Nektar::LocalRegions::Expansion::m_traceExp, Nektar::StdRegions::NullConstFactorMap, sign, and Nektar::LocalRegions::Expansion::v_GetTraceOrient().
◆ v_BuildVertexMatrix()
|
overrideprotectedvirtual |
Reimplemented from Nektar::LocalRegions::Expansion.
Definition at line 2157 of file Expansion2D.cpp.
2159{
2161 DNekMatSharedPtr m_vertexmatrix;
2162
2163 int nVerts, vid1, vid2, vMap1, vMap2;
2164 NekDouble VertexValue;
2165
2166 nVerts = GetNverts();
2167
2168 m_vertexmatrix =
2169 MemoryManager<DNekMat>::AllocateSharedPtr(nVerts, nVerts, 0.0, storage);
2170 DNekMat &VertexMat = (*m_vertexmatrix);
2171
2172 for (vid1 = 0; vid1 < nVerts; ++vid1)
2173 {
2174 vMap1 = GetVertexMap(vid1);
2175
2176 for (vid2 = 0; vid2 < nVerts; ++vid2)
2177 {
2178 vMap2 = GetVertexMap(vid2);
2179 VertexValue = (*r_bnd)(vMap1, vMap2);
2180 VertexMat.SetValue(vid1, vid2, VertexValue);
2181 }
2182 }
2183
2184 return m_vertexmatrix;
2185}
int GetVertexMap(const int localVertexId, bool useCoeffPacking=false)
Definition: StdExpansion.h:685
int GetNverts() const
This function returns the number of vertices of the expansion domain.
Definition: StdExpansion.h:252
References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::eFULL, Nektar::StdRegions::StdExpansion::GetNverts(), and Nektar::StdRegions::StdExpansion::GetVertexMap().
◆ v_DGDeriv()
|
overrideprotectedvirtual |
Reimplemented from Nektar::LocalRegions::Expansion.
Definition at line 1952 of file Expansion2D.cpp.
1957{
1959 StdRegions::eWeakDeriv1,
1960 StdRegions::eWeakDeriv2};
1961
1963
1966
1967 Array<OneD, NekDouble> coeffs = incoeffs;
1969
1970 Coeffs = Transpose(Dmat) * Coeffs;
1971 Vmath::Neg(ncoeffs, coeffs, 1);
1972
1973 // Add the boundary integral including the relevant part of
1974 // the normal
1975 AddNormTraceInt(dir, EdgeExp, edgeCoeffs, coeffs);
1976
1978
1979 Out_d = InvMass * Coeffs;
1980}
void AddNormTraceInt(const int dir, Array< OneD, ExpansionSharedPtr > &EdgeExp, Array< OneD, Array< OneD, NekDouble > > &edgeCoeffs, Array< OneD, NekDouble > &outarray)
Definition: Expansion2D.cpp:980
References AddNormTraceInt(), Nektar::StdRegions::eInvMass, Nektar::StdRegions::eWeakDeriv0, Nektar::StdRegions::eWeakDeriv1, Nektar::StdRegions::eWeakDeriv2, Nektar::eWrapper, Nektar::LocalRegions::Expansion::GetLocMatrix(), Nektar::StdRegions::StdExpansion::GetNcoeffs(), Vmath::Neg(), and Nektar::Transpose().
◆ v_GenMatrix()
|
overridevirtual |
Computes matrices needed for the HDG formulation. References to equations relate to the following paper: R. M. Kirby, S. J. Sherwin, B. Cockburn, To CG or to HDG: A Comparative Study, J. Sci. Comp P1-30 DOI 10.1007/s10915-011-9501-7
TODO: Add variable coeffs
Reimplemented from Nektar::StdRegions::StdExpansion.
Reimplemented in Nektar::LocalRegions::NodalTriExp, Nektar::LocalRegions::QuadExp, and Nektar::LocalRegions::TriExp.
Definition at line 1259 of file Expansion2D.cpp.
1260{
1261 DNekMatSharedPtr returnval;
1262
1263 switch (mkey.GetMatrixType())
1264 {
1265 // (Z^e)^{-1} (Eqn. 33, P22)
1267 {
1269 "HybridDGHelmholtz matrix not set up "
1270 "for non boundary-interior expansions");
1271
1272 int i, j, k;
1273 NekDouble lambdaval =
1274 mkey.GetConstFactor(StdRegions::eFactorLambda);
1278 int shapedim = 2;
1280 bool mmf =
1281 (varcoeffs.find(StdRegions::eVarCoeffMF1x) != varcoeffs.end());
1282
1283 Array<OneD, unsigned int> emap;
1284 Array<OneD, int> sign;
1286 ExpansionSharedPtr EdgeExp;
1287
1291 StdRegions::eWeakDeriv1,
1292 StdRegions::eWeakDeriv2};
1293 DNekMat LocMat(ncoeffs, ncoeffs);
1294
1295 returnval =
1296 MemoryManager<DNekMat>::AllocateSharedPtr(ncoeffs, ncoeffs);
1297 DNekMat &Mat = *returnval;
1298 Vmath::Zero(ncoeffs * ncoeffs, Mat.GetPtr(), 1);
1299
1301 StdRegions::eVarCoeffD11,
1302 StdRegions::eVarCoeffD22};
1303
1304 StdRegions::VarCoeffMap::const_iterator x;
1305
1306 for (i = 0; i < coordim; ++i)
1307 {
1308 if (mmf)
1309 {
1310 if (i < shapedim)
1311 {
1312 StdRegions::VarCoeffMap VarCoeffDirDeriv;
1313 VarCoeffDirDeriv[StdRegions::eVarCoeffMF] =
1314 GetMF(i, shapedim, varcoeffs);
1315 VarCoeffDirDeriv[StdRegions::eVarCoeffMFDiv] =
1316 GetMFDiv(i, varcoeffs);
1317
1318 MatrixKey Dmatkey(StdRegions::eWeakDirectionalDeriv,
1321 VarCoeffDirDeriv);
1322
1324
1325 StdRegions::VarCoeffMap Weight;
1326 Weight[StdRegions::eVarCoeffMass] =
1327 GetMFMag(i, mkey.GetVarCoeffs());
1328
1329 MatrixKey invMasskey(
1331 StdRegions::NullConstFactorMap, Weight);
1332
1334
1335 Mat = Mat + Dmat * invMass * Transpose(Dmat);
1336 }
1337 }
1338 else if (mkey.HasVarCoeff(Coeffs[i]))
1339 {
1342 mkey.GetVarCoeffAsMap(Coeffs[i]));
1343
1345
1348 Mat = Mat + DmatL * invMass * Transpose(DmatR);
1349 }
1350 else
1351 {
1353 Mat = Mat + Dmat * invMass * Transpose(Dmat);
1354 }
1355 }
1356
1357 // Add Mass Matrix Contribution for Helmholtz problem
1359 Mat = Mat + lambdaval * Mass;
1360
1361 // Add tau*E_l using elemental mass matrices on each edge
1362 for (i = 0; i < nedges; ++i)
1363 {
1364 EdgeExp = GetTraceExp(i);
1365 order_e = EdgeExp->GetNcoeffs();
1366
1367 int nq = EdgeExp->GetNumPoints(0);
1369
1370 // @TODO: Document
1371 StdRegions::VarCoeffMap edgeVarCoeffs;
1373 {
1374 Array<OneD, NekDouble> mu(nq);
1376 i, EdgeExp, mkey.GetVarCoeff(StdRegions::eVarCoeffD00),
1377 mu);
1378 edgeVarCoeffs[StdRegions::eVarCoeffMass] = mu;
1379 }
1382 edgeVarCoeffs);
1383 // DNekScalMat &eMass =
1384 // *EdgeExp->GetLocMatrix(StdRegions::eMass);
1385
1386 for (j = 0; j < order_e; ++j)
1387 {
1388 for (k = 0; k < order_e; ++k)
1389 {
1390 Mat(emap[j], emap[k]) =
1391 Mat(emap[j], emap[k]) +
1393 }
1394 }
1395 }
1396 }
1397 break;
1398 // U^e (P22)
1400 {
1401 int i, j, k;
1406
1407 Array<OneD, NekDouble> lambda(nbndry);
1409 Array<OneD, NekDouble> ulam(ncoeffs);
1411 Array<OneD, NekDouble> f(ncoeffs);
1413
1414 Array<OneD, ExpansionSharedPtr> EdgeExp(nedges);
1415 // declare matrix space
1416 returnval =
1417 MemoryManager<DNekMat>::AllocateSharedPtr(ncoeffs, nbndry);
1418 DNekMat &Umat = *returnval;
1419
1420 // Z^e matrix
1422 *this, mkey.GetConstFactors(),
1423 mkey.GetVarCoeffs());
1425
1426 Array<OneD, unsigned int> emap;
1427 Array<OneD, int> sign;
1428
1429 for (i = 0; i < nedges; ++i)
1430 {
1431 EdgeExp[i] = GetTraceExp(i);
1432 }
1433
1434 // for each degree of freedom of the lambda space
1435 // calculate Umat entry
1436 // Generate Lambda to U_lambda matrix
1437 for (j = 0; j < nbndry; ++j)
1438 {
1439 // standard basis vectors e_j
1440 Vmath::Zero(nbndry, &lambda[0], 1);
1441 Vmath::Zero(ncoeffs, &f[0], 1);
1442 lambda[j] = 1.0;
1443
1444 SetTraceToGeomOrientation(EdgeExp, lambda);
1445
1446 // Compute F = [I D_1 M^{-1} D_2 M^{-1}] C e_j
1447 AddHDGHelmholtzTraceTerms(tau, lambda, EdgeExp,
1448 mkey.GetVarCoeffs(), f);
1449
1450 // Compute U^e_j
1451 Ulam = invHmat * F; // generate Ulam from lambda
1452
1453 // fill column of matrix
1454 for (k = 0; k < ncoeffs; ++k)
1455 {
1456 Umat(k, j) = Ulam[k];
1457 }
1458 }
1459 }
1460 break;
1461 // Q_0, Q_1, Q_2 matrices (P23)
1462 // Each are a product of a row of Eqn 32 with the C matrix.
1463 // Rather than explicitly computing all of Eqn 32, we note each
1464 // row is almost a multiple of U^e, so use that as our starting
1465 // point.
1469 {
1470 int i = 0;
1471 int j = 0;
1472 int k = 0;
1473 int dir = 0;
1477 int shapedim = 2;
1478
1479 Array<OneD, NekDouble> lambda(nbndry);
1481 Array<OneD, ExpansionSharedPtr> EdgeExp(nedges);
1482
1483 Array<OneD, NekDouble> ulam(ncoeffs);
1485 Array<OneD, NekDouble> f(ncoeffs);
1487
1488 // declare matrix space
1489 returnval =
1490 MemoryManager<DNekMat>::AllocateSharedPtr(ncoeffs, nbndry);
1491 DNekMat &Qmat = *returnval;
1492
1493 // Lambda to U matrix
1495 *this, mkey.GetConstFactors(),
1496 mkey.GetVarCoeffs());
1498
1499 // Inverse mass matrix
1501
1502 for (i = 0; i < nedges; ++i)
1503 {
1504 EdgeExp[i] = GetTraceExp(i);
1505 }
1506
1507 // Weak Derivative matrix
1508 DNekScalMatSharedPtr Dmat;
1509 switch (mkey.GetMatrixType())
1510 {
1512 dir = 0;
1514 break;
1516 dir = 1;
1518 break;
1520 dir = 2;
1522 break;
1523 default:
1525 break;
1526 }
1527
1530 {
1531 StdRegions::VarCoeffMap VarCoeffDirDeriv;
1532 VarCoeffDirDeriv[StdRegions::eVarCoeffMF] =
1533 GetMF(dir, shapedim, varcoeffs);
1534 VarCoeffDirDeriv[StdRegions::eVarCoeffMFDiv] =
1535 GetMFDiv(dir, varcoeffs);
1536
1537 MatrixKey Dmatkey(
1539 StdRegions::NullConstFactorMap, VarCoeffDirDeriv);
1540
1541 Dmat = GetLocMatrix(Dmatkey);
1542
1543 StdRegions::VarCoeffMap Weight;
1544 Weight[StdRegions::eVarCoeffMass] =
1545 GetMFMag(dir, mkey.GetVarCoeffs());
1546
1549 Weight);
1550
1551 invMass = *GetLocMatrix(invMasskey);
1552 }
1553 else
1554 {
1556 StdRegions::eWeakDeriv1,
1557 StdRegions::eWeakDeriv2};
1558
1559 Dmat = GetLocMatrix(DerivType[dir]);
1560
1562 *this);
1563 invMass = *GetLocMatrix(invMasskey);
1564 }
1565
1566 // for each degree of freedom of the lambda space
1567 // calculate Qmat entry
1568 // Generate Lambda to Q_lambda matrix
1569 for (j = 0; j < nbndry; ++j)
1570 {
1571 Vmath::Zero(nbndry, &lambda[0], 1);
1572 lambda[j] = 1.0;
1573
1574 // for lambda[j] = 1 this is the solution to ulam
1575 for (k = 0; k < ncoeffs; ++k)
1576 {
1577 Ulam[k] = lamToU(k, j);
1578 }
1579
1580 // -D^T ulam
1581 Vmath::Neg(ncoeffs, &ulam[0], 1);
1582 F = Transpose(*Dmat) * Ulam;
1583
1584 SetTraceToGeomOrientation(EdgeExp, lambda);
1585
1586 // Add the C terms resulting from the I's on the
1587 // diagonals of Eqn 32
1588 AddNormTraceInt(dir, lambda, EdgeExp, f, mkey.GetVarCoeffs());
1589
1590 // finally multiply by inverse mass matrix
1591 Ulam = invMass * F;
1592
1593 // fill column of matrix (Qmat is in column major format)
1594 Vmath::Vcopy(ncoeffs, &ulam[0], 1,
1595 &(Qmat.GetPtr())[0] + j * ncoeffs, 1);
1596 }
1597 }
1598 break;
1599 // Matrix K (P23)
1601 {
1602 int i, j, e, cnt;
1603 int order_e, nquad_e;
1608 StdRegions::VarCoeffMap::const_iterator x;
1610 bool mmf =
1611 (varcoeffs.find(StdRegions::eVarCoeffMF1x) != varcoeffs.end());
1612
1613 Array<OneD, NekDouble> work, varcoeff_work;
1614 Array<OneD, const Array<OneD, NekDouble>> normals;
1615 Array<OneD, ExpansionSharedPtr> EdgeExp(nedges);
1616 Array<OneD, NekDouble> lam(nbndry);
1617
1618 Array<OneD, unsigned int> emap;
1619 Array<OneD, int> sign;
1620 StdRegions::Orientation edgedir;
1621
1622 // declare matrix space
1623 returnval =
1624 MemoryManager<DNekMat>::AllocateSharedPtr(nbndry, nbndry);
1625 DNekMat &BndMat = *returnval;
1626
1627 DNekScalMatSharedPtr LamToQ[3];
1628
1629 // Matrix to map Lambda to U
1631 *this, mkey.GetConstFactors(),
1632 mkey.GetVarCoeffs());
1634
1635 // Matrix to map Lambda to Q0
1637 *this, mkey.GetConstFactors(),
1638 mkey.GetVarCoeffs());
1639 LamToQ[0] = GetLocMatrix(LamToQ0key);
1640
1641 // Matrix to map Lambda to Q1
1643 *this, mkey.GetConstFactors(),
1644 mkey.GetVarCoeffs());
1645 LamToQ[1] = GetLocMatrix(LamToQ1key);
1646
1647 // Matrix to map Lambda to Q2 for 3D coordinates
1648 if (coordim == 3)
1649 {
1650 MatrixKey LamToQ2key(
1652 mkey.GetConstFactors(), mkey.GetVarCoeffs());
1653 LamToQ[2] = GetLocMatrix(LamToQ2key);
1654 }
1655
1656 // Set up edge segment expansions from local geom info
1657 for (i = 0; i < nedges; ++i)
1658 {
1659 EdgeExp[i] = GetTraceExp(i);
1660 }
1661
1662 // Set up matrix derived from <mu, Q_lam.n - \tau (U_lam - Lam) >
1663 for (i = 0; i < nbndry; ++i)
1664 {
1665 cnt = 0;
1666
1667 Vmath::Zero(nbndry, lam, 1);
1668 lam[i] = 1.0;
1669 SetTraceToGeomOrientation(EdgeExp, lam);
1670
1671 for (e = 0; e < nedges; ++e)
1672 {
1673 order_e = EdgeExp[e]->GetNcoeffs();
1674 nquad_e = EdgeExp[e]->GetNumPoints(0);
1675
1676 normals = GetTraceNormal(e);
1677 edgedir = GetTraceOrient(e);
1678
1679 work = Array<OneD, NekDouble>(nquad_e);
1680 varcoeff_work = Array<OneD, NekDouble>(nquad_e);
1681
1683
1684 StdRegions::VarCoeffType VarCoeff[3] = {
1686 StdRegions::eVarCoeffD22};
1687
1688 // Q0 * n0 (BQ_0 terms)
1689 Array<OneD, NekDouble> edgeCoeffs(order_e);
1690 Array<OneD, NekDouble> edgePhys(nquad_e);
1691 for (j = 0; j < order_e; ++j)
1692 {
1693 edgeCoeffs[j] = sign[j] * (*LamToQ[0])(emap[j], i);
1694 }
1695
1696 EdgeExp[e]->BwdTrans(edgeCoeffs, edgePhys);
1697 // @TODO Var coeffs
1698 // Multiply by variable coefficient
1699 // if ((x =
1700 // varcoeffs.find(VarCoeff[0]))
1701 // != varcoeffs.end())
1702 // {
1703 // GetPhysEdgeVarCoeffsFromElement(e,EdgeExp[e],x->second,varcoeff_work);
1704 // Vmath::Vmul(nquad_e,varcoeff_work,1,EdgeExp[e]->GetPhys(),1,EdgeExp[e]->UpdatePhys(),1);
1705 // }
1706 if (mmf)
1707 {
1708 Array<OneD, NekDouble> ncdotMF = GetnEdgecdotMF(
1709 0, e, EdgeExp[e], normals, varcoeffs);
1710 Vmath::Vmul(nquad_e, ncdotMF, 1, edgePhys, 1, work, 1);
1711 }
1712 else
1713 {
1714 Vmath::Vmul(nquad_e, normals[0], 1, edgePhys, 1, work,
1715 1);
1716 }
1717
1718 // Q1 * n1 (BQ_1 terms)
1719 for (j = 0; j < order_e; ++j)
1720 {
1721 edgeCoeffs[j] = sign[j] * (*LamToQ[1])(emap[j], i);
1722 }
1723
1724 EdgeExp[e]->BwdTrans(edgeCoeffs, edgePhys);
1725
1726 // @TODO var coeffs
1727 // Multiply by variable coefficients
1728 // if ((x =
1729 // varcoeffs.find(VarCoeff[1]))
1730 // != varcoeffs.end())
1731 // {
1732 // GetPhysEdgeVarCoeffsFromElement(e,EdgeExp[e],x->second,varcoeff_work);
1733 // Vmath::Vmul(nquad_e,varcoeff_work,1,EdgeExp[e]->GetPhys(),1,EdgeExp[e]->UpdatePhys(),1);
1734 // }
1735
1736 if (mmf)
1737 {
1738 Array<OneD, NekDouble> ncdotMF = GetnEdgecdotMF(
1739 1, e, EdgeExp[e], normals, varcoeffs);
1740 Vmath::Vvtvp(nquad_e, ncdotMF, 1, edgePhys, 1, work, 1,
1741 work, 1);
1742 }
1743 else
1744 {
1745 Vmath::Vvtvp(nquad_e, normals[1], 1, edgePhys, 1, work,
1746 1, work, 1);
1747 }
1748
1749 // Q2 * n2 (BQ_2 terms)
1750 if (coordim == 3)
1751 {
1752 for (j = 0; j < order_e; ++j)
1753 {
1754 edgeCoeffs[j] = sign[j] * (*LamToQ[2])(emap[j], i);
1755 }
1756
1757 EdgeExp[e]->BwdTrans(edgeCoeffs, edgePhys);
1758 // @TODO var coeffs
1759 // Multiply by variable coefficients
1760 // if ((x =
1761 // varcoeffs.find(VarCoeff[2]))
1762 // != varcoeffs.end())
1763 // {
1764 // GetPhysEdgeVarCoeffsFromElement(e,EdgeExp[e],x->second,varcoeff_work);
1765 // Vmath::Vmul(nquad_e,varcoeff_work,1,EdgeExp[e]->GetPhys(),1,EdgeExp[e]->UpdatePhys(),1);
1766 // }
1767
1768 Vmath::Vvtvp(nquad_e, normals[2], 1, edgePhys, 1, work,
1769 1, work, 1);
1770 }
1771
1772 // - tau (ulam - lam)
1773 // Corresponds to the G and BU terms.
1774 for (j = 0; j < order_e; ++j)
1775 {
1776 edgeCoeffs[j] =
1777 sign[j] * LamToU(emap[j], i) - lam[cnt + j];
1778 }
1779
1780 EdgeExp[e]->BwdTrans(edgeCoeffs, edgePhys);
1781
1782 // Multiply by variable coefficients
1783 if ((x = varcoeffs.find(VarCoeff[0])) != varcoeffs.end())
1784 {
1786 e, EdgeExp[e], x->second.GetValue(), varcoeff_work);
1787 Vmath::Vmul(nquad_e, varcoeff_work, 1, edgePhys, 1,
1788 edgePhys, 1);
1789 }
1790
1791 Vmath::Svtvp(nquad_e, -tau, edgePhys, 1, work, 1, work, 1);
1792 /// TODO: Add variable coeffs
1793 EdgeExp[e]->IProductWRTBase(work, edgeCoeffs);
1794
1795 EdgeExp[e]->SetCoeffsToOrientation(edgedir, edgeCoeffs,
1796 edgeCoeffs);
1797
1798 for (j = 0; j < order_e; ++j)
1799 {
1800 BndMat(cnt + j, i) = edgeCoeffs[j];
1801 }
1802
1803 cnt += order_e;
1804 }
1805 }
1806 }
1807 break;
1808 // HDG postprocessing
1810 {
1812 mkey.GetConstFactors(), mkey.GetVarCoeffs());
1814
1815 returnval = MemoryManager<DNekMat>::AllocateSharedPtr(
1816 LapMat.GetRows(), LapMat.GetColumns());
1817 DNekMatSharedPtr lmat = returnval;
1818
1819 (*lmat) = LapMat;
1820
1821 // replace first column with inner product wrt 1
1823 Array<OneD, NekDouble> tmp(nq);
1824 Array<OneD, NekDouble> outarray(m_ncoeffs);
1825 Vmath::Fill(nq, 1.0, tmp, 1);
1826 IProductWRTBase(tmp, outarray);
1827
1829 lmat->Invert();
1830 }
1831 break;
1833 {
1837 Array<OneD, const Array<OneD, NekDouble>> normals;
1838 Array<OneD, NekDouble> phys(nphys);
1839 returnval =
1841 DNekMat &Mat = *returnval;
1843
1844 Array<OneD, Array<OneD, NekDouble>> Deriv(3, NullNekDouble1DArray);
1845
1847 {
1848 Deriv[d] = Array<OneD, NekDouble>(nphys);
1849 }
1850
1851 Array<OneD, int> tracepts(ntraces);
1852 Array<OneD, ExpansionSharedPtr> traceExp(ntraces);
1853 int maxtpts = 0;
1854 for (int t = 0; t < ntraces; ++t)
1855 {
1856 traceExp[t] = GetTraceExp(t);
1857 tracepts[t] = traceExp[t]->GetTotPoints();
1858 maxtpts = (maxtpts > tracepts[t]) ? maxtpts : tracepts[t];
1859 }
1860
1861 Array<OneD, NekDouble> val(maxtpts), tmp, tmp1;
1862
1863 Array<OneD, Array<OneD, NekDouble>> dphidn(ntraces);
1864 for (int t = 0; t < ntraces; ++t)
1865 {
1866 dphidn[t] =
1867 Array<OneD, NekDouble>(m_ncoeffs * tracepts[t], 0.0);
1868 }
1869
1871 {
1872 FillMode(i, phys);
1873 PhysDeriv(phys, Deriv[0], Deriv[1], Deriv[2]);
1874
1875 for (int t = 0; t < ntraces; ++t)
1876 {
1878
1879 LibUtilities::BasisKey fromkey = GetTraceBasisKey(t);
1880 LibUtilities::BasisKey tokey =
1881 traceExp[t]->GetBasis(0)->GetBasisKey();
1882 bool DoInterp = (fromkey != tokey);
1883
1884 Array<OneD, NekDouble> n(tracepts[t]);
1885 ;
1887 {
1888 // if variable p may need to interpolate
1889 if (DoInterp)
1890 {
1892 }
1893 else
1894 {
1895 n = norm[d];
1896 }
1897
1899 v_GetTraceOrient(t));
1900
1901 Vmath::Vvtvp(tracepts[t], n, 1, val, 1,
1902 tmp = dphidn[t] + i * tracepts[t], 1,
1903 tmp1 = dphidn[t] + i * tracepts[t], 1);
1904 }
1905 }
1906 }
1907
1908 for (int t = 0; t < ntraces; ++t)
1909 {
1910 int nt = tracepts[t];
1913
1914 // scaling from GJP paper
1915 NekDouble scale =
1917
1919 {
1921 {
1922 Vmath::Vmul(nt, dphidn[t] + i * nt, 1,
1923 dphidn[t] + j * nt, 1, val, 1);
1924 Mat(i, j) =
1925 Mat(i, j) + scale * traceExp[t]->Integral(val);
1926 }
1927 }
1928 }
1929
1930 // fill in symmetric components.
1932 {
1933 for (int j = 0; j < i; ++j)
1934 {
1935 Mat(i, j) = Mat(j, i);
1936 }
1937 }
1938 }
1939 break;
1940 default:
1942 "This matrix type cannot be generated from this class");
1943 break;
1944 }
1945
1946 return returnval;
1947}
void SetTraceToGeomOrientation(Array< OneD, ExpansionSharedPtr > &EdgeExp, Array< OneD, NekDouble > &inout)
Definition: Expansion2D.cpp:901
void AddHDGHelmholtzTraceTerms(const NekDouble tau, const Array< OneD, const NekDouble > &inarray, Array< OneD, ExpansionSharedPtr > &EdgeExp, const StdRegions::VarCoeffMap &dirForcing, Array< OneD, NekDouble > &outarray)
Definition: Expansion2D.cpp:1049
void GetTracePhysVals(const int trace, const StdRegions::StdExpansionSharedPtr &TraceExp, const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &outarray, StdRegions::Orientation orient=StdRegions::eNoOrientation)
Definition: Expansion.h:202
ExpansionSharedPtr GetTraceExp(const int traceid)
Definition: Expansion.h:416
void TraceNormLen(const int traceid, NekDouble &h, NekDouble &p)
Definition: Expansion.h:252
void FillMode(const int mode, Array< OneD, NekDouble > &outarray)
This function fills the array outarray with the mode-th mode of the expansion.
Definition: StdExpansion.h:497
const LibUtilities::BasisKey GetTraceBasisKey(const int i, int k=-1) const
This function returns the basis key belonging to the i-th trace.
Definition: StdExpansion.h:305
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
void PhysDeriv(const Array< OneD, const NekDouble > &inarray, Array< OneD, NekDouble > &out_d0, Array< OneD, NekDouble > &out_d1=NullNekDouble1DArray, Array< OneD, NekDouble > &out_d2=NullNekDouble1DArray)
Definition: StdExpansion.h:855
void Interp1D(const BasisKey &fbasis0, const Array< OneD, const NekDouble > &from, const BasisKey &tbasis0, Array< OneD, NekDouble > &to)
this function interpolates a 1D function evaluated at the quadrature points of the basis fbasis0 to ...
Definition: Interp.cpp:49
Array< OneD, Array< OneD, NekDouble > > NormalVector
Definition: Expansion.h:55
std::vector< double > d(NPUPPER *NPUPPER)
static Array< OneD, NekDouble > NullNekDouble1DArray
Definition: SharedArray.hpp:888
void Fill(int n, const T alpha, T *x, const int incx)
Fill a vector with a constant value.
Definition: Vmath.cpp:43
References AddHDGHelmholtzTraceTerms(), AddNormTraceInt(), Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, ASSERTL1, Nektar::UnitTests::d(), Nektar::StdRegions::StdExpansion::DetShapeType(), Nektar::StdRegions::eFactorLambda, Nektar::StdRegions::eFactorTau, Nektar::StdRegions::eForwards, Nektar::StdRegions::eHybridDGHelmBndLam, Nektar::StdRegions::eHybridDGHelmholtz, Nektar::StdRegions::eHybridDGLamToQ0, Nektar::StdRegions::eHybridDGLamToQ1, Nektar::StdRegions::eHybridDGLamToQ2, Nektar::StdRegions::eHybridDGLamToU, Nektar::StdRegions::eInvHybridDGHelmholtz, Nektar::StdRegions::eInvLaplacianWithUnityMean, Nektar::StdRegions::eInvMass, Nektar::StdRegions::eLaplacian, Nektar::StdRegions::eMass, Nektar::StdRegions::eNormDerivOnTrace, Nektar::StdRegions::eVarCoeffD00, Nektar::StdRegions::eVarCoeffD11, Nektar::StdRegions::eVarCoeffD22, Nektar::StdRegions::eVarCoeffMass, Nektar::StdRegions::eVarCoeffMF, Nektar::StdRegions::eVarCoeffMF1x, Nektar::StdRegions::eVarCoeffMFDiv, Nektar::StdRegions::eWeakDeriv0, Nektar::StdRegions::eWeakDeriv1, Nektar::StdRegions::eWeakDeriv2, Nektar::StdRegions::eWeakDirectionalDeriv, Nektar::eWrapper, Vmath::Fill(), Nektar::StdRegions::StdExpansion::FillMode(), Nektar::StdRegions::StdMatrixKey::GetConstFactor(), Nektar::StdRegions::StdMatrixKey::GetConstFactors(), Nektar::StdRegions::StdExpansion::GetCoordim(), Nektar::LocalRegions::Expansion::GetLocMatrix(), Nektar::StdRegions::StdMatrixKey::GetMatrixType(), Nektar::LocalRegions::Expansion::GetMF(), Nektar::LocalRegions::Expansion::GetMFDiv(), Nektar::LocalRegions::Expansion::GetMFMag(), Nektar::StdRegions::StdExpansion::GetNcoeffs(), GetnEdgecdotMF(), Nektar::StdRegions::StdExpansion::GetNtraces(), GetPhysEdgeVarCoeffsFromElement(), Nektar::StdRegions::StdExpansion::GetTotPoints(), Nektar::StdRegions::StdExpansion::GetTraceBasisKey(), Nektar::LocalRegions::Expansion::GetTraceExp(), Nektar::LocalRegions::Expansion::GetTraceNormal(), Nektar::LocalRegions::Expansion::GetTraceOrient(), Nektar::LocalRegions::Expansion::GetTracePhysVals(), Nektar::StdRegions::StdExpansion::GetTraceToElementMap(), Nektar::StdRegions::StdMatrixKey::GetVarCoeff(), Nektar::StdRegions::StdMatrixKey::GetVarCoeffAsMap(), Nektar::StdRegions::StdMatrixKey::GetVarCoeffs(), Nektar::StdRegions::StdMatrixKey::HasVarCoeff(), Nektar::LibUtilities::Interp1D(), Nektar::StdRegions::StdExpansion::IProductWRTBase(), Nektar::StdRegions::StdExpansion::IsBoundaryInteriorExpansion(), Nektar::StdRegions::StdExpansion::m_ncoeffs, Vmath::Neg(), Nektar::StdRegions::NullConstFactorMap, Nektar::NullNekDouble1DArray, Nektar::StdRegions::StdExpansion::NumDGBndryCoeffs(), CellMLToNektar.cellml_metadata::p, Nektar::StdRegions::StdExpansion::PhysDeriv(), SetTraceToGeomOrientation(), sign, Vmath::Svtvp(), Nektar::LocalRegions::Expansion::TraceNormLen(), Nektar::Transpose(), Nektar::LocalRegions::Expansion::v_GetTraceOrient(), Vmath::Vcopy(), Vmath::Vmul(), Vmath::Vvtvp(), and Vmath::Zero().
Referenced by CreateMatrix(), Nektar::LocalRegions::NodalTriExp::v_GenMatrix(), Nektar::LocalRegions::QuadExp::v_GenMatrix(), and Nektar::LocalRegions::TriExp::v_GenMatrix().
◆ v_GenTraceExp()
|
overridevirtual |
Reimplemented from Nektar::LocalRegions::Expansion.
Definition at line 2187 of file Expansion2D.cpp.
2188{
2191}
References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), Nektar::StdRegions::StdExpansion::GetTraceBasisKey(), and Nektar::LocalRegions::Expansion::m_geom.
◆ v_ReOrientTracePhysMap()
|
overrideprotectedvirtual |
Reimplemented from Nektar::LocalRegions::Expansion.
Definition at line 2236 of file Expansion2D.cpp.
2239{
2240 boost::ignore_unused(nq1);
2241
2242 if (idmap.size() != nq0)
2243 {
2244 idmap = Array<OneD, int>(nq0);
2245 }
2246 switch (orient)
2247 {
2249 // Fwd
2250 for (int i = 0; i < nq0; ++i)
2251 {
2252 idmap[i] = i;
2253 }
2254 break;
2256 {
2257 // Bwd
2258 for (int i = 0; i < nq0; ++i)
2259 {
2260 idmap[i] = nq0 - 1 - i;
2261 }
2262 }
2263 break;
2264 default:
2266 break;
2267 }
2268}
References ASSERTL0, Nektar::StdRegions::eBackwards, and Nektar::StdRegions::eForwards.
◆ v_SetUpPhysNormals()
|
overrideprotectedvirtual |
Reimplemented from Nektar::LocalRegions::Expansion.
Definition at line 2231 of file Expansion2D.cpp.
2232{
2233 v_ComputeTraceNormal(edge);
2234}
virtual void v_ComputeTraceNormal(const int id)
Definition: Expansion.cpp:872
References Nektar::LocalRegions::Expansion::v_ComputeTraceNormal().
◆ v_TraceNormLen()
|
overrideprotectedvirtual |
Reimplemented from Nektar::LocalRegions::Expansion.
Definition at line 2326 of file Expansion2D.cpp.
2327{
2329
2330 int nverts = geom->GetNumVerts();
2331
2332 // vertices on edges
2333 SpatialDomains::PointGeom ev0 = *geom->GetVertex(traceid);
2334 SpatialDomains::PointGeom ev1 = *geom->GetVertex((traceid + 1) % nverts);
2335
2336 // vertex on adjacent edge to ev0
2337 SpatialDomains::PointGeom vadj =
2338 *geom->GetVertex((traceid + (nverts - 1)) % nverts);
2339
2340 // calculate perpendicular distance of normal length
2341 // from first vertex
2342 NekDouble h1 = ev0.dist(vadj);
2343 SpatialDomains::PointGeom Dx, Dx1;
2344
2345 Dx.Sub(ev1, ev0);
2346 Dx1.Sub(vadj, ev0);
2347
2348 NekDouble d1 = Dx.dot(Dx1);
2349 NekDouble lenDx = Dx.dot(Dx);
2350 h = sqrt(h1 * h1 - d1 * d1 / lenDx);
2351
2352 // perpendicular distanace from second vertex
2353 SpatialDomains::PointGeom vadj1 = *geom->GetVertex((traceid + 2) % nverts);
2354
2355 h1 = ev1.dist(vadj1);
2356 Dx1.Sub(vadj1, ev1);
2357 d1 = Dx.dot(Dx1);
2358
2359 h = (h + sqrt(h1 * h1 - d1 * d1 / lenDx)) * 0.5;
2360
2361 int dirn = (geom->GetDir(traceid) == 0) ? 1 : 0;
2362
2364}
std::shared_ptr< Geometry > GeometrySharedPtr
Definition: Geometry.h:54
References Nektar::SpatialDomains::PointGeom::dist(), Nektar::SpatialDomains::PointGeom::dot(), Nektar::StdRegions::StdExpansion::GetBasisNumModes(), Nektar::LocalRegions::Expansion::GetGeom(), Nektar::SpatialDomains::Geometry::GetVertex(), CellMLToNektar.cellml_metadata::p, tinysimd::sqrt(), and Nektar::SpatialDomains::PointGeom::Sub().
◆ v_VectorFlux()
|
overrideprotectedvirtual |
Reimplemented from Nektar::LocalRegions::Expansion.
Definition at line 2310 of file Expansion2D.cpp.
2312{
2313 const Array<OneD, const Array<OneD, NekDouble>> &normals =
2314 GetLeftAdjacentElementExp()->GetTraceNormal(
2315 GetLeftAdjacentElementTrace());
2316
2318 Array<OneD, NekDouble> Fn(nq);
2319 Vmath::Vmul(nq, &vec[0][0], 1, &normals[0][0], 1, &Fn[0], 1);
2320 Vmath::Vvtvp(nq, &vec[1][0], 1, &normals[1][0], 1, &Fn[0], 1, &Fn[0], 1);
2321 Vmath::Vvtvp(nq, &vec[2][0], 1, &normals[2][0], 1, &Fn[0], 1, &Fn[0], 1);
2322
2323 return StdExpansion::Integral(Fn);
2324}
ExpansionSharedPtr GetLeftAdjacentElementExp() const
Definition: Expansion.h:443
int GetLeftAdjacentElementTrace() const
Definition: Expansion.h:456
References Nektar::LocalRegions::Expansion::GetLeftAdjacentElementExp(), Nektar::LocalRegions::Expansion::GetLeftAdjacentElementTrace(), Nektar::StdRegions::StdExpansion::GetTotPoints(), Vmath::Vmul(), and Vmath::Vvtvp().
Member Data Documentation
◆ m_requireNeg
|
protected |
Definition at line 118 of file Expansion2D.h.
Referenced by v_AddEdgeNormBoundaryInt().
