html/fe__nd_8hpp_source.html

// Copyright (c) 2010-2025, Lawrence Livermore National Security, LLC. Produced

// at the Lawrence Livermore National Laboratory. All Rights reserved. See files

// LICENSE and NOTICE for details. LLNL-CODE-806117.

//

// This file is part of the MFEM library. For more information and source code

// availability visit https://mfem.org.

//

// MFEM is free software; you can redistribute it and/or modify it under the

// terms of the BSD-3 license. We welcome feedback and contributions, see file

// CONTRIBUTING.md for details.


#ifndef MFEM_FE_ND

#define MFEM_FE_ND


#include "fe_base.hpp"

#include "fe_h1.hpp"

#include "fe_pyramid.hpp"


namespace mfem

{


/// Arbitrary order Nedelec elements in 3D on a cube


class ND_HexahedronElement : public VectorTensorFiniteElement

{

   static const real_t tk[18];

#ifndef MFEM_THREAD_SAFE

   mutable Vector shape_cx, shape_ox, shape_cy, shape_oy, shape_cz, shape_oz;

   mutable Vector dshape_cx, dshape_cy, dshape_cz;

#endif

   Array<int> dof2tk;

   const real_t *cp;


public:

   /** @brief Construct the ND_HexahedronElement of order @a p and closed and

       open BasisType @a cb_type and @a ob_type */

   ND_HexahedronElement(const int p,

                        const int cb_type = BasisType::GaussLobatto,

                        const int ob_type = BasisType::GaussLegendre);


   void CalcVShape(const IntegrationPoint &ip,

                   DenseMatrix &shape) const override;


   void CalcVShape(ElementTransformation &Trans,

                   DenseMatrix &shape) const override

   { CalcVShape_ND(Trans, shape); }

   void CalcVShape(ElementTransformation &Trans, {…}


   void CalcCurlShape(const IntegrationPoint &ip,

                      DenseMatrix &curl_shape) const override;


   void GetLocalInterpolation(ElementTransformation &Trans,

                              DenseMatrix &I) const override

   { LocalInterpolation_ND(*this, tk, dof2tk, Trans, I); }

   void GetLocalInterpolation(ElementTransformation &Trans, {…}


   void GetLocalRestriction(ElementTransformation &Trans,

                            DenseMatrix &R) const override

   { LocalRestriction_ND(tk, dof2tk, Trans, R); }

   void GetLocalRestriction(ElementTransformation &Trans, {…}


   void GetTransferMatrix(const FiniteElement &fe,

                          ElementTransformation &Trans,

                          DenseMatrix &I) const override

   { LocalInterpolation_ND(CheckVectorFE(fe), tk, dof2tk, Trans, I); }

   void GetTransferMatrix(const FiniteElement &fe, {…}


   using FiniteElement::Project;


   void Project(VectorCoefficient &vc,

                ElementTransformation &Trans, Vector &dofs) const override

   {

      if (obasis1d.IsIntegratedType()) { ProjectIntegrated(vc, Trans, dofs); }

      else { Project_ND(tk, dof2tk, vc, Trans, dofs); }

   }

   void Project(VectorCoefficient &vc, {…}


   void ProjectFromNodes(Vector &vc, ElementTransformation &Trans,

                         Vector &dofs) const override

   { Project_ND(tk, dof2tk, vc, Trans, dofs); }

   void ProjectFromNodes(Vector &vc, ElementTransformation &Trans, {…}


   void ProjectMatrixCoefficient(MatrixCoefficient &mc,

                                 ElementTransformation &T,

                                 Vector &dofs) const override

   { ProjectMatrixCoefficient_ND(tk, dof2tk, mc, T, dofs); }

   void ProjectMatrixCoefficient(MatrixCoefficient &mc, {…}


   void Project(const FiniteElement &fe,

                ElementTransformation &Trans,

                DenseMatrix &I) const override

   { Project_ND(tk, dof2tk, fe, Trans, I); }

   void Project(const FiniteElement &fe, {…}


   void ProjectGrad(const FiniteElement &fe,

                    ElementTransformation &Trans,

                    DenseMatrix &grad) const override

   { ProjectGrad_ND(tk, dof2tk, fe, Trans, grad); }

   void ProjectGrad(const FiniteElement &fe, {…}


   void ProjectCurl(const FiniteElement &fe,

                    ElementTransformation &Trans,

                    DenseMatrix &curl) const override

   { ProjectCurl_ND(tk, dof2tk, fe, Trans, curl); }

   void ProjectCurl(const FiniteElement &fe, {…}


   void GetFaceMap(const int face_id, Array<int> &face_map) const override;


protected:

   void ProjectIntegrated(VectorCoefficient &vc,

                          ElementTransformation &Trans,

                          Vector &dofs) const;

};

class ND_HexahedronElement : public VectorTensorFiniteElement {…};


/// Arbitrary order Nedelec elements in 2D on a square


class ND_QuadrilateralElement : public VectorTensorFiniteElement

{

   static const real_t tk[8];


#ifndef MFEM_THREAD_SAFE

   mutable Vector shape_cx, shape_ox, shape_cy, shape_oy;

   mutable Vector dshape_cx, dshape_cy;

#endif

   Array<int> dof2tk;

   const real_t *cp;


public:

   /** @brief Construct the ND_QuadrilateralElement of order @a p and closed and

       open BasisType @a cb_type and @a ob_type */

   ND_QuadrilateralElement(const int p,

                           const int cb_type = BasisType::GaussLobatto,

                           const int ob_type = BasisType::GaussLegendre);

   void CalcVShape(const IntegrationPoint &ip,

                   DenseMatrix &shape) const override;


   void CalcVShape(ElementTransformation &Trans,

                   DenseMatrix &shape) const override

   { CalcVShape_ND(Trans, shape); }

   void CalcVShape(ElementTransformation &Trans, {…}

   void CalcCurlShape(const IntegrationPoint &ip,

                      DenseMatrix &curl_shape) const override;


   void GetLocalInterpolation(ElementTransformation &Trans,

                              DenseMatrix &I) const override

   { LocalInterpolation_ND(*this, tk, dof2tk, Trans, I); }

   void GetLocalInterpolation(ElementTransformation &Trans, {…}


   void GetLocalRestriction(ElementTransformation &Trans,

                            DenseMatrix &R) const override

   { LocalRestriction_ND(tk, dof2tk, Trans, R); }

   void GetLocalRestriction(ElementTransformation &Trans, {…}


   void GetTransferMatrix(const FiniteElement &fe,

                          ElementTransformation &Trans,

                          DenseMatrix &I) const override

   { LocalInterpolation_ND(CheckVectorFE(fe), tk, dof2tk, Trans, I); }

   void GetTransferMatrix(const FiniteElement &fe, {…}

   using FiniteElement::Project;


   void Project(VectorCoefficient &vc,

                ElementTransformation &Trans, Vector &dofs) const override

   {

      if (obasis1d.IsIntegratedType()) { ProjectIntegrated(vc, Trans, dofs); }

      else { Project_ND(tk, dof2tk, vc, Trans, dofs); }

   }

   void Project(VectorCoefficient &vc, {…}


   void ProjectFromNodes(Vector &vc, ElementTransformation &Trans,

                         Vector &dofs) const override

   { Project_ND(tk, dof2tk, vc, Trans, dofs); }

   void ProjectFromNodes(Vector &vc, ElementTransformation &Trans, {…}


   void ProjectMatrixCoefficient(MatrixCoefficient &mc,

                                 ElementTransformation &T,

                                 Vector &dofs) const override

   { ProjectMatrixCoefficient_ND(tk, dof2tk, mc, T, dofs); }

   void ProjectMatrixCoefficient(MatrixCoefficient &mc, {…}


   void Project(const FiniteElement &fe,

                ElementTransformation &Trans,

                DenseMatrix &I) const override

   { Project_ND(tk, dof2tk, fe, Trans, I); }

   void Project(const FiniteElement &fe, {…}


   void ProjectGrad(const FiniteElement &fe,

                    ElementTransformation &Trans,

                    DenseMatrix &grad) const override

   { ProjectGrad_ND(tk, dof2tk, fe, Trans, grad); }

   void ProjectGrad(const FiniteElement &fe, {…}


   void GetFaceMap(const int face_id, Array<int> &face_map) const override;


protected:

   void ProjectIntegrated(VectorCoefficient &vc,

                          ElementTransformation &Trans,

                          Vector &dofs) const;

};

class ND_QuadrilateralElement : public VectorTensorFiniteElement {…};


/// Arbitrary order Nedelec elements in 3D on a tetrahedron


class ND_TetrahedronElement : public VectorFiniteElement

{

   static const real_t tk[18], c;


#ifndef MFEM_THREAD_SAFE

   mutable Vector shape_x, shape_y, shape_z, shape_l;

   mutable Vector dshape_x, dshape_y, dshape_z, dshape_l;

   mutable DenseMatrix u;

#endif

   Array<int> dof2tk;

   DenseMatrixInverse Ti;


   ND_TetDofTransformation doftrans;


public:

   /// Construct the ND_TetrahedronElement of order @a p

   ND_TetrahedronElement(const int p);

   void CalcVShape(const IntegrationPoint &ip,

                   DenseMatrix &shape) const override;


   void CalcVShape(ElementTransformation &Trans,

                   DenseMatrix &shape) const override

   { CalcVShape_ND(Trans, shape); }

   void CalcVShape(ElementTransformation &Trans, {…}

   void CalcCurlShape(const IntegrationPoint &ip,

                      DenseMatrix &curl_shape) const override;


   void GetLocalInterpolation(ElementTransformation &Trans,

                              DenseMatrix &I) const override

   { LocalInterpolation_ND(*this, tk, dof2tk, Trans, I); }

   void GetLocalInterpolation(ElementTransformation &Trans, {…}


   void GetLocalRestriction(ElementTransformation &Trans,

                            DenseMatrix &R) const override

   { LocalRestriction_ND(tk, dof2tk, Trans, R); }

   void GetLocalRestriction(ElementTransformation &Trans, {…}


   void GetTransferMatrix(const FiniteElement &fe,

                          ElementTransformation &Trans,

                          DenseMatrix &I) const override

   { LocalInterpolation_ND(CheckVectorFE(fe), tk, dof2tk, Trans, I); }

   void GetTransferMatrix(const FiniteElement &fe, {…}


   const StatelessDofTransformation *GetDofTransformation() const override

   { return &doftrans; }

   const StatelessDofTransformation *GetDofTransformation() const override {…}

   using FiniteElement::Project;


   void Project(VectorCoefficient &vc,

                ElementTransformation &Trans, Vector &dofs) const override

   { Project_ND(tk, dof2tk, vc, Trans, dofs); }

   void Project(VectorCoefficient &vc, {…}


   void ProjectFromNodes(Vector &vc, ElementTransformation &Trans,

                         Vector &dofs) const override

   { Project_ND(tk, dof2tk, vc, Trans, dofs); }

   void ProjectFromNodes(Vector &vc, ElementTransformation &Trans, {…}


   void ProjectMatrixCoefficient(MatrixCoefficient &mc,

                                 ElementTransformation &T,

                                 Vector &dofs) const override

   { ProjectMatrixCoefficient_ND(tk, dof2tk, mc, T, dofs); }

   void ProjectMatrixCoefficient(MatrixCoefficient &mc, {…}


   void Project(const FiniteElement &fe,

                ElementTransformation &Trans,

                DenseMatrix &I) const override

   { Project_ND(tk, dof2tk, fe, Trans, I); }

   void Project(const FiniteElement &fe, {…}


   void ProjectGrad(const FiniteElement &fe,

                    ElementTransformation &Trans,

                    DenseMatrix &grad) const override

   { ProjectGrad_ND(tk, dof2tk, fe, Trans, grad); }

   void ProjectGrad(const FiniteElement &fe, {…}


   void ProjectCurl(const FiniteElement &fe,

                    ElementTransformation &Trans,

                    DenseMatrix &curl) const override

   { ProjectCurl_ND(tk, dof2tk, fe, Trans, curl); }

   void ProjectCurl(const FiniteElement &fe, {…}

};

class ND_TetrahedronElement : public VectorFiniteElement {…};


/// Arbitrary order Nedelec elements in 2D on a triangle


class ND_TriangleElement : public VectorFiniteElement

{

   static const real_t tk[8], c;


#ifndef MFEM_THREAD_SAFE

   mutable Vector shape_x, shape_y, shape_l;

   mutable Vector dshape_x, dshape_y, dshape_l;

   mutable DenseMatrix u;

   mutable Vector curlu;

#endif

   Array<int> dof2tk;

   DenseMatrixInverse Ti;


   ND_TriDofTransformation doftrans;


public:

   /// Construct the ND_TriangleElement of order @a p

   ND_TriangleElement(const int p);

   void CalcVShape(const IntegrationPoint &ip,

                   DenseMatrix &shape) const override;


   void CalcVShape(ElementTransformation &Trans,

                   DenseMatrix &shape) const override

   { CalcVShape_ND(Trans, shape); }

   void CalcVShape(ElementTransformation &Trans, {…}

   void CalcCurlShape(const IntegrationPoint &ip,

                      DenseMatrix &curl_shape) const override;


   void GetLocalInterpolation(ElementTransformation &Trans,

                              DenseMatrix &I) const override

   { LocalInterpolation_ND(*this, tk, dof2tk, Trans, I); }

   void GetLocalInterpolation(ElementTransformation &Trans, {…}


   void GetLocalRestriction(ElementTransformation &Trans,

                            DenseMatrix &R) const override

   { LocalRestriction_ND(tk, dof2tk, Trans, R); }

   void GetLocalRestriction(ElementTransformation &Trans, {…}


   void GetTransferMatrix(const FiniteElement &fe,

                          ElementTransformation &Trans,

                          DenseMatrix &I) const override

   { LocalInterpolation_ND(CheckVectorFE(fe), tk, dof2tk, Trans, I); }

   void GetTransferMatrix(const FiniteElement &fe, {…}


   const StatelessDofTransformation *GetDofTransformation() const override

   { return &doftrans; }

   const StatelessDofTransformation *GetDofTransformation() const override {…}

   using FiniteElement::Project;


   void Project(VectorCoefficient &vc,

                ElementTransformation &Trans, Vector &dofs) const override

   { Project_ND(tk, dof2tk, vc, Trans, dofs); }

   void Project(VectorCoefficient &vc, {…}


   void ProjectFromNodes(Vector &vc, ElementTransformation &Trans,

                         Vector &dofs) const override

   { Project_ND(tk, dof2tk, vc, Trans, dofs); }

   void ProjectFromNodes(Vector &vc, ElementTransformation &Trans, {…}


   void ProjectMatrixCoefficient(MatrixCoefficient &mc,

                                 ElementTransformation &T,

                                 Vector &dofs) const override

   { ProjectMatrixCoefficient_ND(tk, dof2tk, mc, T, dofs); }

   void ProjectMatrixCoefficient(MatrixCoefficient &mc, {…}


   void Project(const FiniteElement &fe,

                ElementTransformation &Trans,

                DenseMatrix &I) const override

   { Project_ND(tk, dof2tk, fe, Trans, I); }

   void Project(const FiniteElement &fe, {…}


   void ProjectGrad(const FiniteElement &fe,

                    ElementTransformation &Trans,

                    DenseMatrix &grad) const override

   { ProjectGrad_ND(tk, dof2tk, fe, Trans, grad); }

   void ProjectGrad(const FiniteElement &fe, {…}

};

class ND_TriangleElement : public VectorFiniteElement {…};


/// Arbitrary order Nedelec elements in 1D on a segment


class ND_SegmentElement : public VectorTensorFiniteElement

{

   static const real_t tk[1];


   Array<int> dof2tk;


public:

   /** @brief Construct the ND_SegmentElement of order @a p and open

       BasisType @a ob_type */

   ND_SegmentElement(const int p, const int ob_type = BasisType::GaussLegendre);


   void CalcShape(const IntegrationPoint &ip, Vector &shape) const override

   { obasis1d.Eval(ip.x, shape); }

   void CalcShape(const IntegrationPoint &ip, Vector &shape) const override {…}

   void CalcVShape(const IntegrationPoint &ip,

                   DenseMatrix &shape) const override;


   void CalcVShape(ElementTransformation &Trans,

                   DenseMatrix &shape) const override

   { CalcVShape_ND(Trans, shape); }

   void CalcVShape(ElementTransformation &Trans, {…}

   // void CalcCurlShape(const IntegrationPoint &ip,

   //                            DenseMatrix &curl_shape) const;


   void GetLocalInterpolation(ElementTransformation &Trans,

                              DenseMatrix &I) const override

   { LocalInterpolation_ND(*this, tk, dof2tk, Trans, I); }

   void GetLocalInterpolation(ElementTransformation &Trans, {…}


   void GetLocalRestriction(ElementTransformation &Trans,

                            DenseMatrix &R) const override

   { LocalRestriction_ND(tk, dof2tk, Trans, R); }

   void GetLocalRestriction(ElementTransformation &Trans, {…}


   void GetTransferMatrix(const FiniteElement &fe,

                          ElementTransformation &Trans,

                          DenseMatrix &I) const override

   { LocalInterpolation_ND(CheckVectorFE(fe), tk, dof2tk, Trans, I); }

   void GetTransferMatrix(const FiniteElement &fe, {…}

   using FiniteElement::Project;


   void Project(VectorCoefficient &vc,

                ElementTransformation &Trans, Vector &dofs) const override

   { Project_ND(tk, dof2tk, vc, Trans, dofs); }

   void Project(VectorCoefficient &vc, {…}


   void ProjectMatrixCoefficient(MatrixCoefficient &mc,

                                 ElementTransformation &T,

                                 Vector &dofs) const override

   { ProjectMatrixCoefficient_ND(tk, dof2tk, mc, T, dofs); }

   void ProjectMatrixCoefficient(MatrixCoefficient &mc, {…}


   void Project(const FiniteElement &fe,

                ElementTransformation &Trans,

                DenseMatrix &I) const override

   { Project_ND(tk, dof2tk, fe, Trans, I); }

   void Project(const FiniteElement &fe, {…}


   void ProjectGrad(const FiniteElement &fe,

                    ElementTransformation &Trans,

                    DenseMatrix &grad) const override

   { ProjectGrad_ND(tk, dof2tk, fe, Trans, grad); }

   void ProjectGrad(const FiniteElement &fe, {…}

};

class ND_SegmentElement : public VectorTensorFiniteElement {…};


class ND_WedgeElement : public VectorFiniteElement

{

private:

   static const real_t tk[15];


#ifndef MFEM_THREAD_SAFE

   mutable Vector      t1_shape, s1_shape;

   mutable DenseMatrix tn_shape, sn_shape;

   mutable DenseMatrix t1_dshape, s1_dshape, tn_dshape;

#endif

   Array<int> dof2tk, t_dof, s_dof;


   ND_WedgeDofTransformation doftrans;


   H1_TriangleElement H1TriangleFE;

   ND_TriangleElement NDTriangleFE;

   H1_SegmentElement  H1SegmentFE;

   ND_SegmentElement  NDSegmentFE;


public:

   ND_WedgeElement(const int p,

                   const int cb_type = BasisType::GaussLobatto,

                   const int ob_type = BasisType::GaussLegendre);


   void CalcVShape(const IntegrationPoint &ip,

                   DenseMatrix &shape) const override;


   void CalcVShape(ElementTransformation &Trans,

                   DenseMatrix &shape) const override

   { CalcVShape_ND(Trans, shape); }

   void CalcVShape(ElementTransformation &Trans, {…}


   void CalcCurlShape(const IntegrationPoint &ip,

                      DenseMatrix &curl_shape) const override;


   void GetLocalInterpolation(ElementTransformation &Trans,

                              DenseMatrix &I) const override

   { LocalInterpolation_ND(*this, tk, dof2tk, Trans, I); }

   void GetLocalInterpolation(ElementTransformation &Trans, {…}


   void GetLocalRestriction(ElementTransformation &Trans,

                            DenseMatrix &R) const override

   { LocalRestriction_ND(tk, dof2tk, Trans, R); }

   void GetLocalRestriction(ElementTransformation &Trans, {…}


   void GetTransferMatrix(const FiniteElement &fe,

                          ElementTransformation &Trans,

                          DenseMatrix &I) const override

   { LocalInterpolation_ND(CheckVectorFE(fe), tk, dof2tk, Trans, I); }

   void GetTransferMatrix(const FiniteElement &fe, {…}


   const StatelessDofTransformation *GetDofTransformation() const override

   { return &doftrans; }

   const StatelessDofTransformation *GetDofTransformation() const override {…}


   using FiniteElement::Project;


   void Project(VectorCoefficient &vc,

                ElementTransformation &Trans, Vector &dofs) const override

   { Project_ND(tk, dof2tk, vc, Trans, dofs); }

   void Project(VectorCoefficient &vc, {…}


   void ProjectMatrixCoefficient(MatrixCoefficient &mc,

                                 ElementTransformation &T,

                                 Vector &dofs) const override

   { ProjectMatrixCoefficient_ND(tk, dof2tk, mc, T, dofs); }

   void ProjectMatrixCoefficient(MatrixCoefficient &mc, {…}


   void Project(const FiniteElement &fe,

                ElementTransformation &Trans,

                DenseMatrix &I) const override

   { Project_ND(tk, dof2tk, fe, Trans, I); }

   void Project(const FiniteElement &fe, {…}


   void ProjectGrad(const FiniteElement &fe,

                    ElementTransformation &Trans,

                    DenseMatrix &grad) const override

   { ProjectGrad_ND(tk, dof2tk, fe, Trans, grad); }

   void ProjectGrad(const FiniteElement &fe, {…}


   void ProjectCurl(const FiniteElement &fe,

                    ElementTransformation &Trans,

                    DenseMatrix &curl) const override

   { ProjectCurl_ND(tk, dof2tk, fe, Trans, curl); }

   void ProjectCurl(const FiniteElement &fe, {…}

};

class ND_WedgeElement : public VectorFiniteElement {…};


/** Arbitrary order H(Curl) basis functions defined on pyramid-shaped elements


  This implementation is closely based on the finite elements

  described in section 9.2 of the paper "Orientation embedded high

  order shape functions for the exact sequence elements of all shapes"

  by Federico Fuentes, Brendan Keith, Leszek Demkowicz, and Sriram

  Nagaraj, see https://doi.org/10.1016/j.camwa.2015.04.027.

 */


class ND_FuentesPyramidElement

   : public VectorFiniteElement, public FuentesPyramid

{

private:

   static const real_t tk[27];


   mutable real_t zmax;


#ifndef MFEM_THREAD_SAFE

   mutable DenseMatrix tmp_E_E_ij;

   mutable DenseMatrix tmp_dE_E_ij;

   mutable DenseTensor tmp_E_Q1_ijk;

   mutable DenseTensor tmp_dE_Q1_ijk;

   mutable DenseTensor tmp_E_Q2_ijk;

   mutable DenseTensor tmp_dE_Q2_ijk;

   mutable DenseTensor tmp_E_T_ijk;

   mutable DenseTensor tmp_dE_T_ijk;

   mutable DenseMatrix tmp_phi_Q1_ij;

   mutable DenseTensor tmp_dphi_Q1_ij;

   mutable DenseMatrix tmp_phi_Q2_ij;

   mutable DenseTensor tmp_dphi_Q2_ij;

   mutable Vector      tmp_phi_E_i;

   mutable DenseMatrix tmp_dphi_E_i;

   mutable DenseMatrix u;

   mutable DenseMatrix curlu;

#endif

   Array<int> dof2tk;

   DenseMatrixInverse Ti;


   ND_PyramidDofTransformation doftrans;


   void calcBasis(const int p, const IntegrationPoint & ip,

                  DenseMatrix & E_E_ik,

                  DenseTensor & E_Q1_ijk,

                  DenseTensor & E_Q2_ijk,

                  DenseTensor & E_T_ijk,

                  DenseMatrix & phi_Q1_ij,

                  DenseTensor & dphi_Q1_ij,

                  DenseMatrix & phi_Q2_ij,

                  Vector      & phi_E_k,

                  DenseMatrix & dphi_E_k,

                  DenseMatrix & W) const;


   void calcCurlBasis(const int p, const IntegrationPoint & ip,

                      DenseMatrix & E_E_ik,

                      DenseMatrix & dE_E_ik,

                      DenseTensor & E_Q1_ijk,

                      DenseTensor & dE_Q1_ijk,

                      DenseTensor & E_Q2_ijk,

                      DenseTensor & dE_Q2_ijk,

                      DenseTensor & E_T_ijk,

                      DenseTensor & dE_T_ijk,

                      DenseMatrix & phi_Q2_ij,

                      DenseTensor & dphi_Q2_ij,

                      Vector      & phi_E_k,

                      DenseMatrix & dphi_E_k,

                      DenseMatrix & dW) const;


public:

   ND_FuentesPyramidElement(const int p,

                            const int cb_type = BasisType::GaussLobatto,

                            const int ob_type = BasisType::GaussLegendre);

   virtual void CalcVShape(const IntegrationPoint &ip,

                           DenseMatrix &shape) const;


   virtual void CalcVShape(ElementTransformation &Trans,

                           DenseMatrix &shape) const

   { CalcVShape_ND(Trans, shape); }

   virtual void CalcVShape(ElementTransformation &Trans, {…}

   virtual void CalcCurlShape(const IntegrationPoint &ip,

                              DenseMatrix &curl_shape) const;


   virtual void GetLocalInterpolation(ElementTransformation &Trans,

                                      DenseMatrix &I) const

   { LocalInterpolation_ND(*this, tk, dof2tk, Trans, I); }

   virtual void GetLocalInterpolation(ElementTransformation &Trans, {…}


   virtual void GetLocalRestriction(ElementTransformation &Trans,

                                    DenseMatrix &R) const

   { LocalRestriction_ND(tk, dof2tk, Trans, R); }

   virtual void GetLocalRestriction(ElementTransformation &Trans, {…}


   virtual void GetTransferMatrix(const FiniteElement &fe,

                                  ElementTransformation &Trans,

                                  DenseMatrix &I) const

   { LocalInterpolation_ND(CheckVectorFE(fe), tk, dof2tk, Trans, I); }

   virtual void GetTransferMatrix(const FiniteElement &fe, {…}


   using FiniteElement::Project;


   virtual void Project(VectorCoefficient &vc,

                        ElementTransformation &Trans, Vector &dofs) const

   { Project_ND(tk, dof2tk, vc, Trans, dofs); }

   virtual void Project(VectorCoefficient &vc, {…}


   virtual void ProjectMatrixCoefficient(

      MatrixCoefficient &mc, ElementTransformation &T, Vector &dofs) const

   { ProjectMatrixCoefficient_ND(tk, dof2tk, mc, T, dofs); }

   virtual void ProjectMatrixCoefficient( {…}


   virtual void Project(const FiniteElement &fe, ElementTransformation &Trans,

                        DenseMatrix &I) const

   { Project_ND(tk, dof2tk, fe, Trans, I); }

   virtual void Project(const FiniteElement &fe, ElementTransformation &Trans, {…}


   virtual void ProjectGrad(const FiniteElement &fe,

                            ElementTransformation &Trans,

                            DenseMatrix &grad) const

   { ProjectGrad_ND(tk, dof2tk, fe, Trans, grad); }

   virtual void ProjectGrad(const FiniteElement &fe, {…}


   virtual void ProjectCurl(const FiniteElement &fe,

                            ElementTransformation &Trans,

                            DenseMatrix &curl) const

   { ProjectCurl_ND(tk, dof2tk, fe, Trans, curl); }

   virtual void ProjectCurl(const FiniteElement &fe, {…}


   void CalcRawVShape(const IntegrationPoint &ip,

                      DenseMatrix &shape) const;


   void CalcRawCurlShape(const IntegrationPoint &ip,

                         DenseMatrix &dshape) const;


   real_t GetZetaMax() const { return zmax; }

};

class ND_FuentesPyramidElement {…};


/// A 0D Nedelec finite element for the boundary of a 1D domain

/** ND_R1D_PointElement provides a representation of the trace of a three

    component Nedelec basis restricted to 1D.

*/


class ND_R1D_PointElement : public VectorFiniteElement

{

   static const real_t tk[9];


public:

   /** @brief Construct the ND_R1D_PointElement */

   ND_R1D_PointElement(int p);


   using FiniteElement::CalcVShape;


   void CalcVShape(const IntegrationPoint &ip,

                   DenseMatrix &shape) const override;


   void CalcVShape(ElementTransformation &Trans,

                   DenseMatrix &shape) const override;

};

class ND_R1D_PointElement : public VectorFiniteElement {…};


/// Arbitrary order, three component, Nedelec elements in 1D on a segment

/** ND_R1D_SegmentElement provides a representation of a three component Nedelec

    basis where the vector components vary along only one dimension.

*/


class ND_R1D_SegmentElement : public VectorFiniteElement

{

   static const real_t tk[9];

#ifndef MFEM_THREAD_SAFE

   mutable Vector shape_cx, shape_ox;

   mutable Vector dshape_cx;

#endif

   Array<int> dof_map, dof2tk;


   Poly_1D::Basis &cbasis1d, &obasis1d;


public:

   /** @brief Construct the ND_R1D_SegmentElement of order @a p and closed and

       open BasisType @a cb_type and @a ob_type */

   ND_R1D_SegmentElement(const int p,

                         const int cb_type = BasisType::GaussLobatto,

                         const int ob_type = BasisType::GaussLegendre);


   using FiniteElement::CalcVShape;

   using FiniteElement::CalcPhysCurlShape;


   void CalcVShape(const IntegrationPoint &ip,

                   DenseMatrix &shape) const override;


   void CalcVShape(ElementTransformation &Trans,

                   DenseMatrix &shape) const override;


   void CalcCurlShape(const IntegrationPoint &ip,

                      DenseMatrix &curl_shape) const override;


   void CalcPhysCurlShape(ElementTransformation &Trans,

                          DenseMatrix &curl_shape) const override;


   void GetLocalInterpolation(ElementTransformation &Trans,

                              DenseMatrix &I) const override

   { LocalInterpolation_ND(*this, tk, dof2tk, Trans, I); }

   void GetLocalInterpolation(ElementTransformation &Trans, {…}


   void GetLocalRestriction(ElementTransformation &Trans,

                            DenseMatrix &R) const override

   { LocalRestriction_ND(tk, dof2tk, Trans, R); }

   void GetLocalRestriction(ElementTransformation &Trans, {…}


   void GetTransferMatrix(const FiniteElement &fe,

                          ElementTransformation &Trans,

                          DenseMatrix &I) const override

   { LocalInterpolation_ND(CheckVectorFE(fe), tk, dof2tk, Trans, I); }

   void GetTransferMatrix(const FiniteElement &fe, {…}


   using FiniteElement::Project;


   void Project(VectorCoefficient &vc,

                ElementTransformation &Trans, Vector &dofs) const override;


   void ProjectFromNodes(Vector &vc, ElementTransformation &Trans,

                         Vector &dofs) const override

   { Project_ND(tk, dof2tk, vc, Trans, dofs); }

   void ProjectFromNodes(Vector &vc, ElementTransformation &Trans, {…}


   void ProjectMatrixCoefficient(MatrixCoefficient &mc,

                                 ElementTransformation &T,

                                 Vector &dofs) const override

   { ProjectMatrixCoefficient_ND(tk, dof2tk, mc, T, dofs); }

   void ProjectMatrixCoefficient(MatrixCoefficient &mc, {…}


   void Project(const FiniteElement &fe,

                ElementTransformation &Trans,

                DenseMatrix &I) const override;


   void ProjectGrad(const FiniteElement &fe,

                    ElementTransformation &Trans,

                    DenseMatrix &grad) const override

   { ProjectGrad_ND(tk, dof2tk, fe, Trans, grad); }

   void ProjectGrad(const FiniteElement &fe, {…}


   void ProjectCurl(const FiniteElement &fe,

                    ElementTransformation &Trans,

                    DenseMatrix &curl) const override

   { ProjectCurl_ND(tk, dof2tk, fe, Trans, curl); }

   void ProjectCurl(const FiniteElement &fe, {…}

};

class ND_R1D_SegmentElement : public VectorFiniteElement {…};


/** ND_R2D_SegmentElement provides a representation of a 3D Nedelec

    basis where the vector field is assumed constant in the third dimension.

*/


class ND_R2D_SegmentElement : public VectorFiniteElement

{

   static const real_t tk[4];

#ifndef MFEM_THREAD_SAFE

   mutable Vector shape_cx, shape_ox;

   mutable Vector dshape_cx;

#endif

   Array<int> dof_map, dof2tk;


   Poly_1D::Basis &cbasis1d, &obasis1d;


private:

   void LocalInterpolation(const VectorFiniteElement &cfe,

                           ElementTransformation &Trans,

                           DenseMatrix &I) const;


public:

   /** @brief Construct the ND_R2D_SegmentElement of order @a p and closed and

       open BasisType @a cb_type and @a ob_type */

   ND_R2D_SegmentElement(const int p,

                         const int cb_type = BasisType::GaussLobatto,

                         const int ob_type = BasisType::GaussLegendre);


   void CalcVShape(const IntegrationPoint &ip,

                   DenseMatrix &shape) const override;


   void CalcVShape(ElementTransformation &Trans,

                   DenseMatrix &shape) const override;


   void CalcCurlShape(const IntegrationPoint &ip,

                      DenseMatrix &curl_shape) const override;


   void GetLocalInterpolation(ElementTransformation &Trans,

                              DenseMatrix &I) const override

   { LocalInterpolation(*this, Trans, I); }

   void GetLocalInterpolation(ElementTransformation &Trans, {…}


   void GetLocalRestriction(ElementTransformation &Trans,

                            DenseMatrix &R) const override

   { MFEM_ABORT("method is not overloaded"); }

   void GetLocalRestriction(ElementTransformation &Trans, {…}


   void GetTransferMatrix(const FiniteElement &fe,

                          ElementTransformation &Trans,

                          DenseMatrix &I) const override

   { LocalInterpolation(CheckVectorFE(fe), Trans, I); }

   void GetTransferMatrix(const FiniteElement &fe, {…}


   using FiniteElement::Project;


   void Project(VectorCoefficient &vc,

                ElementTransformation &Trans, Vector &dofs) const override;

};

class ND_R2D_SegmentElement : public VectorFiniteElement {…};


class ND_R2D_FiniteElement : public VectorFiniteElement

{

protected:

   const real_t *tk;

   Array<int> dof_map, dof2tk;


   ND_R2D_FiniteElement(int p, Geometry::Type G, int Do, const real_t *tk_fe);


private:

   void LocalInterpolation(const VectorFiniteElement &cfe,

                           ElementTransformation &Trans,

                           DenseMatrix &I) const;


public:

   using FiniteElement::CalcVShape;

   using FiniteElement::CalcPhysCurlShape;


   void CalcVShape(ElementTransformation &Trans,

                   DenseMatrix &shape) const override;


   void CalcPhysCurlShape(ElementTransformation &Trans,

                          DenseMatrix &curl_shape) const override;


   void GetLocalInterpolation(ElementTransformation &Trans,

                              DenseMatrix &I) const override

   { LocalInterpolation(*this, Trans, I); }

   void GetLocalInterpolation(ElementTransformation &Trans, {…}


   void GetLocalRestriction(ElementTransformation &Trans,

                            DenseMatrix &R) const override;


   void GetTransferMatrix(const FiniteElement &fe,

                          ElementTransformation &Trans,

                          DenseMatrix &I) const override

   { LocalInterpolation(CheckVectorFE(fe), Trans, I); }

   void GetTransferMatrix(const FiniteElement &fe, {…}


   using FiniteElement::Project;


   void Project(VectorCoefficient &vc,

                ElementTransformation &Trans, Vector &dofs) const override;


   void Project(const FiniteElement &fe, ElementTransformation &Trans,

                DenseMatrix &I) const override;


   void ProjectGrad(const FiniteElement &fe,

                    ElementTransformation &Trans,

                    DenseMatrix &grad) const override;

};

class ND_R2D_FiniteElement : public VectorFiniteElement {…};


/// Arbitrary order Nedelec 3D elements in 2D on a triangle


class ND_R2D_TriangleElement : public ND_R2D_FiniteElement

{

private:

   static const real_t tk_t[15];


#ifndef MFEM_THREAD_SAFE

   mutable DenseMatrix nd_shape;

   mutable Vector      h1_shape;

   mutable DenseMatrix nd_dshape;

   mutable DenseMatrix h1_dshape;

#endif


   ND_TriangleElement ND_FE;

   H1_TriangleElement H1_FE;


public:

   /// Construct the ND_R2D_TriangleElement of order @a p

   ND_R2D_TriangleElement(const int p,

                          const int cb_type = BasisType::GaussLobatto);


   using ND_R2D_FiniteElement::CalcVShape;

   using ND_R2D_FiniteElement::CalcPhysCurlShape;


   void CalcVShape(const IntegrationPoint &ip,

                   DenseMatrix &shape) const override;

   void CalcCurlShape(const IntegrationPoint &ip,

                      DenseMatrix &curl_shape) const override;

};

class ND_R2D_TriangleElement : public ND_R2D_FiniteElement {…};


/// Arbitrary order Nedelec 3D elements in 2D on a square


class ND_R2D_QuadrilateralElement : public ND_R2D_FiniteElement

{

   static const real_t tk_q[15];


#ifndef MFEM_THREAD_SAFE

   mutable Vector shape_cx, shape_ox, shape_cy, shape_oy;

   mutable Vector dshape_cx, dshape_cy;

#endif


   Poly_1D::Basis &cbasis1d, &obasis1d;


public:

   /** @brief Construct the ND_R2D_QuadrilateralElement of order @a p and

       closed and open BasisType @a cb_type and @a ob_type */

   ND_R2D_QuadrilateralElement(const int p,

                               const int cb_type = BasisType::GaussLobatto,

                               const int ob_type = BasisType::GaussLegendre);


   using ND_R2D_FiniteElement::CalcVShape;

   using ND_R2D_FiniteElement::CalcPhysCurlShape;


   void CalcVShape(const IntegrationPoint &ip,

                   DenseMatrix &shape) const override;

   void CalcCurlShape(const IntegrationPoint &ip,

                      DenseMatrix &curl_shape) const override;

};

class ND_R2D_QuadrilateralElement : public ND_R2D_FiniteElement {…};


} // namespace mfem


#endif

mfem::Array
Definition array.hpp:47

mfem::BasisType::GaussLobatto
@ GaussLobatto
Closed type.
Definition fe_base.hpp:36

mfem::BasisType::GaussLegendre
@ GaussLegendre
Open type.
Definition fe_base.hpp:35

mfem::DenseMatrixInverse
Definition densemat.hpp:838

mfem::DenseMatrix
Data type dense matrix using column-major storage.
Definition densemat.hpp:24

mfem::DenseTensor
Rank 3 tensor (array of matrices)
Definition densemat.hpp:1112

mfem::ElementTransformation
Definition eltrans.hpp:28

mfem::FiniteElement
Abstract class for all finite elements.
Definition fe_base.hpp:244

mfem::FiniteElement::CalcVShape
virtual void CalcVShape(const IntegrationPoint &ip, DenseMatrix &shape) const
Evaluate the values of all shape functions of a vector finite element in reference space at the given...
Definition fe_base.cpp:40

mfem::FiniteElement::Project
virtual void Project(Coefficient &coeff, ElementTransformation &Trans, Vector &dofs) const
Given a coefficient and a transformation, compute its projection (approximation) in the local finite ...
Definition fe_base.cpp:126

mfem::FiniteElement::CalcPhysCurlShape
virtual void CalcPhysCurlShape(ElementTransformation &Trans, DenseMatrix &curl_shape) const
Evaluate the curl of all shape functions of a vector finite element in physical space at the point de...
Definition fe_base.cpp:71

mfem::FuentesPyramid
Definition fe_pyramid.hpp:39

mfem::Geometry::Type
Type
Definition geom.hpp:40

mfem::H1_SegmentElement
Arbitrary order H1 elements in 1D.
Definition fe_h1.hpp:23

mfem::H1_TriangleElement
Arbitrary order H1 elements in 2D on a triangle.
Definition fe_h1.hpp:85

mfem::IntegrationPoint
Class for integration point with weight.
Definition intrules.hpp:35

mfem::IntegrationPoint::x
real_t x
Definition intrules.hpp:37

mfem::MatrixCoefficient
Base class for Matrix Coefficients that optionally depend on time and space.
Definition coefficient.hpp:1047

mfem::ND_FuentesPyramidElement
Definition fe_nd.hpp:429

mfem::ND_FuentesPyramidElement::ProjectGrad
virtual void ProjectGrad(const FiniteElement &fe, ElementTransformation &Trans, DenseMatrix &grad) const
Compute the discrete gradient matrix from the given FiniteElement onto 'this' FiniteElement....
Definition fe_nd.hpp:519

mfem::ND_FuentesPyramidElement::Project
virtual void Project(const FiniteElement &fe, ElementTransformation &Trans, DenseMatrix &I) const
Compute the embedding/projection matrix from the given FiniteElement onto 'this' FiniteElement....
Definition fe_nd.hpp:515

mfem::ND_FuentesPyramidElement::CalcRawVShape
void CalcRawVShape(const IntegrationPoint &ip, DenseMatrix &shape) const
Definition fe_nd.cpp:1840

mfem::ND_FuentesPyramidElement::GetZetaMax
real_t GetZetaMax() const
Definition fe_nd.hpp:535

mfem::ND_FuentesPyramidElement::CalcVShape
virtual void CalcVShape(ElementTransformation &Trans, DenseMatrix &shape) const
Evaluate the values of all shape functions of a vector finite element in physical space at the point ...
Definition fe_nd.hpp:491

mfem::ND_FuentesPyramidElement::CalcRawCurlShape
void CalcRawCurlShape(const IntegrationPoint &ip, DenseMatrix &dshape) const
Definition fe_nd.cpp:1862

mfem::ND_FuentesPyramidElement::Project
virtual void Project(VectorCoefficient &vc, ElementTransformation &Trans, Vector &dofs) const
Given a vector coefficient and a transformation, compute its projection (approximation) in the local ...
Definition fe_nd.hpp:509

mfem::ND_FuentesPyramidElement::GetLocalRestriction
virtual void GetLocalRestriction(ElementTransformation &Trans, DenseMatrix &R) const
Return a local restriction matrix R (Dof x Dof) mapping fine dofs to coarse dofs.
Definition fe_nd.hpp:499

mfem::ND_FuentesPyramidElement::GetLocalInterpolation
virtual void GetLocalInterpolation(ElementTransformation &Trans, DenseMatrix &I) const
Return the local interpolation matrix I (Dof x Dof) where the fine element is the image of the base g...
Definition fe_nd.hpp:496

mfem::ND_FuentesPyramidElement::ProjectCurl
virtual void ProjectCurl(const FiniteElement &fe, ElementTransformation &Trans, DenseMatrix &curl) const
Compute the discrete curl matrix from the given FiniteElement onto 'this' FiniteElement....
Definition fe_nd.hpp:524

mfem::ND_FuentesPyramidElement::ProjectMatrixCoefficient
virtual void ProjectMatrixCoefficient(MatrixCoefficient &mc, ElementTransformation &T, Vector &dofs) const
Given a matrix coefficient and a transformation, compute an approximation ("projection") in the local...
Definition fe_nd.hpp:512

mfem::ND_FuentesPyramidElement::ND_FuentesPyramidElement
ND_FuentesPyramidElement(const int p, const int cb_type=BasisType::GaussLobatto, const int ob_type=BasisType::GaussLegendre)
Definition fe_nd.cpp:1591

mfem::ND_FuentesPyramidElement::CalcVShape
virtual void CalcVShape(const IntegrationPoint &ip, DenseMatrix &shape) const
Evaluate the values of all shape functions of a vector finite element in reference space at the given...
Definition fe_nd.cpp:1786

mfem::ND_FuentesPyramidElement::GetTransferMatrix
virtual void GetTransferMatrix(const FiniteElement &fe, ElementTransformation &Trans, DenseMatrix &I) const
Return interpolation matrix, I, which maps dofs from a coarse element, fe, to the fine dofs on this f...
Definition fe_nd.hpp:502

mfem::ND_FuentesPyramidElement::CalcCurlShape
virtual void CalcCurlShape(const IntegrationPoint &ip, DenseMatrix &curl_shape) const
Evaluate the curl of all shape functions of a vector finite element in reference space at the given p...
Definition fe_nd.cpp:1811

mfem::ND_HexahedronElement
Arbitrary order Nedelec elements in 3D on a cube.
Definition fe_nd.hpp:24

mfem::ND_HexahedronElement::ProjectFromNodes
void ProjectFromNodes(Vector &vc, ElementTransformation &Trans, Vector &dofs) const override
Given a vector of values at the finite element nodes and a transformation, compute its projection (ap...
Definition fe_nd.hpp:72

mfem::ND_HexahedronElement::Project
void Project(VectorCoefficient &vc, ElementTransformation &Trans, Vector &dofs) const override
Given a vector coefficient and a transformation, compute its projection (approximation) in the local ...
Definition fe_nd.hpp:65

mfem::ND_HexahedronElement::ND_HexahedronElement
ND_HexahedronElement(const int p, const int cb_type=BasisType::GaussLobatto, const int ob_type=BasisType::GaussLegendre)
Construct the ND_HexahedronElement of order p and closed and open BasisType cb_type and ob_type.
Definition fe_nd.cpp:26

mfem::ND_HexahedronElement::ProjectGrad
void ProjectGrad(const FiniteElement &fe, ElementTransformation &Trans, DenseMatrix &grad) const override
Compute the discrete gradient matrix from the given FiniteElement onto 'this' FiniteElement....
Definition fe_nd.hpp:86

mfem::ND_HexahedronElement::ProjectCurl
void ProjectCurl(const FiniteElement &fe, ElementTransformation &Trans, DenseMatrix &curl) const override
Compute the discrete curl matrix from the given FiniteElement onto 'this' FiniteElement....
Definition fe_nd.hpp:91

mfem::ND_HexahedronElement::GetLocalRestriction
void GetLocalRestriction(ElementTransformation &Trans, DenseMatrix &R) const override
Return a local restriction matrix R (Dof x Dof) mapping fine dofs to coarse dofs.
Definition fe_nd.hpp:54

mfem::ND_HexahedronElement::GetLocalInterpolation
void GetLocalInterpolation(ElementTransformation &Trans, DenseMatrix &I) const override
Return the local interpolation matrix I (Dof x Dof) where the fine element is the image of the base g...
Definition fe_nd.hpp:50

mfem::ND_HexahedronElement::GetFaceMap
void GetFaceMap(const int face_id, Array< int > &face_map) const override
Return the mapping from lexicographic face DOFs to lexicographic element DOFs for the given local fac...
Definition fe_nd.cpp:485

mfem::ND_HexahedronElement::ProjectMatrixCoefficient
void ProjectMatrixCoefficient(MatrixCoefficient &mc, ElementTransformation &T, Vector &dofs) const override
Given a matrix coefficient and a transformation, compute an approximation ("projection") in the local...
Definition fe_nd.hpp:76

mfem::ND_HexahedronElement::ProjectIntegrated
void ProjectIntegrated(VectorCoefficient &vc, ElementTransformation &Trans, Vector &dofs) const
Definition fe_nd.cpp:245

mfem::ND_HexahedronElement::CalcVShape
void CalcVShape(const IntegrationPoint &ip, DenseMatrix &shape) const override
Evaluate the values of all shape functions of a vector finite element in reference space at the given...
Definition fe_nd.cpp:310

mfem::ND_HexahedronElement::Project
void Project(const FiniteElement &fe, ElementTransformation &Trans, DenseMatrix &I) const override
Compute the embedding/projection matrix from the given FiniteElement onto 'this' FiniteElement....
Definition fe_nd.hpp:81

mfem::ND_HexahedronElement::GetTransferMatrix
void GetTransferMatrix(const FiniteElement &fe, ElementTransformation &Trans, DenseMatrix &I) const override
Return interpolation matrix, I, which maps dofs from a coarse element, fe, to the fine dofs on this f...
Definition fe_nd.hpp:58

mfem::ND_HexahedronElement::CalcCurlShape
void CalcCurlShape(const IntegrationPoint &ip, DenseMatrix &curl_shape) const override
Evaluate the curl of all shape functions of a vector finite element in reference space at the given p...
Definition fe_nd.cpp:400

mfem::ND_HexahedronElement::CalcVShape
void CalcVShape(ElementTransformation &Trans, DenseMatrix &shape) const override
Evaluate the values of all shape functions of a vector finite element in physical space at the point ...
Definition fe_nd.hpp:43

mfem::ND_PyramidDofTransformation
DoF transformation implementation for the Nedelec basis on pyramid elements.
Definition doftrans.hpp:373

mfem::ND_QuadrilateralElement
Arbitrary order Nedelec elements in 2D on a square.
Definition fe_nd.hpp:107

mfem::ND_QuadrilateralElement::ND_QuadrilateralElement
ND_QuadrilateralElement(const int p, const int cb_type=BasisType::GaussLobatto, const int ob_type=BasisType::GaussLegendre)
Construct the ND_QuadrilateralElement of order p and closed and open BasisType cb_type and ob_type.
Definition fe_nd.cpp:533

mfem::ND_QuadrilateralElement::CalcVShape
void CalcVShape(const IntegrationPoint &ip, DenseMatrix &shape) const override
Evaluate the values of all shape functions of a vector finite element in reference space at the given...
Definition fe_nd.cpp:700

mfem::ND_QuadrilateralElement::GetFaceMap
void GetFaceMap(const int face_id, Array< int > &face_map) const override
Return the mapping from lexicographic face DOFs to lexicographic element DOFs for the given local fac...
Definition fe_nd.cpp:820

mfem::ND_QuadrilateralElement::Project
void Project(const FiniteElement &fe, ElementTransformation &Trans, DenseMatrix &I) const override
Compute the embedding/projection matrix from the given FiniteElement onto 'this' FiniteElement....
Definition fe_nd.hpp:154

mfem::ND_QuadrilateralElement::CalcCurlShape
void CalcCurlShape(const IntegrationPoint &ip, DenseMatrix &curl_shape) const override
Evaluate the curl of all shape functions of a vector finite element in reference space at the given p...
Definition fe_nd.cpp:763

mfem::ND_QuadrilateralElement::GetLocalInterpolation
void GetLocalInterpolation(ElementTransformation &Trans, DenseMatrix &I) const override
Return the local interpolation matrix I (Dof x Dof) where the fine element is the image of the base g...
Definition fe_nd.hpp:130

mfem::ND_QuadrilateralElement::ProjectFromNodes
void ProjectFromNodes(Vector &vc, ElementTransformation &Trans, Vector &dofs) const override
Given a vector of values at the finite element nodes and a transformation, compute its projection (ap...
Definition fe_nd.hpp:147

mfem::ND_QuadrilateralElement::ProjectGrad
void ProjectGrad(const FiniteElement &fe, ElementTransformation &Trans, DenseMatrix &grad) const override
Compute the discrete gradient matrix from the given FiniteElement onto 'this' FiniteElement....
Definition fe_nd.hpp:158

mfem::ND_QuadrilateralElement::ProjectIntegrated
void ProjectIntegrated(VectorCoefficient &vc, ElementTransformation &Trans, Vector &dofs) const
Definition fe_nd.cpp:624

mfem::ND_QuadrilateralElement::ProjectMatrixCoefficient
void ProjectMatrixCoefficient(MatrixCoefficient &mc, ElementTransformation &T, Vector &dofs) const override
Given a matrix coefficient and a transformation, compute an approximation ("projection") in the local...
Definition fe_nd.hpp:150

mfem::ND_QuadrilateralElement::CalcVShape
void CalcVShape(ElementTransformation &Trans, DenseMatrix &shape) const override
Evaluate the values of all shape functions of a vector finite element in physical space at the point ...
Definition fe_nd.hpp:125

mfem::ND_QuadrilateralElement::GetLocalRestriction
void GetLocalRestriction(ElementTransformation &Trans, DenseMatrix &R) const override
Return a local restriction matrix R (Dof x Dof) mapping fine dofs to coarse dofs.
Definition fe_nd.hpp:133

mfem::ND_QuadrilateralElement::GetTransferMatrix
void GetTransferMatrix(const FiniteElement &fe, ElementTransformation &Trans, DenseMatrix &I) const override
Return interpolation matrix, I, which maps dofs from a coarse element, fe, to the fine dofs on this f...
Definition fe_nd.hpp:136

mfem::ND_QuadrilateralElement::Project
void Project(VectorCoefficient &vc, ElementTransformation &Trans, Vector &dofs) const override
Given a vector coefficient and a transformation, compute its projection (approximation) in the local ...
Definition fe_nd.hpp:141

mfem::ND_R1D_PointElement
A 0D Nedelec finite element for the boundary of a 1D domain.
Definition fe_nd.hpp:544

mfem::ND_R1D_PointElement::CalcVShape
void CalcVShape(const IntegrationPoint &ip, DenseMatrix &shape) const override
Evaluate the values of all shape functions of a vector finite element in reference space at the given...
Definition fe_nd.cpp:2543

mfem::ND_R1D_PointElement::ND_R1D_PointElement
ND_R1D_PointElement(int p)
Construct the ND_R1D_PointElement.
Definition fe_nd.cpp:2532

mfem::ND_R1D_SegmentElement
Arbitrary order, three component, Nedelec elements in 1D on a segment.
Definition fe_nd.hpp:565

mfem::ND_R1D_SegmentElement::CalcVShape
void CalcVShape(const IntegrationPoint &ip, DenseMatrix &shape) const override
Evaluate the values of all shape functions of a vector finite element in reference space at the given...
Definition fe_nd.cpp:2625

mfem::ND_R1D_SegmentElement::ND_R1D_SegmentElement
ND_R1D_SegmentElement(const int p, const int cb_type=BasisType::GaussLobatto, const int ob_type=BasisType::GaussLegendre)
Construct the ND_R1D_SegmentElement of order p and closed and open BasisType cb_type and ob_type.
Definition fe_nd.cpp:2561

mfem::ND_R1D_SegmentElement::ProjectCurl
void ProjectCurl(const FiniteElement &fe, ElementTransformation &Trans, DenseMatrix &curl) const override
Compute the discrete curl matrix from the given FiniteElement onto 'this' FiniteElement....
Definition fe_nd.hpp:633

mfem::ND_R1D_SegmentElement::CalcPhysCurlShape
void CalcPhysCurlShape(ElementTransformation &Trans, DenseMatrix &curl_shape) const override
Evaluate the curl of all shape functions of a vector finite element in physical space at the point de...
Definition fe_nd.cpp:2718

mfem::ND_R1D_SegmentElement::ProjectGrad
void ProjectGrad(const FiniteElement &fe, ElementTransformation &Trans, DenseMatrix &grad) const override
Compute the discrete gradient matrix from the given FiniteElement onto 'this' FiniteElement....
Definition fe_nd.hpp:628

mfem::ND_R1D_SegmentElement::GetLocalInterpolation
void GetLocalInterpolation(ElementTransformation &Trans, DenseMatrix &I) const override
Return the local interpolation matrix I (Dof x Dof) where the fine element is the image of the base g...
Definition fe_nd.hpp:597

mfem::ND_R1D_SegmentElement::GetTransferMatrix
void GetTransferMatrix(const FiniteElement &fe, ElementTransformation &Trans, DenseMatrix &I) const override
Return interpolation matrix, I, which maps dofs from a coarse element, fe, to the fine dofs on this f...
Definition fe_nd.hpp:605

mfem::ND_R1D_SegmentElement::ProjectFromNodes
void ProjectFromNodes(Vector &vc, ElementTransformation &Trans, Vector &dofs) const override
Given a vector of values at the finite element nodes and a transformation, compute its projection (ap...
Definition fe_nd.hpp:615

mfem::ND_R1D_SegmentElement::CalcCurlShape
void CalcCurlShape(const IntegrationPoint &ip, DenseMatrix &curl_shape) const override
Evaluate the curl of all shape functions of a vector finite element in reference space at the given p...
Definition fe_nd.cpp:2678

mfem::ND_R1D_SegmentElement::Project
void Project(VectorCoefficient &vc, ElementTransformation &Trans, Vector &dofs) const override
Given a vector coefficient and a transformation, compute its projection (approximation) in the local ...
Definition fe_nd.cpp:2729

mfem::ND_R1D_SegmentElement::ProjectMatrixCoefficient
void ProjectMatrixCoefficient(MatrixCoefficient &mc, ElementTransformation &T, Vector &dofs) const override
Given a matrix coefficient and a transformation, compute an approximation ("projection") in the local...
Definition fe_nd.hpp:619

mfem::ND_R1D_SegmentElement::GetLocalRestriction
void GetLocalRestriction(ElementTransformation &Trans, DenseMatrix &R) const override
Return a local restriction matrix R (Dof x Dof) mapping fine dofs to coarse dofs.
Definition fe_nd.hpp:601

mfem::ND_R2D_FiniteElement
Definition fe_nd.hpp:695

mfem::ND_R2D_FiniteElement::ND_R2D_FiniteElement
ND_R2D_FiniteElement(int p, Geometry::Type G, int Do, const real_t *tk_fe)
Definition fe_nd.cpp:3023

mfem::ND_R2D_FiniteElement::GetLocalInterpolation
void GetLocalInterpolation(ElementTransformation &Trans, DenseMatrix &I) const override
Return the local interpolation matrix I (Dof x Dof) where the fine element is the image of the base g...
Definition fe_nd.hpp:717

mfem::ND_R2D_FiniteElement::GetTransferMatrix
void GetTransferMatrix(const FiniteElement &fe, ElementTransformation &Trans, DenseMatrix &I) const override
Return interpolation matrix, I, which maps dofs from a coarse element, fe, to the fine dofs on this f...
Definition fe_nd.hpp:724

mfem::ND_R2D_FiniteElement::dof2tk
Array< int > dof2tk
Definition fe_nd.hpp:698

mfem::ND_R2D_FiniteElement::CalcPhysCurlShape
void CalcPhysCurlShape(ElementTransformation &Trans, DenseMatrix &curl_shape) const override
Evaluate the curl of all shape functions of a vector finite element in physical space at the point de...
Definition fe_nd.cpp:3058

mfem::ND_R2D_FiniteElement::Project
void Project(VectorCoefficient &vc, ElementTransformation &Trans, Vector &dofs) const override
Given a vector coefficient and a transformation, compute its projection (approximation) in the local ...
Definition fe_nd.cpp:3167

mfem::ND_R2D_FiniteElement::tk
const real_t * tk
Definition fe_nd.hpp:697

mfem::ND_R2D_FiniteElement::dof_map
Array< int > dof_map
Definition fe_nd.hpp:698

mfem::ND_R2D_FiniteElement::CalcVShape
void CalcVShape(ElementTransformation &Trans, DenseMatrix &shape) const override
Evaluate the values of all shape functions of a vector finite element in physical space at the point ...
Definition fe_nd.cpp:3041

mfem::ND_R2D_FiniteElement::ProjectGrad
void ProjectGrad(const FiniteElement &fe, ElementTransformation &Trans, DenseMatrix &grad) const override
Compute the discrete gradient matrix from the given FiniteElement onto 'this' FiniteElement....
Definition fe_nd.cpp:3279

mfem::ND_R2D_FiniteElement::GetLocalRestriction
void GetLocalRestriction(ElementTransformation &Trans, DenseMatrix &R) const override
Return a local restriction matrix R (Dof x Dof) mapping fine dofs to coarse dofs.
Definition fe_nd.cpp:3121

mfem::ND_R2D_QuadrilateralElement
Arbitrary order Nedelec 3D elements in 2D on a square.
Definition fe_nd.hpp:775

mfem::ND_R2D_QuadrilateralElement::CalcCurlShape
void CalcCurlShape(const IntegrationPoint &ip, DenseMatrix &curl_shape) const override
Evaluate the curl of all shape functions of a vector finite element in reference space at the given p...
Definition fe_nd.cpp:3631

mfem::ND_R2D_QuadrilateralElement::ND_R2D_QuadrilateralElement
ND_R2D_QuadrilateralElement(const int p, const int cb_type=BasisType::GaussLobatto, const int ob_type=BasisType::GaussLegendre)
Construct the ND_R2D_QuadrilateralElement of order p and closed and open BasisType cb_type and ob_typ...
Definition fe_nd.cpp:3444

mfem::ND_R2D_QuadrilateralElement::CalcVShape
void CalcVShape(const IntegrationPoint &ip, DenseMatrix &shape) const override
Evaluate the values of all shape functions of a vector finite element in reference space at the given...
Definition fe_nd.cpp:3571

mfem::ND_R2D_SegmentElement
Definition fe_nd.hpp:644

mfem::ND_R2D_SegmentElement::Project
void Project(VectorCoefficient &vc, ElementTransformation &Trans, Vector &dofs) const override
Given a vector coefficient and a transformation, compute its projection (approximation) in the local ...
Definition fe_nd.cpp:2998

mfem::ND_R2D_SegmentElement::ND_R2D_SegmentElement
ND_R2D_SegmentElement(const int p, const int cb_type=BasisType::GaussLobatto, const int ob_type=BasisType::GaussLegendre)
Construct the ND_R2D_SegmentElement of order p and closed and open BasisType cb_type and ob_type.
Definition fe_nd.cpp:2838

mfem::ND_R2D_SegmentElement::CalcVShape
void CalcVShape(const IntegrationPoint &ip, DenseMatrix &shape) const override
Evaluate the values of all shape functions of a vector finite element in reference space at the given...
Definition fe_nd.cpp:2887

mfem::ND_R2D_SegmentElement::GetLocalRestriction
void GetLocalRestriction(ElementTransformation &Trans, DenseMatrix &R) const override
Return a local restriction matrix R (Dof x Dof) mapping fine dofs to coarse dofs.
Definition fe_nd.hpp:679

mfem::ND_R2D_SegmentElement::CalcCurlShape
void CalcCurlShape(const IntegrationPoint &ip, DenseMatrix &curl_shape) const override
Evaluate the curl of all shape functions of a vector finite element in reference space at the given p...
Definition fe_nd.cpp:2930

mfem::ND_R2D_SegmentElement::GetTransferMatrix
void GetTransferMatrix(const FiniteElement &fe, ElementTransformation &Trans, DenseMatrix &I) const override
Return interpolation matrix, I, which maps dofs from a coarse element, fe, to the fine dofs on this f...
Definition fe_nd.hpp:683

mfem::ND_R2D_SegmentElement::GetLocalInterpolation
void GetLocalInterpolation(ElementTransformation &Trans, DenseMatrix &I) const override
Return the local interpolation matrix I (Dof x Dof) where the fine element is the image of the base g...
Definition fe_nd.hpp:675

mfem::ND_R2D_TriangleElement
Arbitrary order Nedelec 3D elements in 2D on a triangle.
Definition fe_nd.hpp:744

mfem::ND_R2D_TriangleElement::ND_R2D_TriangleElement
ND_R2D_TriangleElement(const int p, const int cb_type=BasisType::GaussLobatto)
Construct the ND_R2D_TriangleElement of order p.
Definition fe_nd.cpp:3303

mfem::ND_R2D_TriangleElement::CalcCurlShape
void CalcCurlShape(const IntegrationPoint &ip, DenseMatrix &curl_shape) const override
Evaluate the curl of all shape functions of a vector finite element in reference space at the given p...
Definition fe_nd.cpp:3411

mfem::ND_R2D_TriangleElement::CalcVShape
void CalcVShape(const IntegrationPoint &ip, DenseMatrix &shape) const override
Evaluate the values of all shape functions of a vector finite element in reference space at the given...
Definition fe_nd.cpp:3382

mfem::ND_SegmentElement
Arbitrary order Nedelec elements in 1D on a segment.
Definition fe_nd.hpp:297

mfem::ND_SegmentElement::ProjectGrad
void ProjectGrad(const FiniteElement &fe, ElementTransformation &Trans, DenseMatrix &grad) const override
Compute the discrete gradient matrix from the given FiniteElement onto 'this' FiniteElement....
Definition fe_nd.hpp:337

mfem::ND_SegmentElement::ND_SegmentElement
ND_SegmentElement(const int p, const int ob_type=BasisType::GaussLegendre)
Construct the ND_SegmentElement of order p and open BasisType ob_type.
Definition fe_nd.cpp:1268

mfem::ND_SegmentElement::CalcVShape
void CalcVShape(ElementTransformation &Trans, DenseMatrix &shape) const override
Evaluate the values of all shape functions of a vector finite element in physical space at the point ...
Definition fe_nd.hpp:310

mfem::ND_SegmentElement::ProjectMatrixCoefficient
void ProjectMatrixCoefficient(MatrixCoefficient &mc, ElementTransformation &T, Vector &dofs) const override
Given a matrix coefficient and a transformation, compute an approximation ("projection") in the local...
Definition fe_nd.hpp:329

mfem::ND_SegmentElement::CalcVShape
void CalcVShape(const IntegrationPoint &ip, DenseMatrix &shape) const override
Evaluate the values of all shape functions of a vector finite element in reference space at the given...
Definition fe_nd.cpp:1285

mfem::ND_SegmentElement::GetTransferMatrix
void GetTransferMatrix(const FiniteElement &fe, ElementTransformation &Trans, DenseMatrix &I) const override
Return interpolation matrix, I, which maps dofs from a coarse element, fe, to the fine dofs on this f...
Definition fe_nd.hpp:321

mfem::ND_SegmentElement::CalcShape
void CalcShape(const IntegrationPoint &ip, Vector &shape) const override
Evaluate the values of all shape functions of a scalar finite element in reference space at the given...
Definition fe_nd.hpp:306

mfem::ND_SegmentElement::GetLocalInterpolation
void GetLocalInterpolation(ElementTransformation &Trans, DenseMatrix &I) const override
Return the local interpolation matrix I (Dof x Dof) where the fine element is the image of the base g...
Definition fe_nd.hpp:315

mfem::ND_SegmentElement::GetLocalRestriction
void GetLocalRestriction(ElementTransformation &Trans, DenseMatrix &R) const override
Return a local restriction matrix R (Dof x Dof) mapping fine dofs to coarse dofs.
Definition fe_nd.hpp:318

mfem::ND_SegmentElement::Project
void Project(VectorCoefficient &vc, ElementTransformation &Trans, Vector &dofs) const override
Given a vector coefficient and a transformation, compute its projection (approximation) in the local ...
Definition fe_nd.hpp:326

mfem::ND_SegmentElement::Project
void Project(const FiniteElement &fe, ElementTransformation &Trans, DenseMatrix &I) const override
Compute the embedding/projection matrix from the given FiniteElement onto 'this' FiniteElement....
Definition fe_nd.hpp:333

mfem::ND_TetDofTransformation
DoF transformation implementation for the Nedelec basis on tetrahedra.
Definition doftrans.hpp:350

mfem::ND_TetrahedronElement
Arbitrary order Nedelec elements in 3D on a tetrahedron.
Definition fe_nd.hpp:174

mfem::ND_TetrahedronElement::ProjectMatrixCoefficient
void ProjectMatrixCoefficient(MatrixCoefficient &mc, ElementTransformation &T, Vector &dofs) const override
Given a matrix coefficient and a transformation, compute an approximation ("projection") in the local...
Definition fe_nd.hpp:216

mfem::ND_TetrahedronElement::ProjectFromNodes
void ProjectFromNodes(Vector &vc, ElementTransformation &Trans, Vector &dofs) const override
Given a vector of values at the finite element nodes and a transformation, compute its projection (ap...
Definition fe_nd.hpp:213

mfem::ND_TetrahedronElement::Project
void Project(VectorCoefficient &vc, ElementTransformation &Trans, Vector &dofs) const override
Given a vector coefficient and a transformation, compute its projection (approximation) in the local ...
Definition fe_nd.hpp:210

mfem::ND_TetrahedronElement::GetLocalRestriction
void GetLocalRestriction(ElementTransformation &Trans, DenseMatrix &R) const override
Return a local restriction matrix R (Dof x Dof) mapping fine dofs to coarse dofs.
Definition fe_nd.hpp:200

mfem::ND_TetrahedronElement::ProjectGrad
void ProjectGrad(const FiniteElement &fe, ElementTransformation &Trans, DenseMatrix &grad) const override
Compute the discrete gradient matrix from the given FiniteElement onto 'this' FiniteElement....
Definition fe_nd.hpp:224

mfem::ND_TetrahedronElement::GetLocalInterpolation
void GetLocalInterpolation(ElementTransformation &Trans, DenseMatrix &I) const override
Return the local interpolation matrix I (Dof x Dof) where the fine element is the image of the base g...
Definition fe_nd.hpp:197

mfem::ND_TetrahedronElement::CalcCurlShape
void CalcCurlShape(const IntegrationPoint &ip, DenseMatrix &curl_shape) const override
Evaluate the curl of all shape functions of a vector finite element in reference space at the given p...
Definition fe_nd.cpp:1036

mfem::ND_TetrahedronElement::ProjectCurl
void ProjectCurl(const FiniteElement &fe, ElementTransformation &Trans, DenseMatrix &curl) const override
Compute the discrete curl matrix from the given FiniteElement onto 'this' FiniteElement....
Definition fe_nd.hpp:229

mfem::ND_TetrahedronElement::ND_TetrahedronElement
ND_TetrahedronElement(const int p)
Construct the ND_TetrahedronElement of order p.
Definition fe_nd.cpp:846

mfem::ND_TetrahedronElement::CalcVShape
void CalcVShape(const IntegrationPoint &ip, DenseMatrix &shape) const override
Evaluate the values of all shape functions of a vector finite element in reference space at the given...
Definition fe_nd.cpp:994

mfem::ND_TetrahedronElement::CalcVShape
void CalcVShape(ElementTransformation &Trans, DenseMatrix &shape) const override
Evaluate the values of all shape functions of a vector finite element in physical space at the point ...
Definition fe_nd.hpp:192

mfem::ND_TetrahedronElement::GetTransferMatrix
void GetTransferMatrix(const FiniteElement &fe, ElementTransformation &Trans, DenseMatrix &I) const override
Return interpolation matrix, I, which maps dofs from a coarse element, fe, to the fine dofs on this f...
Definition fe_nd.hpp:203

mfem::ND_TetrahedronElement::GetDofTransformation
const StatelessDofTransformation * GetDofTransformation() const override
Return a DoF transformation object for this particular type of basis.
Definition fe_nd.hpp:207

mfem::ND_TetrahedronElement::Project
void Project(const FiniteElement &fe, ElementTransformation &Trans, DenseMatrix &I) const override
Compute the embedding/projection matrix from the given FiniteElement onto 'this' FiniteElement....
Definition fe_nd.hpp:220

mfem::ND_TriDofTransformation
Definition doftrans.hpp:339

mfem::ND_TriangleElement
Arbitrary order Nedelec elements in 2D on a triangle.
Definition fe_nd.hpp:237

mfem::ND_TriangleElement::GetLocalRestriction
void GetLocalRestriction(ElementTransformation &Trans, DenseMatrix &R) const override
Return a local restriction matrix R (Dof x Dof) mapping fine dofs to coarse dofs.
Definition fe_nd.hpp:264

mfem::ND_TriangleElement::GetTransferMatrix
void GetTransferMatrix(const FiniteElement &fe, ElementTransformation &Trans, DenseMatrix &I) const override
Return interpolation matrix, I, which maps dofs from a coarse element, fe, to the fine dofs on this f...
Definition fe_nd.hpp:267

mfem::ND_TriangleElement::CalcVShape
void CalcVShape(const IntegrationPoint &ip, DenseMatrix &shape) const override
Evaluate the values of all shape functions of a vector finite element in reference space at the given...
Definition fe_nd.cpp:1189

mfem::ND_TriangleElement::CalcVShape
void CalcVShape(ElementTransformation &Trans, DenseMatrix &shape) const override
Evaluate the values of all shape functions of a vector finite element in physical space at the point ...
Definition fe_nd.hpp:256

mfem::ND_TriangleElement::ProjectMatrixCoefficient
void ProjectMatrixCoefficient(MatrixCoefficient &mc, ElementTransformation &T, Vector &dofs) const override
Given a matrix coefficient and a transformation, compute an approximation ("projection") in the local...
Definition fe_nd.hpp:280

mfem::ND_TriangleElement::CalcCurlShape
void CalcCurlShape(const IntegrationPoint &ip, DenseMatrix &curl_shape) const override
Evaluate the curl of all shape functions of a vector finite element in reference space at the given p...
Definition fe_nd.cpp:1223

mfem::ND_TriangleElement::Project
void Project(const FiniteElement &fe, ElementTransformation &Trans, DenseMatrix &I) const override
Compute the embedding/projection matrix from the given FiniteElement onto 'this' FiniteElement....
Definition fe_nd.hpp:284

mfem::ND_TriangleElement::ProjectFromNodes
void ProjectFromNodes(Vector &vc, ElementTransformation &Trans, Vector &dofs) const override
Given a vector of values at the finite element nodes and a transformation, compute its projection (ap...
Definition fe_nd.hpp:277

mfem::ND_TriangleElement::Project
void Project(VectorCoefficient &vc, ElementTransformation &Trans, Vector &dofs) const override
Given a vector coefficient and a transformation, compute its projection (approximation) in the local ...
Definition fe_nd.hpp:274

mfem::ND_TriangleElement::ProjectGrad
void ProjectGrad(const FiniteElement &fe, ElementTransformation &Trans, DenseMatrix &grad) const override
Compute the discrete gradient matrix from the given FiniteElement onto 'this' FiniteElement....
Definition fe_nd.hpp:288

mfem::ND_TriangleElement::GetDofTransformation
const StatelessDofTransformation * GetDofTransformation() const override
Return a DoF transformation object for this particular type of basis.
Definition fe_nd.hpp:271

mfem::ND_TriangleElement::ND_TriangleElement
ND_TriangleElement(const int p)
Construct the ND_TriangleElement of order p.
Definition fe_nd.cpp:1108

mfem::ND_TriangleElement::GetLocalInterpolation
void GetLocalInterpolation(ElementTransformation &Trans, DenseMatrix &I) const override
Return the local interpolation matrix I (Dof x Dof) where the fine element is the image of the base g...
Definition fe_nd.hpp:261

mfem::ND_WedgeDofTransformation
DoF transformation implementation for the Nedelec basis on wedge elements.
Definition doftrans.hpp:361

mfem::ND_WedgeElement
Definition fe_nd.hpp:344

mfem::ND_WedgeElement::Project
void Project(const FiniteElement &fe, ElementTransformation &Trans, DenseMatrix &I) const override
Compute the embedding/projection matrix from the given FiniteElement onto 'this' FiniteElement....
Definition fe_nd.hpp:402

mfem::ND_WedgeElement::GetTransferMatrix
void GetTransferMatrix(const FiniteElement &fe, ElementTransformation &Trans, DenseMatrix &I) const override
Return interpolation matrix, I, which maps dofs from a coarse element, fe, to the fine dofs on this f...
Definition fe_nd.hpp:383

mfem::ND_WedgeElement::CalcVShape
void CalcVShape(const IntegrationPoint &ip, DenseMatrix &shape) const override
Evaluate the values of all shape functions of a vector finite element in reference space at the given...
Definition fe_nd.cpp:1512

mfem::ND_WedgeElement::GetDofTransformation
const StatelessDofTransformation * GetDofTransformation() const override
Return a DoF transformation object for this particular type of basis.
Definition fe_nd.hpp:388

mfem::ND_WedgeElement::GetLocalInterpolation
void GetLocalInterpolation(ElementTransformation &Trans, DenseMatrix &I) const override
Return the local interpolation matrix I (Dof x Dof) where the fine element is the image of the base g...
Definition fe_nd.hpp:377

mfem::ND_WedgeElement::ProjectMatrixCoefficient
void ProjectMatrixCoefficient(MatrixCoefficient &mc, ElementTransformation &T, Vector &dofs) const override
Given a matrix coefficient and a transformation, compute an approximation ("projection") in the local...
Definition fe_nd.hpp:397

mfem::ND_WedgeElement::ProjectCurl
void ProjectCurl(const FiniteElement &fe, ElementTransformation &Trans, DenseMatrix &curl) const override
Compute the discrete curl matrix from the given FiniteElement onto 'this' FiniteElement....
Definition fe_nd.hpp:412

mfem::ND_WedgeElement::ProjectGrad
void ProjectGrad(const FiniteElement &fe, ElementTransformation &Trans, DenseMatrix &grad) const override
Compute the discrete gradient matrix from the given FiniteElement onto 'this' FiniteElement....
Definition fe_nd.hpp:407

mfem::ND_WedgeElement::Project
void Project(VectorCoefficient &vc, ElementTransformation &Trans, Vector &dofs) const override
Given a vector coefficient and a transformation, compute its projection (approximation) in the local ...
Definition fe_nd.hpp:393

mfem::ND_WedgeElement::CalcCurlShape
void CalcCurlShape(const IntegrationPoint &ip, DenseMatrix &curl_shape) const override
Evaluate the curl of all shape functions of a vector finite element in reference space at the given p...
Definition fe_nd.cpp:1546

mfem::ND_WedgeElement::CalcVShape
void CalcVShape(ElementTransformation &Trans, DenseMatrix &shape) const override
Evaluate the values of all shape functions of a vector finite element in physical space at the point ...
Definition fe_nd.hpp:370

mfem::ND_WedgeElement::GetLocalRestriction
void GetLocalRestriction(ElementTransformation &Trans, DenseMatrix &R) const override
Return a local restriction matrix R (Dof x Dof) mapping fine dofs to coarse dofs.
Definition fe_nd.hpp:380

mfem::ND_WedgeElement::ND_WedgeElement
ND_WedgeElement(const int p, const int cb_type=BasisType::GaussLobatto, const int ob_type=BasisType::GaussLegendre)
Definition fe_nd.cpp:1296

mfem::Poly_1D::Basis
Class for evaluating 1D nodal, positive (Bernstein), or integrated (Gerritsma) bases.
Definition fe_base.hpp:1003

mfem::Poly_1D::Basis::Eval
void Eval(const real_t x, Vector &u) const
Evaluate the basis functions at point x in [0,1].
Definition fe_base.cpp:1777

mfem::Poly_1D::Basis::IsIntegratedType
bool IsIntegratedType() const
Returns true if the basis is "integrated", false otherwise.
Definition fe_base.hpp:1047

mfem::StatelessDofTransformation
Definition doftrans.hpp:69

mfem::VectorCoefficient
Base class for vector Coefficients that optionally depend on time and space.
Definition coefficient.hpp:567

mfem::VectorFiniteElement
Intermediate class for finite elements whose basis functions return vector values.
Definition fe_base.hpp:813

mfem::VectorFiniteElement::Project_ND
void Project_ND(const real_t *tk, const Array< int > &d2t, VectorCoefficient &vc, ElementTransformation &Trans, Vector &dofs) const
Project a vector coefficient onto the ND basis functions.
Definition fe_base.cpp:1306

mfem::VectorFiniteElement::ProjectMatrixCoefficient_ND
void ProjectMatrixCoefficient_ND(const real_t *tk, const Array< int > &d2t, MatrixCoefficient &mc, ElementTransformation &T, Vector &dofs) const
Project the rows of the matrix coefficient in an ND space.
Definition fe_base.cpp:1335

mfem::VectorFiniteElement::LocalRestriction_ND
void LocalRestriction_ND(const real_t *tk, const Array< int > &d2t, ElementTransformation &Trans, DenseMatrix &R) const
Definition fe_base.cpp:1671

mfem::VectorFiniteElement::ProjectGrad_ND
void ProjectGrad_ND(const real_t *tk, const Array< int > &d2t, const FiniteElement &fe, ElementTransformation &Trans, DenseMatrix &grad) const
Definition fe_base.cpp:1434

mfem::VectorFiniteElement::CalcVShape_ND
void CalcVShape_ND(ElementTransformation &Trans, DenseMatrix &shape) const
Definition fe_base.cpp:1071

mfem::VectorFiniteElement::LocalInterpolation_ND
void LocalInterpolation_ND(const VectorFiniteElement &cfe, const real_t *tk, const Array< int > &d2t, ElementTransformation &Trans, DenseMatrix &I) const
Definition fe_base.cpp:1589

mfem::VectorFiniteElement::CheckVectorFE
static const VectorFiniteElement & CheckVectorFE(const FiniteElement &fe)
Definition fe_base.hpp:973

mfem::VectorFiniteElement::ProjectCurl_ND
void ProjectCurl_ND(const real_t *tk, const Array< int > &d2t, const FiniteElement &fe, ElementTransformation &Trans, DenseMatrix &curl) const
Definition fe_base.cpp:1249

mfem::VectorTensorFiniteElement
Definition fe_base.hpp:1337

mfem::VectorTensorFiniteElement::obasis1d
Poly_1D::Basis & obasis1d
Definition fe_base.hpp:1342

mfem::Vector
Vector data type.
Definition vector.hpp:82

fe_base.hpp

fe_h1.hpp

fe_pyramid.hpp

mfem
Definition CodeDocumentation.dox:1

mfem::real_t
float real_t
Definition config.hpp:43

p
real_t p(const Vector &x, real_t t)
Definition navier_mms.cpp:53