• Introduction
• Algebra
• Quadrature
• Common functions
• Mesh
• Finite Elements
• Computations
  • Computation of sources
  • Physical index
  • Solution of linear systems
  • Eigenvalue problems
  • Interface with finite elements
• Boundary conditions
• Post-processing
• Solved equations
• Time schemes

Link between finite elements classes and EllipticProblem

We describe here how finite element classes are handled in the class VarFiniteElement. The class EllipticProblem derives from this class. The class VarFiniteElement stores a set a finite element classes. Different finite elements may be needed in the simulation for the following reasons

• Variable order : different orders of approximation are used
• Mixed mesh : the mesh can be hexahedral-dominant (with pyramids, tetrahedra and prisms)
• Functional spaces : an unknown can belong to H¹, whereas another belong to H(curl) space.

We are using this class to construct and store finite element objects.

Methods of class VarFiniteElement (and VarFiniteElement_Base)

AddFiniteElement1D	adds one-dimensional finite element
GetTypeIntegrationBoundary	retrieves the type of quadrature rules for surface integrals
ClearFiniteElement	clears the finite elements stored in the class
AddSurfaceFiniteElement	adds surface finite elements
AddFiniteElement	adds volume finite elements
UpdateInterpolationElement	updates finite elements
CopyFiniteElement	copies finite elements from another class
SetFiniteElement	changes the finite elements to use for a part of elements
GetReferenceElement	returns the reference finite element associated with a given element
GetSurfaceFiniteElement	returns the surface finite element associated with a given surface
SetAxisymGeometry	informs that the 2-D mesh is used for axisymmetric computation
GetReferenceElementH1	returns the reference finite element associated with a given element (for H1 space)
GetSurfaceFiniteElementH1	returns the surface finite element associated with a given face (for H1 space)
GetReferenceElementHcurl	returns the reference finite element associated with a given element (for H(curl) space)
GetSurfaceFiniteElementHcurl	returns the surface finite element associated with a given face (for H(curl) space)
GetReferenceElementHdiv	returns the reference finite element associated with a given element (for H(div) space)
GetNeighborReferenceElement	returns the reference finite element associated with a given neighbor element (parallel)

The class VarFiniteElementEnum lists the finite elements in Montjoie and makes the link between the name (e.g. QUADRANGLE_LOBATTO) and its identification number (an integer). In regular use, this class does not need to be used, only VarFiniteElement should be used.

Methods of class VarFiniteElementEnum

GetIdentityNumber	returns an identification number of the finite element from its name
InitStaticData	initializes the arrays containing identification numbers
GetNewReferenceElement	creates a new instance of the required finite element
GetNewSurfaceElement	creates a new instance of the required surface finite element

AddFiniteElement1D

This method constructs a 1-D finite element following the name given as argument. Some elements can keep the old finite element. The name of the finite element has to be chosen as detailed in the description of TypeElement keyword.

Example :

int main()
{
  VarFiniteElement<Dimension1> var; // it can also be a derived class

  // assuming that a 1-D mesh has been created
  Mesh<Dimension1> mesh; // to complete


  Vector<bool> change_elt(mesh.GetNbElt());
  change_elt.Fill(true); // if you want to affect the same finite element for all elements
  var.AddFiniteElement1D("EDGE_LOBATTO", 4, change_elt, mesh);

  // if one element has a different order :
  int num_elem = 3;
  change_elt.Fill(false); change_elt(num_elem) = true;
  var.AddFiniteElement1D("EDGE_LOBATTO", 6, change_elt, mesh);

  // to retrieve the finite element associated with an element :
  int i = 32;
  const ElementReference<Dimension1, 1>& Fb = var.GetReferenceElementH1(i);
  
   return 0;
}

  

Location :

Harmonic/VarFiniteElement.hxx
Harmonic/VarFiniteElement.cxx

GetTypeIntegrationBoundary

This method retrieves the type of quadrature rules that are used by finite elements of the mesh numberings given as argument. If these rules are not compatible (for example an element use Gauss rules on the edge, whereas another element use Gauss-Lobatto rules), the program is aborted.

Example :

int main()
{
  
    EllipticProblem<HelmholtzEquationDG<Dimension3> > var;;

    // allocating the arrays for physical indexes
    var.InitIndices(100); // we choose N = 100
    var.SetTypeEquation("HELMHOLTZ");
    
    // then you can read the data file
    ReadInputFile("test.ini", var);

    // you can continue the computations
    var.ComputeMeshAndFiniteElement("QUADRANGLE_LOBATTO");

   // you can retrieve the type of quadrature rules
   Vector<MeshNumbering<Dimension3>* > other_mesh_num;
   int type_int_edge, type_int_tri, type_int_quad;
   var.GetTypeIntegrationBoundary(var.mesh, var.GetMeshNumbering(0), other_mesh_num,
                                  type_int_edge, type_int_tri, type_int_quad);

   DISP(type_int_tri); DISP(type_int_quad);
   
   return 0;
}

  

Location :

Harmonic/VarFiniteElement.hxx
Harmonic/VarFiniteElement.cxx

AddFiniteElement

This method creates a set of new finite elements (with orders specified in arguments) and affects them to the required elements. The name of the finite element has to be chosen as detailed in the description of TypeElement. order(0) lists the orders of approximation to create for triangles (in 2-D) and for tetrahedra (in 3-D). order(1) lists the orders of approximation for quadrilaterals in 2-D, pyramids in 3-D. order(2) and order(3) are used for wedges and hexahedra (in 3-D only). For the class EllipticProblem, the user should not call AddFiniteElement since it is alreay called by ComputeMeshAndFiniteElement. The second syntax is more complex and handles the case with several mesh numberings (with different finite elements for each numbering).

Example :

int main()
{
  
  // starting from a mesh
  Mesh<Dimension3> mesh;
  mesh.Read("test.mesh");

  // and a mesh numbering
  MeshNumbering<Dimension3> mesh_num(mesh);
   // you have to fill orders for each element in mesh_num (uniform or variable)

   // here we retrieve the orders present in the mesh numbering
   TinyVector<IVect, 4> order;    
   this->mesh_num.GetOrder(order);

   // no over_integration (put a positive number to over-integrate)
   int r_over_quad = 0;

   // for a continuous formulation
   int dg_form = ElementReference_Base::CONTINUOUS;

   // we want to change all the elements
   VectBool change_elt(mesh.GetNbElt()); change_elt.Fill(true);
   
   // for H^1 elements, type = 1
   VarFiniteElement<Dimension3> var;
   var.AddFiniteElement("HEXAHEDRON_LOBATTO", order, change_elt, mesh, mesh_num,
                        r_over_quad, dg_form, 1);

   // to retrieve the finite element for a given element
   int num_elem = 20;
   const ElementReference<Dimension3, 1>& Fb = var.GetReferenceElementH1(num_elem);
   
   return 0;
}

  

Location :

Harmonic/VarFiniteElement.hxx
Harmonic/VarFiniteElement.cxx

ClearFiniteElement

This method clear previous finite elements created.

Example :

int main()
{
  
  // starting from a mesh
  Mesh<Dimension3> mesh;
  mesh.Read("test.mesh");

  // and a mesh numbering
  MeshNumbering<Dimension3> mesh_num(mesh);
   // you have to fill orders for each element in mesh_num (uniform or variable)

   // here we retrieve the orders present in the mesh numbering
   TinyVector<IVect, 4> order;    
   this->mesh_num.GetOrder(order);

   // no over_integration (put a positive number to over-integrate)
   int r_over_quad = 0;

   // for a continuous formulation
   int dg_form = ElementReference_Base::CONTINUOUS;

   // we want to change all the elements
   VectBool change_elt(mesh.GetNbElt()); change_elt.Fill(true);
   
   // for H^1 elements, type = 1
   VarFiniteElement<Dimension3> var;
   var.AddFiniteElement("HEXAHEDRON_LOBATTO", order, change_elt, mesh, mesh_num,
                        r_over_quad, dg_form, 1);

   // to retrieve the finite element for a given element
   int num_elem = 20;
   const ElementReference<Dimension3, 1>& Fb = var.GetReferenceElementH1(num_elem);

   // if you want to clear finite elements
   var.ClearFiniteElement();

   return 0;
}

  

Location :

Harmonic/VarFiniteElement.hxx
Harmonic/VarFiniteElement.cxx

AddSurfaceFiniteElement

This method creates a set of new surface finite elements (with orders specified in arguments) and affects them to the required surfaces. The name of the finite element has to be chosen as detailed in the description of TypeElement. The methods creates the trace of the finite element on its boundaries. For the class EllipticProblem, the user should not call AddSurfaceFiniteElement since it is alreay called by ComputeMeshAndFiniteElement (for HDG formulation). The second syntax is more complex and handles the case with several mesh numberings (with different finite elements for each numbering).

Example :

int main()
{
  
  // starting from a mesh
  Mesh<Dimension3> mesh;
  mesh.Read("test.mesh");

  // and a mesh numbering
  MeshNumbering<Dimension3> mesh_num(mesh);
   // you have to fill orders for each element in mesh_num (uniform or variable)

   // here we retrieve the orders present in the mesh numbering
   TinyVector<IVect, 4> order, order_quad;    
   this->mesh_num.GetOrder(order);

   // no over_integration (put a positive number to over-integrate)
   int r_over_quad = 0;

   // for a continuous formulation
   int dg_form = ElementReference_Base::CONTINUOUS;

   // we want to change all the elements
   VectBool change_elt(mesh.GetNbElt()); change_elt.Fill(true);
   
   // for H^1 elements, type = 1
   VarFiniteElement<Dimension3> var;
   var.AddFiniteElement("HEXAHEDRON_LOBATTO", order, change_elt, mesh, mesh_num,
                        r_over_quad, dg_form, 1);

  // if you need also trace of finite elements (for unknown lambda in HDG)
  mesh_num.GetOrderQuadrature(order_quad);
  change_elt.Reallocate(mesh.GetNbBoundary()); change_elt.Fill(true);
  var.AddSurfaceFiniteElement("HEXAHEDRON_LOBATTO", order_quad, change_elt, mesh,
                              mesh_num, r_over_quad, dg_form, 1);

   // to retrieve the finite element for a given element
   int num_elem = 20;
   const ElementReference<Dimension3, 1>& Fb = var.GetReferenceElementH1(num_elem);

   // and surface finite element for a given surface
   int num_surf = 11;
   const ElementReference<Dimension2, 1>& Fb_s = var.GetSurfaceFiniteElementH1(num_surf);
   
   return 0;
}

  

Location :

Harmonic/VarFiniteElement.hxx
Harmonic/VarFiniteElement.cxx

UpdateInterpolationElement

This method updates the interpolation operators (used for variable orders) without reconstructing finite element classes. It can be useful if the same orders exist but with a different distribution (faces are affected with different orders of quadrature).

Example :

int main()
{
  
  // starting from a mesh
  Mesh<Dimension3> mesh;
  mesh.Read("test.mesh");

  // and a mesh numbering
  MeshNumbering<Dimension3> mesh_num(mesh);
   // you have to fill orders for each element in mesh_num (uniform or variable)

   // here we retrieve the orders present in the mesh numbering
   TinyVector<IVect, 4> order, order_quad;    
   this->mesh_num.GetOrder(order);

   // no over_integration (put a positive number to over-integrate)
   int r_over_quad = 0;

   // for a continuous formulation
   int dg_form = ElementReference_Base::CONTINUOUS;

   // we want to change all the elements
   VectBool change_elt(mesh.GetNbElt()); change_elt.Fill(true);
   
   // for H^1 elements, type = 1
   VarFiniteElement<Dimension3> var;
   var.AddFiniteElement("HEXAHEDRON_LOBATTO", order, change_elt, mesh, mesh_num,
                        r_over_quad, dg_form, 1);

  // updating finite element (for a different distribution of orders)
  var.UpdateInterpolationElement();
   
   return 0;
}

  

Location :

Harmonic/VarFiniteElement.hxx
Harmonic/VarFiniteElement.cxx

CopyFiniteElement

This method copies the finite elements stored in another class. This copy is a shallow copy such that only pointers are copied.

Example :

int main()
{
  
  // starting from a mesh
  Mesh<Dimension3> mesh;
  mesh.Read("test.mesh");

  // and a mesh numbering
  MeshNumbering<Dimension3> mesh_num(mesh);
   // you have to fill orders for each element in mesh_num (uniform or variable)

   // here we retrieve the orders present in the mesh numbering
   TinyVector<IVect, 4> order, order_quad;    
   this->mesh_num.GetOrder(order);

   // no over_integration (put a positive number to over-integrate)
   int r_over_quad = 0;

   // for a continuous formulation
   int dg_form = ElementReference_Base::CONTINUOUS;

   // we want to change all the elements
   VectBool change_elt(mesh.GetNbElt()); change_elt.Fill(true);
   
   // for H^1 elements, type = 1
   VarFiniteElement<Dimension3> var;
   var.AddFiniteElement("HEXAHEDRON_LOBATTO", order, change_elt, mesh, mesh_num,
                        r_over_quad, dg_form, 1);

   // if you want to copy finite elements to another class var2
   VarFiniteElement<Dimension3> var2;
   Vector<MeshNumbering<Dimension3>*> other_mesh_num; IVect other_type;
   var2.CopyFiniteElement(var, mesh, mesh_num, other_mesh_num, 1, other_type);
   
   return 0;
}

  

Location :

Harmonic/VarFiniteElement.hxx
Harmonic/VarFiniteElement.cxx

SetFiniteElement

This method sets the finite elements to use for elements such that change_elt(i) is true. In this method, we assume that finite elements have been previously created (with AddFiniteElement), and we change only the pointers.

Example :

int main()
{
  
  // starting from a mesh
  Mesh<Dimension3> mesh;
  mesh.Read("test.mesh");

  // and a mesh numbering
  MeshNumbering<Dimension3> mesh_num(mesh);
   // you have to fill orders for each element in mesh_num (uniform or variable)

   // here we retrieve the orders present in the mesh numbering
   TinyVector<IVect, 4> order, order_quad;    
   this->mesh_num.GetOrder(order);

   // no over_integration (put a positive number to over-integrate)
   int r_over_quad = 0;

   // for a continuous formulation
   int dg_form = ElementReference_Base::DISCONTINUOUS;

   // we want to change all the elements
   VectBool change_elt(mesh.GetNbElt()); change_elt.Fill(true);
   
   // for H^1 elements, type = 1
   VarFiniteElement<Dimension3> var;
   var.AddFiniteElement("HEXAHEDRON_LOBATTO", order, change_elt, mesh, mesh_num,
                        r_over_quad, dg_form, 1);

   // if you want to add other finite elements
   VarFiniteElement<Dimension3> var;
   var.AddFiniteElement("TETRAHEDRON_HIERARCHIC", order, change_elt, mesh, mesh_num,
                        r_over_quad, dg_form, 1);

   // you can change some elements to get back to hexahedron_lobatto
   // no finite elements are created, only pointers are modified
   change_elt(3) = false; change_elt(5) = false;
   var.SetFiniteElement("HEXAHEDRON_LOBATTO", change_elt, 1);
   
   return 0;
}

  

Location :

Harmonic/VarFiniteElement.hxx
Harmonic/VarFiniteElement.cxx

GetReferenceElement, GetReferenceElementH1, GetReferenceElementHcurl, GetReferenceElementHdiv

This method returns the finite element associated with the element i. The second argument is optional and is used if there are several mesh numberings. The methods GetReferenceElementH1, GetReferenceElementHcurl, GetReferenceElementHdiv returns the finite element casted with the good type. The last syntax of GetReferenceElement allows to retrieve all the finite elements stored in the class.

Example :

int main()
{
  
  // starting from a mesh
  Mesh<Dimension3> mesh;
  mesh.Read("test.mesh");

  // and a mesh numbering
  MeshNumbering<Dimension3> mesh_num(mesh);
   // you have to fill orders for each element in mesh_num (uniform or variable)

   // here we retrieve the orders present in the mesh numbering
   TinyVector<IVect, 4> order, order_quad;    
   this->mesh_num.GetOrder(order);

   // no over_integration (put a positive number to over-integrate)
   int r_over_quad = 0;

   // for a continuous formulation
   int dg_form = ElementReference_Base::DISCONTINUOUS;

   // we want to change all the elements
   VectBool change_elt(mesh.GetNbElt()); change_elt.Fill(true);
   
   // for H^1 elements, type = 1
   VarFiniteElement<Dimension3> var;
   var.AddFiniteElement("HEXAHEDRON_LOBATTO", order, change_elt, mesh, mesh_num,
                        r_over_quad, dg_form, 1);

   // loop over elements of the mesh
   for (int i = 0; i < mesh.GetNbElt(); i++)
     {
       // we retrieve the finite element associated with element i
       const ElementReference_Dim<Dimension3>& Fb = var.GetReferenceElement(i);

       // if you know that the element is scalar, you can retrieve the leaf class
       const ElementReference<Dimension3, 1>& Fb_s = var.GetReferenceElementH1(i);

       // GetReferenceElementHcurl for edge elements, GetReferenceElementHdiv for facet elements
     }

   // second syntax is less common, and serves to retrieve all the finite elements stored in the class
   // if there is only one finite element (e.g. the mesh is purely hexahedral and the order is uniform), the array will be of length 1
   Vector<const ElementReferece_Dim<Dimension3>* > all_Fb;
   var.GetReferenceElement(all_Fb);

   return 0;
}

  

Location :

Harmonic/VarFiniteElement.hxx
Harmonic/VarFiniteElement.cxx

GetSurfaceFiniteElement, GetSurfaceFiniteElementH1, GetSurfaceFiniteElementHcurl

This method returns the surface finite element associated with the face i. The second argument is optional and is used if there are several mesh numberings. The last syntax allows to retrieve all the surface finite elements stored in the class.

Example :

int main()
{
  
  // starting from a mesh
  Mesh<Dimension3> mesh;
  mesh.Read("test.mesh");

  // and a mesh numbering
  MeshNumbering<Dimension3> mesh_num(mesh);
   // you have to fill orders for each element in mesh_num (uniform or variable)

   // here we retrieve the orders present in the mesh numbering
   TinyVector<IVect, 4> order, order_quad;    
   this->mesh_num.GetOrder(order);

   // no over_integration (put a positive number to over-integrate)
   int r_over_quad = 0;

   // for hdg formulation
   int dg_form = ElementReference_Base::HDG;

   // we want to change all the elements
   VectBool change_elt(mesh.GetNbElt()); change_elt.Fill(true);
   
   // for H^1 elements, type = 1
   VarFiniteElement<Dimension3> var;
   var.AddFiniteElement("HEXAHEDRON_LOBATTO", order, change_elt, mesh, mesh_num,
                        r_over_quad, dg_form, 1);

   // if you need also trace of finite elements (for unknown lambda in HDG)
   mesh_num.GetOrderQuadrature(order_quad);
   change_elt.Reallocate(mesh.GetNbBoundary()); change_elt.Fill(true);
   var.AddSurfaceFiniteElement("HEXAHEDRON_LOBATTO", order_quad, change_elt, mesh,
                               mesh_num, r_over_quad, dg_form, 1);

   // loop over faces of the mesh
   for (int i = 0; i < mesh.GetNbBoundary(); i++)
     {
       // we retrieve the finite element associated with face i
       const ElementReference_Dim<Dimension2>& Fb = var.GetSurfaceFiniteElement(i);

       // if you know that the element is scalar, you can retrieve the leaf class
       const ElementReference<Dimension2, 1>& Fb_s = var.GetSurfaceFiniteElementH1(i);

       // GetSurfaceFiniteElementHcurl for edge elements
     }

   // second syntax is less common, and serves to retrieve all the surface finite elements stored in the class
   // if there is only one finite element (e.g. the mesh is purely hexahedral and the order is uniform), the array will be of length 1
   Vector<const ElementReferece_Dim<Dimension2>* > all_Fb;
   var.GetSurfaceFiniteElement(all_Fb);

   return 0;
}

  

Location :

Harmonic/VarFiniteElement.hxx
Harmonic/VarFiniteElement.cxx

SetAxisymGeometry

This method is called when the solved problem is axisymmetric. This is useful because the curvatures are different from a 2-D planar configuration.

Example :

int main()
{
  
  // starting from a mesh
  Mesh<Dimension2> mesh;
  mesh.Read("test.mesh");

  // and a mesh numbering
  MeshNumbering<Dimension2> mesh_num(mesh);
   // you have to fill orders for each element in mesh_num (uniform or variable)

   // here we retrieve the orders present in the mesh numbering
   TinyVector<IVect, 4> order, order_quad;    
   this->mesh_num.GetOrder(order);

   // no over_integration (put a positive number to over-integrate)
   int r_over_quad = 0;

   // for a continuous formulation
   int dg_form = ElementReference_Base::CONTINUOUS;

   // we want to change all the elements
   VectBool change_elt(mesh.GetNbElt()); change_elt.Fill(true);

   // the computation will be used for axisymmetric geometry
   VarFiniteElement<Dimension2> var;
   var.SetAxisymGeometry(true); // not needed for the common case

   // for H^1 elements, type = 1
   var.AddFiniteElement("QUADRANGLE_LOBATTO", order, change_elt, mesh, mesh_num,
                        r_over_quad, dg_form, 1);

   return 0;
}

  

Location :

Harmonic/VarFiniteElement.hxx
Harmonic/VarFiniteElement.cxx

GetNeighborReferenceElement

This method returns the finite element associated with the neighboring element of face i. It is useful for parallel computations if you need to access to the finite element that is associated with the processor owing the neighbor element.

Example :

int main()
{
  
  // starting from a mesh
  Mesh<Dimension3> mesh;
  mesh.Read("test.mesh");

  // and a mesh numbering
  MeshNumbering<Dimension3> mesh_num(mesh);
   // you have to fill orders for each element in mesh_num (uniform or variable)

   // here we retrieve the orders present in the mesh numbering
   TinyVector<IVect, 4> order, order_quad;    
   this->mesh_num.GetOrder(order);

   // no over_integration (put a positive number to over-integrate)
   int r_over_quad = 0;

   // for a continuous formulation
   int dg_form = ElementReference_Base::DISCONTINUOUS;

   // we want to change all the elements
   VectBool change_elt(mesh.GetNbElt()); change_elt.Fill(true);
   
   // for H^1 elements, type = 1
   VarFiniteElement<Dimension3> var;
   var.AddFiniteElement("HEXAHEDRON_LOBATTO", order, change_elt, mesh, mesh_num,
                        r_over_quad, dg_form, 1);

   // loop over referenced faces of the mesh
   for (int i = 0; i < mesh.GetNbBoundaryRef(); i++)
     {
       // do we have a face on the interface between two processors ?
       int ref = mesh.BoundaryRef(i).GetReference();
       int cond = mesh.GetBoundaryCondition(ref);
       bool neighbor_face = (cond == BoundaryConditionEnum::LINE_NEIGHBOR);

       if (neighbor_face)
         {
           // local number of the face (between neighboring faces)
           int pos_loc = mesh_num.GetLocalEdgeNumberNeighborElement(i);
           
           // we retrieve the finite element associated with the neighbor element
           const ElementReference_Dim<Dimension3>& Fb = var.GetNeighborReferenceElement(pos_loc);
          }
     }

   return 0;
}

  

Location :

Harmonic/VarFiniteElement.hxx
Harmonic/VarFiniteElement.cxx

GetIdentityNumber

This method returns the integer associated with the name of a finite element. For a given dimension and type of finite element, the identification number is unique.

Example :

int main(int argc, char** argv)
{
  InitMontjoie(argc, argv);

  int id = VarFiniteElementEnum<Dimension2, 1>::GetIdentityNumber("QUADRANGLE_LOBATTO", 1);

  // then you can create a finite element with this id
  ElementReference<Dimension2, 1>* Fb = VarFiniteElementEnum<Dimension2, 1>::GetNewReferenceElement(id);

  // and constructs the finite element for a given order
   Fb->ConstructFiniteElement(4);

   return FinalizeMontjoie();
}

  

Location :

Harmonic/VarFiniteElement.hxx
Harmonic/VarFiniteElement.cxx

InitStaticData

This method initializes the mapping between name of finite elements and identification numbers. This method is automatically called by InitMontjoie, and should not be called in regular use.

Example :

int main(int argc, char** argv)
{
  // you do not call  InitMontjoie(argc, argv);
  // then you need to call InitStaticData
  VarFiniteElementEnum<Dimension2, 1>::InitStaticData();

  int id = VarFiniteElementEnum<Dimension2, 1>::GetIdentityNumber("QUADRANGLE_LOBATTO", 1);

  // then you can create a finite element with this id
  ElementReference<Dimension2, 1>* Fb = VarFiniteElementEnum<Dimension2, 1>::GetNewReferenceElement(id);

  // and constructs the finite element for a given order
   Fb->ConstructFiniteElement(4);

   return 0;
}

  

Location :

Harmonic/VarFiniteElement.hxx
Harmonic/VarFiniteElement.cxx

GetNewReferenceElement

This method creates a finite element object by giving its identification number. It is up to the user to delete the created object.

Example :

int main(int argc, char** argv)
{
  InitMontjoie(argc, argv);

  int id = VarFiniteElementEnum<Dimension2, 1>::GetIdentityNumber("QUADRANGLE_LOBATTO", 1);

  // then you can create a finite element with this id
  ElementReference<Dimension2, 1>* Fb = VarFiniteElementEnum<Dimension2, 1>::GetNewReferenceElement(id);

  // and constructs the finite element for a given order
   Fb->ConstructFiniteElement(4);


  // you have to release memory when you no longer need the object
  delete Fb;

   return FinalizeMontjoie();
}

  

Location :

Harmonic/VarFiniteElement.hxx
Harmonic/VarFiniteElement.cxx

GetNewSurfaceElement

This method creates a surface finite element object by giving its identification number. The created surface finite element is the trace of the finite element on a face. The surface finite element is constructed. It is up to the user to delete the created object.

Example :

int main(int argc, char** argv)
{
  InitMontjoie(argc, argv);

  int id = VarFiniteElementEnum<Dimension2, 1>::GetIdentityNumber("QUADRANGLE_LOBATTO", 1);

  // then you can create (and construct) a surface finite element with this id
  ElementReference<Dimension1, 1>* Fb = VarFiniteElementEnum<Dimension2, 1>::GetNewSurfaceElement(4, 4, 4, id);

  // you have to release memory when you no longer need the object
  delete Fb;

   return FinalizeMontjoie();
}

  

Location :

Harmonic/VarFiniteElement.hxx
Harmonic/VarFiniteElement.cxx