Manipulation of meshes in 3-D

GetReference for Edge<Dimension3>

Syntax

int GetReference() const

This method returns the reference number associated with the edge. This reference number is usually determined in the definition of the geometry of the mesh. If you are using Gmsh, it is the number you specify just after Physical Line.

Example :

Mesh<Dimension3> mesh;
// you read a mesh
mesh.Read("test.mesh");
// then you loop over referenced edges
for (int i = 0: i < mesh.GetNbEdgesRef(); i++)
  if (mesh.EdgeRef(i).GetReference() == 2)
    cout << "Edge " << mesh.EdgeRef(i) << endl;

Location :

SetReference for Edge<Dimension3>

Syntax

void SetReference(int ref)

This method changes the reference number associated with the edge.

Example :

Mesh<Dimension3> mesh;
// you read a mesh
mesh.Read("test.mesh");

// then you loop over referenced edges to change ref 2 to ref 3
for (int i = 0: i < mesh.GetNbEdgesRef(); i++)
  if (mesh.EdgeRef(i).GetReference() == 2)
    mesh.BoundaryRef(i).SetReference(3);

Location :

numVertex for Edge<Dimension3>

Syntax

int numVertex(int j) const

This method returns the vertex number of an extremity (first or second). You can't change the vertex number, only retrieve it with that method. If you want to change extremities, you have to use Init.

Example :

Mesh<Dimension3> mesh;
// you read a mesh
mesh.Read("test.mesh");
// then you display extremities of referenced edges
for (int i = 0: i < mesh.GetNbEdgesRef(); i++)
  {
    cout << "First extremity " << mesh.EdgeRef(i).numVertex(0) << endl;
    cout << "Second extremity " << mesh.EdgeRef(i).numVertex(1) << endl;
  }

Location :

GetNbVertices() for Edge<Dimension3>

Syntax

int GetNbVertices() const

This method returns 2 since there are two vertices on an edge.

Location :

ClearConnectivity for Edge<Dimension3>

Syntax

void ClearConnectivity()

This method removes informations about elements sharing the edge. After that call, there is no elements and no faces associated with the edge. Usually, this low-level method is not used, since you can clear connectivity of all the mesh with method ClearConnectivity.

Example :

Mesh<Dimension3> mesh;
// you read a mesh
mesh.Read("test.mesh");
// we clear the faces and elements shared by an edge ...
mesh.EdgeRef(3).ClearConnectivity();
// if you want to clear the connectivity of all the mesh :
mesh.ClearConnectivity();

Location :

GetNbFaces for Edge<Dimension3>

Syntax

int GetNbFaces() const

This method returns the number of faces (triangles or quadrilaterals) sharing the edge.

Example :

Mesh<Dimension3> mesh;

// we read a mesh
mesh.Read("test.mesh");

// special treatment for edges that belong to only one face
for (int i = 0; i < mesh.GetNbEdges(); i++)
  if (mesh.GetEdge(i).GetNbFaces() == 1)
    cout << "Edge not shared " << i << endl;

Location :

GetNbElements for Edge<Dimension3>

Syntax

int GetNbElements() const

This method returns the number of elements (e.g. tetrahedra, hexahedra) sharing the edge.

Example :

Mesh<Dimension3> mesh;

// we read a mesh
mesh.Read("test.mesh");

// special treatment for edges with only one element
for (int i = 0; i < mesh.GetNbEdges(); i++)
  if (mesh.GetEdge(i).GetNbElements() == 1)
    cout << "Edge not shared " << i << endl;

Location :

numFace for Edge<Dimension3>

Syntax

int numFace(int num) const

This methods returns the face number of a face adjacent to the edge.

Example :

Mesh<Dimension3> mesh;

// we read a mesh
mesh.Read("test.mesh");

// loop over referenced edges
for (int i = 0; i < mesh.GetNbEdgesRef(); i++)
  {
    // face number
    int num_face = mesh.EdgeRef(i).numFace(0);

    // and local position of the edge on this face
    int num_loc = mesh.Boundary(num_elem).GetPositionBoundary(i);
    cout << num_loc << "-th edge of face " << num_face << endl;
  }

Location :

numElement for Edge<Dimension3>

Syntax

int numElement(int num) const

This methods returns the element number of an element adjacent to the edge.

Example :

Mesh<Dimension3> mesh;

// we read a mesh
mesh.Read("test.mesh");

// loop over referenced edges
for (int i = 0; i < mesh.GetNbEdgesRef(); i++)
  {
    // element number
    int num_elem = mesh.EdgeRef(i).numElement(0);

    // and local position of the edge on the element
    int num_loc = mesh.Element(num_elem).GetPositionEdge(i);
    cout << num_loc << "-th edge of element " << num_elem << endl;
  }

Location :

AddFace for Edge<Dimension3>

Syntax

void AddFace(int i)

This methods adds a face to the edge. This low level method should be used with caution. The research of adjacent faces for all the edges of the mesh is performed in method FindConnectivity (which is automatically called when reading/creating a mesh).

Example :

Mesh<Dimension3> mesh;

// first, vertices
mesh.ReallocateVertices(4);
mesh.Vertex(0) = R3(0,0,0); mesh.Vertex(1) = R3(1,0,0);
mesh.Vertex(2) = R3(1,1,0); mesh.Vertex(3) = R3(1,1,1);

// you specify two referenced edges
mesh.ReallocateEdgesRef(2);
mesh.BoundaryRef(0).Init(0, 1, 1);
mesh.BoundaryRef(1).Init(1, 2, 1);

// then you have faces
mesh.ReallocateBoundaries(1);
mesh.Boundary(0).InitTriangular(0, 1, 2, 1);

// you can specify faces manually (not advised)
mesh.EdgeRef(0).AddFace(0);
mesh.EdgeRef(1).AddFace(0);

Location :

AddElement for Edge<Dimension3>

Syntax

void AddElement(int i)

This methods adds an element to the edge. This low level method should be used with caution. The research of adjacent elements for all the edges of the mesh is performed in method FindConnectivity (which is automatically called when reading/creating a mesh).

Example :

Mesh<Dimension3> mesh;

// first, vertices
mesh.ReallocateVertices(4);
mesh.Vertex(0) = R3(0,0,0); mesh.Vertex(1) = R3(1,0,0);
mesh.Vertex(2) = R3(1,1,0); mesh.Vertex(3) = R3(1,1,1);

// you specify two referenced edges
mesh.ReallocateEdgesRef(2);
mesh.BoundaryRef(0).Init(0, 1, 1);
mesh.BoundaryRef(1).Init(1, 2, 1);

// then you have elements
mesh.ReallocateElements(1);
mesh.Element(0).InitTetrahedral(0, 1, 2, 3, 1);
// you can specify elements by hand (not advised)
mesh.EdgeRef(0).AddElement(0);
mesh.EdgeRef(1).AddElement(0);

Location :

ClearFaces for Edge<Dimension3>

Syntax

void ClearFaces()

This method clears the list of faces associated with the edge. This low level method should be used with caution. The research of adjacent elements for all the edges of the mesh is performed in method FindConnectivity (which is automatically called when reading/creating a mesh).

Example :

Mesh<Dimension3> mesh;
mesh.Read("test.mesh");

// if you want to clear the list of faces of a single edge
mesh.EdgeRef(0).ClearFaces();

Location :

IsTriangular for Face<Dimension3>

Syntax

bool IsTriangular() const

This method returns true if the face is a triangle, false otherwise.

Example :

Mesh<Dimension3> mesh;
mesh.Read("test.mesh");

// specific treatment for triangles
for (int i = 0; i < mesh.GetNbBoundary(); i++)
  if (mesh.Boundary(i).IsTriangular())
    cout << "triangular face " << endl;

Location :

IsQuadrangular for Face<Dimension3>

Syntax

bool IsQuadrangular() const

This method returns true if the face is a quadrangle, false otherwise.

Example :

Mesh<Dimension3> mesh;
mesh.Read("test.mesh");
// specific treatment for quadrangles
for (int i = 0; i < mesh.GetNbBoundary(); i++)
  if (mesh.Boundary(i).IsQuadrangular())
    cout << "quadrangular face " << endl;

Location :

GetHybridType for Face<Dimension3>

Syntax

int GetHybridType() const

This method returns 0 for a triangle, 1 for a quadrangle.

Example :

Mesh<Dimension3> mesh;
mesh.Read("test.mesh");
// specific treatment for triangles/quadrangles
for (int i = 0; i < mesh.GetNbBoundary(); i++)
  switch (mesh.Boundary(i).GetHybridType())
    {
    case 0 :
      cout << "triangular face " << endl;
      break;
    case 1 :
      cout << "quadrangular face " << endl;
      break;
    }

Location :

GetOrientationEdge, GetOrientationBoundary for Face<Dimension3>

Syntax

bool GetOrientationEdge(int num_loc) const

int GetOrientationBoundary(int num_loc) const

This method returns the difference of orientation between local and global edge. It returns true if the orientations are equal, false if the orientations are opposite.

Example :

Mesh<Dimension3> mesh;
mesh.Read("test.mesh");
int num_face = 2;
for (int num_loc = 0; num_loc < mesh.Boundary(num_face).GetNbEdges(); num_loc++)
  cout << "Difference of orientation " << mesh.Boundary(num_face).GetOrientationEdge(num_loc);

Location :

numVertex for Face<Dimension3>

Syntax

int numVertex(int num_loc) const

This method returns the vertex number of a vertex of the face.

Example :

Mesh<Dimension3> mesh;
mesh.Read("test.mesh");
for (int i = 0; i < mesh.GetNbBoundary(); i++)
  {
    int nb_vertices = mesh.Boundary(i).GetNbVertices();
    // storing vertices of the face in an array
    IVect num(nb_vertices);
    for (int j = 0; j < nb_vertices; j++)
      num(j) = mesh.Boundary(i).numVertex(j);
  }

Location :

numEdge for Face<Dimension3>

Syntax

int numEdge(int num_loc) const

This method returns the edge number of an edge of the face.

Example :

Mesh<Dimension3> mesh;
mesh.Read("test.mesh");
for (int i = 0; i < mesh.GetNbBoundary(); i++)
  {
    int nb_edges = mesh.Boundary(i).GetNbEdges();
    // storing edges of the face in an array
    IVect num(nb_edges);
    for (int j = 0; j < nb_edges; j++)
      num(j) = mesh.Boundary(i).numEdge(j);
  }

Location :

GetReference for Face<Dimension3>

Syntax

int GetReference() const

This method returns the reference number of the face. Usually this reference number is determined during the construction of the mesh. For example, in Gmsh it is the number just after Physical Surface.

Example :

Mesh<Dimension3> mesh;
mesh.Read("test.mesh");
for (int i = 0; i < mesh.GetNbBoundaryRef(); i++)
  if (mesh.BoundaryRef(i).GetReference() == 2)
    cout << "Face with ref 2 " << endl;

Location :

GetNbVertices for Face<Dimension3>

Syntax

int GetNbVertices() const

This method returns the number of vertices of the face, e.g. three for a triangle.

Example :

Mesh<Dimension3> mesh;
mesh.Read("test.mesh");
for (int i = 0; i < mesh.GetNbBoundaryRef(); i++)
  if (mesh.BoundaryRef(i).GetNbVertices() == 3)
    cout << "Triangular face " << endl;

Location :

GetNbEdges for Face<Dimension3>

Syntax

int GetNbEdges() const

This method returns the number of edges of the face, e.g. 3 for a triangle.

Example :

Mesh<Dimension3> mesh;
mesh.Read("test.mesh");
for (int i = 0; i < mesh.GetNbBoundaryRef(); i++)
  if (mesh.BoundaryRef(i).GetNbEdges() == 3)
    cout << "Triangular face " << endl;

Location :

SetVertex for Face<Dimension3>

Syntax

void SetVertex(int num_loc, int num_glob)

This method sets the global vertex number of a local vertex of the face. Usually, we prefer to specify all the vertices of the face in the same time by calling methods InitTriangular, InitQuadrangular or Init.

Example :

Mesh<Dimension3> mesh;
mesh.Read("test.mesh");
// if you want to change a global number
int old_num = 23; int new_num = 57;
for (int i = 0; i < mesh.GetNbBoundaryRef(); i++)
  for (int j = 0; j < mesh.BoundaryRef(i).GetNbVertices(); j++)
    if (mesh.BoundaryRef(i).numVertex(j) == old_num)
      mesh.BoundaryRef(i).SetVertex(j, new_num);

Location :

SetReference for Face<Dimension3>

Syntax

void SetReference(int ref)

This method sets the reference number of the face.

Example :

Mesh<Dimension3> mesh;
mesh.Read("test.mesh");
// if you want to change a reference
for (int i = 0; i < mesh.GetNbBoundaryRef(); i++)
  if (mesh.BoundaryRef(i).GetReference() == 2)
    mesh.BoundaryRef(i).SetReference(3);

Location :

InitTriangular for Face<Dimension3>

Syntax

void InitTriangular(int n0, int n1, int n2, int ref)

This method specifies the three vertices of the face (which becomes a triangle) and the associated reference number.

Example :

Mesh<Dimension3> mesh;
// construction of a basic mesh
mesh.ReallocateVertices(3);
mesh.Vertex(0) = R3(0,0,0); mesh.Vertex(1) = R3(1,0,0); mesh.Vertex(2) = R3(1,1,1);
// creating referenced faces
mesh.ReallocateBoundariesRef(1);
mesh.BoundaryRef(0).InitTriangular(0, 1, 2, 32);

Location :

InitQuadrangular for Face<Dimension3>

Syntax

void InitQuadrangular(int n0, int n1, int n2, int n3, int ref)

This method specifies the four vertices of the face (which becomes a quadrangle) and the associated reference number.

Example :

Mesh<Dimension3> mesh;
// construction of a basic mesh
mesh.ReallocateVertices(4);
mesh.Vertex(0) = R3(0,0,0); mesh.Vertex(1) = R3(1,0,1);
mesh.Vertex(2) = R3(1,1,0);  mesh.Vertex(3) = R3(0,1, 1);
// creating referenced faces
mesh.ReallocateBoundariesRef(1);
mesh.BoundaryRef(0).InitQuadrangular(0, 1, 2, 3, 32);

Location :

Init for Face<Dimension3>

Syntax

void Init(const IVect& num, int ref)

This method specifies the vertices of the face and the reference number. If the length of the array num is equal to 3, the face will be a triangle, if it is equal to 4, it will be a quadrangle.

Example :

Mesh<Dimension3> mesh;
// construction of a basic mesh
mesh.ReallocateVertices(4);
mesh.Vertex(0) = R3(0,0,0); mesh.Vertex(1) = R3(1,0,1);
mesh.Vertex(2) = R3(1,1,0);  mesh.Vertex(3) = R3(0,1,1);
// we create referenced faces
mesh.ReallocateBoundariesRef(1);
IVect num(4); num.Fill();
mesh.BoundaryRef(0).Init(num, 32);

Location :

SetEdge for Face<Dimension3>

Syntax

void SetEdge(int num_loc, int num_glob)

This method sets the global number of an edge of the face. This method is low-level, since global edge numbers are attributed when calling FindConnectivity. In regular use, this method should not be called.

Example :

Mesh<Dimension3> mesh;
mesh.ReadMesh("test.mesh");

// changing first edge number of face 3 (not advised to do that)
mesh.BoundaryRef(3).SetEdge(0, 32);

Location :

GetPositionBoundary for Face<Dimension3>

Syntax

int GetPositionBoundary(int num_glob) const

This method returns the local position of a global edge.

Example :

Mesh<Dimension3> mesh;

// we read a mesh
mesh.Read("test.mesh");

// loop over referenced edges
for (int i = 0; i < mesh.GetNbEdgesRef(); i++)
  {
    // face number
    int num_face = mesh.EdgeRef(i).numFace(0);
    // usually referenced edges are placed before the other edges
    int num_edge = i;
    // local position of the edge on the face
    int num_loc = mesh.Boundary(num_face).GetPositionBoundary(num_edge);
    cout << num_loc << "-th edge of face " << num_face << endl;
}

Location :

ClearConnectivity for Face<Dimension3>

Syntax

void ClearConnectivity()

This method clears the edges and elements which have been found. The edge numbers and element numbers are set to -1 after a call to that function. This low-level method should not be used, you can clear connectivity of all the mesh by calling ClearConnectivity.

Example :

Mesh<Dimension3> mesh;
// we read a mesh
mesh.Read("test.mesh");

// and after you can clear connectivities of faces
for (int i = 0; i < mesh.GetNbBoundary(); i++)
  mesh.Boundary(i).ClearConnectivity();

Location :

ClearEdges for Face<Dimension3>

Syntax

void ClearEdges()

This method clears the edges which have been found. The edge numbers are set to -1 after a call to that function. This low-level method should not be used, you can clear connectivity of all the mesh by calling ClearConnectivity.

Example :

Mesh<Dimension3> mesh;

// we read a mesh
mesh.Read("test.mesh");

// and after you clear informations about edges of faces
for (int i = 0; i < mesh.GetNbBoundary(); i++)
  mesh.Boundary(i).ClearEdges();

Location :

GetMemorySize for Face<Dimension3>

Syntax

int GetMemorySize() const

This method returns the size used to store the face in bytes.

Example :

Mesh<Dimension3> mesh;

// we read a mesh
mesh.Read("test.mesh");

// loop over faces
for (int i = 0; i < mesh.GetNbBoundary(); i++)
  cout << mesh.Boundary(i).GetMemorySize() << endl;

Location :

GetNbElements for Face<Dimension3>

Syntax

int GetNbElements() const

This method returns the number of elements sharing the face. If the face is on the boundary, it will return 1 (only one element), otherwise it should return 2.

Example :

Mesh<Dimension3> mesh;
// we read a mesh
mesh.Read("test.mesh");

// special treatment for intern faces ?
for (int i = 0; i < mesh.GetNbBoundary(); i++)
  if (mesh.Boundary(i).GetNbElements() == 2)
    cout << "Intern face " << i << endl;

Location :

numElement for Face<Dimension3>

Syntax

int numElement(int num) const

This methods returns the element number of an element adjacent to the face.

Example :

Mesh<Dimension3> mesh;
// we read a mesh
mesh.Read("test.mesh");

// loop over referenced faces
for (int i = 0; i < mesh.GetNbBoundaryRef(); i++)
  {
    // element number
    int num_elem = mesh.BoundaryRef(i).numElement(0);
    // you can get global number of the face
    int num_face = i;
    // and local position of the face on the element
    int num_loc = mesh.Element(num_elem).GetPositionBoundary(num_face);
    cout << num_loc << "-th face of element " << num_elem << endl;
  }

Location :

AddElement for Face<Dimension3>

Syntax

void AddElement(int i)

This methods adds an element to the face. The number of elements is lower or equal to 2. If you try to add three elements to a face, the third element number will overwrite the second element number. This low level method should be used with caution. The research of adjacent elements for all the faces of the mesh is performed in method FindConnectivity (which is automatically called when reading/creating a mesh).

Example :

Mesh<Dimension3> mesh;

// first, vertices
mesh.ReallocateVertices(4);
mesh.Vertex(0) = R3(0,0,0); mesh.Vertex(1) = R3(1,0,0);
mesh.Vertex(2) = R3(1,1,1); mesh.Vertex(3) = R3(1,0,1);

// you specify two referenced faces
mesh.ReallocateBoundariesRef(2);
mesh.BoundaryRef(0).InitTriangular(0, 1, 2, 1);
mesh.BoundaryRef(1).InitTriangular(1, 2, 3, 1);

// then you have elements
mesh.ReallocateElements(1);
mesh.Element(0).InitTetrahedral(0, 1, 2, 3, 1);

// you can specify elements by hand (not advised)
mesh.BoundaryRef(0).AddElement(0);
mesh.BoundaryRef(1).AddElement(0);

Location :

SetElement for Face<Dimension3>

Syntax

void SetElement(int n0, int n1)

This methods sets the element numbers of adjacent elements to the face. This low level method should be used with caution. The research of adjacent elements for all the faces of the mesh is performed in method FindConnectivity (which is automatically called when reading/creating a mesh).

Example :

Mesh<Dimension3> mesh;

// first, vertices
mesh.ReallocateVertices(4);
mesh.Vertex(0) = R3(0,0,0); mesh.Vertex(1) = R3(1,0,0);
mesh.Vertex(2) = R3(1,1,1); mesh.Vertex(3) = R3(1,0,1);

// you specify two referenced faces
mesh.ReallocateBoundariesRef(2);
mesh.BoundaryRef(0).InitTriangular(0, 1, 2, 1);
mesh.BoundaryRef(1).InitTriangular(1, 2, 3, 1);

// then you have elements
mesh.ReallocateElements(1);
mesh.Element(0).InitTetrahedral(0, 1, 2, 3, 1);

// you can specify elements by hand (not advised)
mesh.BoundaryRef(0).AddElement(1);
mesh.BoundaryRef(0).AddElement(2);

// now if you want to change both element numbers
mesh.BoundaryRef(0).SetElement(0, 3);

Location :

GetGeometryReference for Face<Dimension3>

Syntax

int GetGeometryReference() const

This method returns the geometry number associated with the face. This geometry number is only defined in .msh files generated by Gmsh, and corresponds to the identification number given to each surface in the .geo file. If you are reading meshes from other formats, the geometric reference will be 0 for every face.

Example :

Mesh<Dimension3> mesh;
// you read a mesh generated by Gmsh
mesh.Read("test.msh");
// then you loop over referenced faces
for (int i = 0: i < mesh.GetNbBoundaryRef(); i++)
  if (mesh.BoundaryRef(i).GetGeometryReference() == 2)
    cout << "Face " << mesh.BoundaryRef(i) << endl;

Location :

SetGeometryReference for Face<Dimension3>

Syntax

void SetGeometryReference(int ref)

This method changes the geometry number associated with the face.

Example :

Mesh<Dimension3> mesh;
// you read a mesh
mesh.Read("test.msh");
// then you loop over referenced faces to change geometry ref 2 to geometry ref 3
for (int i = 0: i < mesh.GetNbBoundaryRef(); i++)
  if (mesh.BoundaryRef(i).GetGeometryReference() == 2)
    mesh.BoundaryRef(i).SetGeometryReference(3);

Location :

GetMemorySize for Volume

Syntax

int GetMemorySize() const

This method returns the size used to store a volume in bytes.

Example :

Mesh<Dimension3> mesh;

// we read a mesh
mesh.Read("test.mesh");

// loop over elements
for (int i = 0; i < mesh.GetNbElt(); i++)
  cout << mesh.Element(i).GetMemorySize() << endl;

Location :

GetReference for Volume

Syntax

int GetReference() const

This method returns the reference number of the element. Usually this reference number is determined during the construction of the mesh. For example, in Gmsh it is the number just after Physical Volume.

Example :

Mesh<Dimension3> mesh;
mesh.Read("test.mesh");
for (int i = 0; i < mesh.GetNbElt(); i++)
  if (mesh.Element(i).GetReference() == 2)
    cout << "Volume with ref 2 " << endl;

Location :

SetReference for Volume

Syntax

void SetReference(int ref)

This method sets the reference number of the volume.

Example :

Mesh<Dimension3> mesh;
mesh.Read("test.mesh");
// if you want to change a reference
for (int i = 0; i < mesh.GetNbElt(); i++)
  if (mesh.Element(i).GetReference() == 2)
    mesh.Element(i).SetReference(3);

Location :

GetHybridType for Volume

Syntax

int GetHybridType() const

This method returns 0 for a tetrahedron, 1 for a pyramid, 2 for a wedge and 3 for an hexahedron.

Example :

Mesh<Dimension3> mesh;
mesh.Read("test.mesh");
// specific treatment for the different elements
for (int i = 0; i < mesh.GetNbElt(); i++)
  switch (mesh.Element(i).GetHybridType())
    {
    case 0 :
      cout << "tetrahedral element " << endl;
      break;
    case 1 :
      cout << "pyramidal element " << endl;
      break;
    case 2 :
      cout << "prismatic element " << endl;
      break;
    case 3 :
      cout << "hexahedral element " << endl;
      break;
    }

Location :

IsPML for Volume

Syntax

bool IsPML() const

This method returns true if the volume is located in a PML area. This status can be modified with methods SetPML() and UnsetPML().

Example :

Mesh<Dimension3> mesh;

// we read a mesh
mesh.Read("test.mesh");

// then you can count pml elements for example
int nb_elt_pml = 0;
for (int i = 0; i < mesh.GetNbElt(); i++)
  if (mesh.Element(i).IsPML())
    nb_elt_pml++;

Location :

SetPML for Volume

Syntax

void SetPML(int num, int type)

This method informs that the element is in a PML. The first argument num if the PML region number, whereas the second argument type is the type of PML.

Example :

Mesh<Dimension3> mesh;

// we read a mesh
mesh.Read("test.mesh");

// you can mark some elements as pml
mesh.Element(23).SetPML(0, 0);

Location :

UnsetPML for Volume

Syntax

void UnsetPML()

This method informs that the element is not in a PML.

Example :

Mesh<Dimension3> mesh;

// we read a mesh
mesh.Read("test.mesh");

// you can mark some elements as pml
mesh.Element(23).SetPML(0, 0);

// and unmark them
mesh.Element(23).UnsetPML();

Location :

GetTypePML for Volume

Syntax

int GetTypePML() const

This method returns the type of PML associated with the face.

Example :

Mesh<Dimension3> mesh;

// we read a mesh
mesh.Read("test.mesh");

// loop over PML elements
for (int i = 0; i < mesh.GetNbElt(); i++)
  if (mesh.Element(i).IsPML())
    cout << mesh.Element(i).GetTypePML() << endl;

Location :

GetNumberPML for Volume

Syntax

int GetNumberPML() const

This method returns the number of PML region associated with the face.

Example :

Mesh<Dimension3> mesh;

// we read a mesh
mesh.Read("test.mesh");

// loop over PML elements
for (int i = 0; i < mesh.GetNbElt(); i++)
  if (mesh.Element(i).IsPML())
    cout << mesh.Element(i).GetNumberPML() << endl;

Location :

IsCurved for Volume

Syntax

bool IsCurved() const

This method returns true if the element is considered as a curved element. This status can be modified with methods SetCurved() and UnsetCurved().

Example :

Mesh<Dimension3> mesh;

// we read a mesh 
// if the mesh file is appropriate, there may be curved elements
mesh.SetGeometryOrder(4);
mesh.Read("test.mesh");

// then you can count curved elements
int nb_elt_curved = 0;
for (int i = 0; i < mesh.GetNbElt(); i++)
  if (mesh.Element(i).IsCurved())
    nb_elt_curved++;

Location :

SetCurved for Volume

Syntax

void SetCurved()

This method informs that the element is curved.

Example :

Mesh<Dimension3> mesh;
// we read a mesh
mesh.SetGeometryOrder(2);
mesh.Read("test.mesh");

// you can mark some elements as curved
mesh.Element(23).SetCurved();

Location :

UnsetCurved for Volume

Syntax

void UnsetCurved()

This method informs that the element is not curved.

Example :

Mesh<Dimension3> mesh;
// we read a mesh
mesh.SetGeometryOrder(2);
mesh.Read("test.mesh");

// you can mark some elements as curved
mesh.Element(23).SetCurved();

// and unmark them
mesh.Element(23).UnsetCurved();

Location :

GetNbVertices for Volume

Syntax

int GetNbVertices() const

This method returns the number of vertices of the element, 4 for a tetrahedron, 5 for a pyramid, 6 for a wedge and 8 for a hexahedron.

Example :

Mesh<Dimension3> mesh;
mesh.Read("test.mesh");
for (int i = 0; i < mesh.GetNbElt(); i++)
  if (mesh.Element(i).GetNbVertices() == 4)
    cout << "Tetrahedral element " << endl;

Location :

GetNbEdges for Volume

Syntax

int GetNbEdges() const

This method returns the number of edges of the element, 6 for a tetrahedron, 8 for a pyramid, 9 for a wedge and 12 for a hexahedron.

Example :

Mesh<Dimension3> mesh;
mesh.Read("test.mesh");
for (int i = 0; i < mesh.GetNbElt(); i++)
  if (mesh.Element(i).GetNbEdges() == 6)
    cout << "Tetrahedral element " << endl;

Location :

GetNbFaces, GetNbBoundary for Volume

Syntax

int GetNbFaces() const

int GetNbBoundary() const

This method returns the number of faces of the element, 4 for a tetrahedron, 5 for a pyramid or a wedge and 6 for a hexahedron.

Example :

Mesh<Dimension3> mesh;
mesh.Read("test.mesh");
for (int i = 0; i < mesh.GetNbElt(); i++)
  if (mesh.Element(i).GetNbBoundary() == 4)
    cout << "Tetrahedral element " << endl;

Location :

numVertex for Volume

Syntax

int numVertex(int num_loc) const

This method returns vertex number of a vertex of the volume.

Example :

Mesh<Dimension3> mesh;
mesh.Read("test.mesh");
for (int i = 0; i < mesh.GetNbElt(); i++)
  {
    int nb_vertices = mesh.Element(i).GetNbVertices();
    // storing vertices of the face in an array
    IVect num(nb_vertices);
    for (int j = 0; j < nb_vertices; j++)
      num(j) = mesh.Element(i).numVertex(j);
  }

Location :

numEdge for Volume

Syntax

int numEdge(int num_loc) const

This method returns the edge number of an edge of the volume.

Example :

Mesh<Dimension3> mesh;
mesh.Read("test.mesh");
for (int i = 0; i < mesh.GetNbElt(); i++)
  {
    int nb_edges = mesh.Element(i).GetNbEdges();
    // storing edges of the volume i in an array
    IVect num(nb_edges);
    for (int j = 0; j < nb_edges; j++)
      num(j) = mesh.Element(i).numEdge(j);
  }

Location :

numFace, numBoundary for Volume

Syntax

int numFace(int num_loc) const

int numBoundary(int num_loc) const

This method returns the face number of a face of the volume.

Example :

Mesh<Dimension3> mesh;
mesh.Read("test.mesh");
for (int i = 0; i < mesh.GetNbElt(); i++)
  {
    int nb_faces = mesh.Element(i).GetNbFaces();
    // storing faces of the volume in an array
    IVect num(nb_faces);
    for (int j = 0; j < nb_faces; j++)
      num(j) = mesh.Element(i).numFace(j);
  }

Location :

GetOrientationEdge for Volume

Syntax

bool GetOrientationEdge(int num_loc) const

This method returns the difference of orientation between local and global edge. It returns true if the orientations are equal, false if the orientations are opposite.

Example :

Mesh<Dimension3> mesh;
mesh.Read("test.mesh");
int num_elem = 2;
for (int num_loc = 0; num_loc < mesh.Element(num_elem).GetNbEdges(); num_loc++)
  cout << "Difference of orientation " << mesh.Element(num_elem).GetOrientationEdge(num_loc);

Location :

GetOrientationFace, GetOrientationBoundary for Volume

Syntax

int GetOrientationFace(int num_loc) const

int GetOrientationBoundary(int num_loc) const

This method returns the difference of orientation between local and global face.

Example :

Mesh<Dimension3> mesh;
mesh.Read("test.mesh");
int num_elem = 2;
for (int num_loc = 0; num_loc < mesh.Element(num_elem).GetNbBoundary(); num_loc++)
  cout << "Difference of orientation " << mesh.Element(num_elem).GetOrientationFace(num_loc);

Location :

SetOrientationFace for Volume

Syntax

void SetOrientationFace(int num_loc, int rot)

This method sets the difference of orientation between local and global face. This low-level method should not be called since this orientation is set in other methods (such as reading a mesh, splitting it, etc).

Example :

Mesh<Dimension3> mesh;
mesh.Read("test.mesh");
int num_elem = 2;
mesh.Element(num_elem).SetOrientationFace(0, 3);

Location :

Init for Volume

Syntax

void Init(const IVect& num, int ref)

This method specifies the vertices of the element and the reference number. If the length of the array num is equal to 4, the element will be a tetrahedron, if it is equal to 5, it will be a pyramid, etc.

Example :

Mesh<Dimension3> mesh;

// construction of a basic mesh
mesh.ReallocateVertices(4);
mesh.Vertex(0) = R3(0,0,0); mesh.Vertex(1) = R3(1,0,0);
mesh.Vertex(2) = R3(1,1,0);  mesh.Vertex(3) = R3(0,1,1);

// we create elements
mesh.ReallocateElements(1);
IVect num(4); num.Fill();
mesh.Element(0).Init(num, 32);

Location :

InitTetrahedral for Volume

Syntax

void InitTetrahedral(const IVect& num, int ref)

void InitTetrahedral(int n1, int n2, int n3, int n4, int ref)

This method inits a tetrahedral element by giving the numbers of the four vertices and the reference. You can also provide the numbers in an array num.

Example :

Mesh<Dimension3> mesh;

// construction of a basic mesh
mesh.ReallocateVertices(6);
mesh.Vertex(0) = R3(0,0,0); mesh.Vertex(1) = R3(1,0,1);
mesh.Vertex(2) = R3(1,1,0);  mesh.Vertex(3) = R3(0,1,1);
mesh.Vertex(4) = R3(1,0,0);  mesh.Vertex(5) = R3(0,1,0);

// we create elements
mesh.ReallocateElements(2);
IVect num(4); num.Fill();
mesh.Element(0).InitTetrahedral(num, 32);
mesh.Element(1).InitTetrahedral(1, 3, 2, 4, 32);

Location :

InitPyramidal for Volume

Syntax

void InitPyramidal(const IVect& num, int ref)

void InitPyramidal(int n1, int n2, int n3, int n4, int n5, int ref)

This method inits a pyramidal element by giving the numbers of the five vertices and the reference. You can also provide the numbers in an array num.

Example :

Mesh<Dimension3> mesh;

// construction of a basic mesh
mesh.ReallocateVertices(6);
mesh.Vertex(0) = R3(0,0,0); mesh.Vertex(1) = R3(1,0,1);
mesh.Vertex(2) = R3(1,1,0);  mesh.Vertex(3) = R3(0,1,1);
mesh.Vertex(4) = R3(1,0,0);  mesh.Vertex(5) = R3(0,1,0);

// we create elements
mesh.ReallocateElements(2);
IVect num(5); num.Fill();
mesh.Element(0).InitPyramidal(num, 32);
mesh.Element(1).InitPyramidal(1, 3, 2, 4, 5, 32);

Location :

InitWedge for Volume

Syntax

void InitWedge(const IVect& num, int ref)

void InitWedge(int n1, int n2, int n3, int n4, int n5, int n6, int ref)

This method inits a prismatic element by giving the numbers of the six vertices and the reference. You can also provide the numbers in an array num.

Example :

Mesh<Dimension3> mesh;

// construction of a basic mesh
mesh.ReallocateVertices(6);
mesh.Vertex(0) = R3(0,0,0); mesh.Vertex(1) = R3(1,0,1);
mesh.Vertex(2) = R3(1,1,0);  mesh.Vertex(3) = R3(0,1,1);
mesh.Vertex(4) = R3(1,0,0);  mesh.Vertex(5) = R3(0,1,0);

// we create elements
mesh.ReallocateElements(2);
IVect num(6); num.Fill();
mesh.Element(0).InitWedge(num, 32);
mesh.Element(1).InitWedge(1, 3, 2, 4, 0, 5, 32);

Location :

InitHexahedral for Volume

Syntax

void InitHexahedral(const IVect& num, int ref)

void InitHexahedral(int n1, int n2, int n3, int n4, int n5, int n6, int n7, int n8, int ref)

This method inits a hexahedral element by giving the numbers of the eight vertices and the reference. You can also provide the numbers in an array num.

Example :

Mesh<Dimension3> mesh;

// construction of a basic mesh
mesh.ReallocateVertices(8);
mesh.Vertex(0) = R3(0,0,0); mesh.Vertex(1) = R3(1,0,1);
mesh.Vertex(2) = R3(1,1,0);  mesh.Vertex(3) = R3(0,1,1);
mesh.Vertex(4) = R3(1,0,0);  mesh.Vertex(5) = R3(0,1,0);
mesh.Vertex(6) = R3(0,0,1);  mesh.Vertex(7) = R3(1,1,1);

// we create elements
mesh.ReallocateElements(2);
IVect num(8); num.Fill();
mesh.Element(0).InitHexahedral(num, 32);
mesh.Element(1).InitHexahedral(0, 1, 3, 2, 4, 5, 6, 7, 32);

Location :

SetEdge for Volume

Syntax

void SetEdge(int num_loc, int num_glob)

This method sets the global number of an edge of the volume. This method is a low-level, since global edge numbers are attributed when calling FindConnectivity. In regular use, this method should not be called.

Example :

Mesh<Dimension3> mesh;
mesh.ReadMesh("test.mesh");

// changing first edge number of element 3 (not advised to do that)
mesh.Element(3).SetEdge(0, 32);

Location :

SetFace for Volume

Syntax

void SetFace(int num_loc, int num_glob)

void SetFace(int num_loc, int num_glob, int rot)

This method sets the global number of a face of the volume. This method is a low-level, since global face numbers are attributed when calling FindConnectivity. In regular use, this method should not be called. The optional third argument is the orientation of the face.

Example :

Mesh<Dimension3> mesh;
mesh.ReadMesh("test.mesh");

// changing first face number of element 3 (not advised to do that)
mesh.Element(3).SetFace(0, 32);

Location :

GetPositionEdge for Volume

Syntax

int GetPositionEdge(int num_glob) const

This method returns the local position of a global edge.

Example :

Mesh<Dimension3> mesh;

// we read a mesh
mesh.Read("test.mesh");

// loop over referenced edges
for (int i = 0; i < mesh.GetNbEdgesRef(); i++)
  {
    // element number
    int num_elem = mesh.EdgeRef(i).numElement(0);
    // usually referenced edges are placed before the other edges
    int num_edge = i;
    // local position of the edge on the element
    int num_loc = mesh.Element(num_elem).GetPositionEdge(num_edge);
    cout << num_loc << "-th edge of element " << num_elem << endl;
}

Location :

GetPositionBoundary for Volume

Syntax

int GetPositionBoundary(int num_glob) const

This method returns the local position of a global face.

Example :

Mesh<Dimension3> mesh;

// we read a mesh
mesh.Read("test.mesh");

// loop over referenced faces
for (int i = 0; i < mesh.GetNbBoundaryRef(); i++)
  {
    // element number
    int num_elem = mesh.BoundaryRef(i).numElement(0);
    // usually referenced faces are placed before the other faces
    int num_edge = i;
    // local position of the face on the element
    int num_loc = mesh.Element(num_elem).GetPositionBoundary(num_edge);
    cout << num_loc << "-th face of element " << num_elem << endl;
}

Location :

ClearConnectivity for Volume

Syntax

void ClearConnectivity()

This method clears the edges and faces which have been found. The edge and face numbers are set to -1 after a call to that function. This low-level method should not be used, you can clear connectivity of all the mesh by calling ClearConnectivity.

Example :

Mesh<Dimension3> mesh;
// we read a mesh
mesh.Read("test.mesh");

// and after you can clear connectivities of elements only
for (int i = 0; i < mesh.GetNbElt(); i++)
  mesh.Element(i).ClearConnectivity();

Location :

ClearEdges for Volume

Syntax

void ClearEdges()

Example :

Mesh<Dimension3> mesh;

// we read a mesh
mesh.Read("test.mesh");

// and after you clear informations about edges
for (int i = 0; i < mesh.GetNbElt(); i++)
  mesh.Element(i).ClearEdges();

Location :

ClearFaces for Volume

Syntax

void ClearFaces()

This method clears the facees which have been found. The face numbers are set to -1 after a call to that function. This low-level method should not be used, you can clear connectivity of all the mesh by calling ClearConnectivity.

Example :

Mesh<Dimension3> mesh;

// we read a mesh
mesh.Read("test.mesh");

// and after you clear informations about faces
for (int i = 0; i < mesh.GetNbElt(); i++)
  mesh.Element(i).ClearFaces();

Location :

TranslateMesh

Syntax

void TranslateMesh(Mesh<Dimension3>& mesh, R3 translat)

This method translates the 3-D mesh with the vector translat.

Example :

Mesh<Dimension3> mesh;
mesh.Read("test.mesh");

// defining the vector of translation
R3 translat(2.5, -0.4, 0.8);

// the mesh is translated
TranslateMesh(mesh, translat);

Location :

RotateMesh

Syntax

void RotateMesh(Mesh<Dimension3>& mesh, R3 center, R3 axis, Real_wp teta)

This method rotates the 3-D mesh around an axis with an angle teta.

Example :

Mesh<Dimension3> mesh;
mesh.Read("test.mesh");

// defining a point of the axis of rotation
R3 center(2.5, -0.4, 0.8);

// then the direction of the axis
R3 axis(0.0, 0.0, 1.0);

// the mesh is rotated by an angle pi/4 around the axis
RotateMesh(mesh, center, axis, pi_wp/4);

Location :

ScaleMesh

Syntax

void ScaleMesh(Mesh<Dimension3>& mesh, R3 scale)

This method scales the mesh. Each coordinate is multiplied by a given factor.

Example :

Mesh<Dimension3> mesh;
mesh.Read("test.mesh");

// defining the scaling factors for each direction
R3 scale(2.0, 3.0, 4.0);

// the mesh is scaled (here x is multiplied by 2, y by 3, z by 4)
ScaleMesh(mesh, scale);

Location :

WriteElementMesh

Syntax

void WriteElementMesh(	Mesh<Dimension3>& mesh, ElementGeomReference<Dimension3>& Fb,
	SetPoints<Dimension3>& PointsElem, string file_name, int num_elem)

This method writes the element num_elem of the mesh in a file. The element will be subdivided depending on the geometry order. This function is useful to check a curved element.

Example :

Mesh<Dimension3> mesh;
// you can read a curved mesh
mesh.Read("test.msh");

// writes the element 4 in a new mesh (the element will be subdivided if the geometry order is greater or equal to 2).
int num_elem = 4;
const ElementGeomReference<Dimension3>& Fb = mesh.GetReferenceElement(num_elem);
SetPoints<Dimension3> PointsElem;
VectR3 s; mesh.GetVerticesElement(num_elem, s);
Fb.FjElemNodal(s, PointsElem, mesh, num_elem);
WriteElementMesh(mesh, Fb, PointsElem, "elem.mesh", 4);

Location :

ScaleVariableMesh

Syntax

void ScaleVariableMesh(Mesh<Dimension3>& mesh, ScalingMeshVirtualFunction3D fct)

This method scales the mesh in x and y. The factor depends on the variable z and is prescribed by the virtual function EvaluateCoefficient of the object fct.

Example :

// you derive the class ScalingMeshVirtualFunction3D
class MyScaling : public  ScalingMeshVirtualFunction3D
{
public :
// for a given z, you define the dilatation coefficient in x and y
void EvaluateCoefficient(const Real_wp& z, Real_wp& coefx, Real_wp& coefy)
{
  coefx = 1.0/(1.0 + z*z);
  coefy = 1.0/(1.0 + 2.0*abs(z));
}

};
  
int main()
{
  Mesh<Dimension3> mesh;
  mesh.Read("test.mesh");

  // defining the scaling factor in x/y
  MyScaling scale;

  // the mesh is scaled (here x is multiplied by 1/(1+z^2), y by 1/(1+abs(z)))
  ScaleVariableMesh(mesh, scale);
}

Location :

ReallocateBoundariesRef

Syntax

void ReallocateBoundariesRef(int n)

This low-level routine reallocates the referenced faces of the mesh. The faces are modified with the method BoundaryRef.

Example :

Mesh<Dimension3> mesh;
mesh.ReallocateBoundariesRef(10);
mesh.BoundaryRef(0).InitTriangular(2, 5, 7, 1);
mesh.BoundaryRef(1).InitQuadrangular(1, 4, 7, 8, 1);
// etc

// once you have filled referenced faces, elements and vertices
mesh.FindConnectivity();

Location :

ResizeBoundariesRef

Syntax

void ResizeBoundariesRef(int n)

This low-level routine resizes the referenced faces of the mesh. Previous referenced faces are conserved (contrary to ReallocateBoundariesRef), and the additional faces are not initialized. The faces are modified with the method BoundaryRef.

Example :

// starting mesh from a file
Mesh<Dimension3> mesh;
mesh.Read("test.mesh");
int n = mesh.GetNbBoundaryRef();

// you can add referenced faces
mesh.ResizeBoundariesRef(n+10);
mesh.BoundaryRef(n).InitTriangular(2, 5, 7, 1);
mesh.BoundaryRef(n+1).InitQuadrangular(1, 4, 7, 8, 1);
// etc

// once you have filled additional referenced faces
mesh.FindConnectivity();

Location :

ReallocateEdgesRef

Syntax

void ReallocateEdgesRef(int n)

This low-level routine reallocates the referenced edges of the mesh. The edges are modified with the method EdgeRef.

Example :

Mesh<Dimension3> mesh;
mesh.ReallocateEdgesRef(10);
mesh.EdgeRef(0).Init(2, 5, 1);
mesh.EdgeRef(1).Init(1, 4, 1);
// etc

// once you have filled referenced faces, elements and vertices
mesh.FindConnectivity();

Location :

ResizeEdgesRef

Syntax

void ResizeEdgesRef(int n)

This low-level routine resizes the referenced edges of the mesh. Previous referenced edges are conserved (contrary to ReallocateEdgesRef), and the additional edges are not initialized. The edges are modified with the method EdgeRef.

Example :

// starting mesh from a file
Mesh<Dimension3> mesh;
mesh.Read("test.mesh");
int n = mesh.GetNbEdgesRef();

// you can add referenced edges
mesh.ResizeEdgesRef(n+10);
mesh.EdgeRef(n).Init(2, 5, 1);
mesh.EdgeRef(n+1).Init(1, 4, 1);
// etc

// once you have filled additional referenced edges
mesh.FindConnectivity();

Location :

ReallocateFaces

Syntax

void ReallocateFaces(int N)

This low-level routine reallocates the faces of the mesh. The faces are modified with the method Boundary. This method should be used cautiously since faces are automatically constructed when FindConnectivity is called.

Example :

Mesh<Dimension3> mesh;
mesh.ReallocateFaces(10);
mesh.Boundary(0).InitTriangular(0, 1, 4, 1);

// here a call to FindConnectivity will reconstruct the faces (previous faces are erased)
mesh.FindConnectivity();

Location :

ResizeFaces

Syntax

void ResizeFaces(int N)

This low-level routine resizes the faces of the mesh. Previous faces are conserved (contrary to ReallocateFaces), and the additional faces are not initialized. The faces are modified with the method Boundary. This method should be used cautiously since faces are automatically constructed when FindConnectivity is called.

Example :

// starting mesh from a file
Mesh<Dimension3> mesh;
mesh.Read("test.mesh");
int n = mesh.GetNbVertices();

// you can add faces
mesh.ResizeFaces(n+10);
mesh.Boundary(n).Init(2.1, 5.4, 1.3);
mesh.Boundary(n+1).Init(1.9, 4.8, 1.6);
// etc

// here a call to FindConnectivity will reconstruct the faces (previous faces are erased)
mesh.FindConnectivity();

Location :

EdgeRef

Syntax

Edge<Dimension3>& EdgeRef(int i)

This method gives access to a referenced edge of the mesh.

Example :

// starting mesh from a file
Mesh<Dimension3> mesh;
mesh.Read("test.mesh");
int n = mesh.GetNbEdgesRef();

// you can display referenced edges
for (int i = 0; i < n; i++)
  cout << " Referenced Edge " << i << " = " << mesh.EdgeRef(i) << endl;

Location :

BoundaryRef

Syntax

Face<Dimension3>& BoundaryRef(int i)

This method gives access to a referenced face of the mesh.

Example :

// starting mesh from a file
Mesh<Dimension3> mesh;
mesh.Read("test.mesh");
int n = mesh.GetNbBoundaryRef();

// you can display referenced faces
for (int i = 0; i < n; i++)
  cout << " Referenced face " << i << " = " << mesh.BoundaryRef(i) << endl;

Location :

Boundary

Syntax

Face<Dimension3>& Boundary(int i)

This method gives access to a face of the mesh.

Example :

// starting mesh from a file
Mesh<Dimension3> mesh;
mesh.Read("test.mesh");
int n = mesh.GetNbBoundary();

// you can display all the faces of the mesh (interior faces also)
for (int i = 0; i < n; i++)
  cout << " Face " << i << " = " << mesh.Boundary(i) << endl;

Location :

GetNbBoundary

Syntax

int GetNbBoundary() const

This method returns the number of faces of the mesh.

Example :

// starting mesh from a file
Mesh<Dimension3> mesh;
mesh.Read("test.mesh");
int n = mesh.GetNbBoundary();

cout << " Number of faces : " << n << endl;

Location :

GetNbBoundaryRef

Syntax

int GetNbBoundaryRef() const

This method returns the number of referenced faces of the mesh.

Example :

// starting mesh from a file
Mesh<Dimension3> mesh;
mesh.Read("test.mesh");
int n = mesh.GetNbBoundaryRef();

cout << " Number of referenced faces : " << n << endl;

Location :

GetGlobalBoundaryNumber

Syntax

int GetGlobalBoundaryNumber(int i) const

This method returns the global number of the local face i. This method is relevant only in parallel (when each processor owns a part of the mesh).

Example :

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

int i = 3;
int iglob = mesh.GetGlobalBoundaryNumber(i);

Location :

GetTriangleReferenceElement

Syntax

const TriangleGeomReference& GetTriangleReferenceElement() const

This method returns the triangular finite element used for curved triangles.

Example :

// starting mesh from a file
Mesh<Dimension3> mesh;
mesh.SetOrderGeometry(3);
mesh.Read("test.mesh");

const TriangleGeomReference& tri = mesh.GetTriangleReferenceElement();

Location :

GetQuadrilateralReferenceElement

Syntax

const QuadrangleGeomReference& GetQuadrilateralReferenceElement() const

This method returns the quadrangular finite element used for curved quadrilaterals.

Example :

// starting mesh from a file
Mesh<Dimension3> mesh;
mesh.SetOrderGeometry(3);
mesh.Read("test.mesh");

const QuadrangleGeomReference& tri = mesh.GetQuadrilateralReferenceElement();

Location :

GetReferenceElementSurface

Syntax

void GetReferenceElementSurface(Vector<const ElementGeomReference<Dimension2>* >& elt) const

This method fills the array elt with the triangular and quadrangular finite element used for curved surfaces.

Example :

// starting mesh from a file
Mesh<Dimension3> mesh;
mesh.SetOrderGeometry(3);
mesh.Read("test.mesh");

Vector<const ElementGeomReference<Dimension2>* > elt
mesh.GetReferenceElementSurface(elt);

Location :

GetReferenceElementVolume

Syntax

void GetReferenceElementVolume(Vector<const ElementGeomReference<Dimension3>* >& elt) const

This method fills the array elt with the finite element used for each element.

Example :

// starting mesh from a file
Mesh<Dimension3> mesh;
mesh.SetOrderGeometry(3);
mesh.Read("test.mesh");

Vector<const ElementGeomReference<Dimension3>* > elt
mesh.GetReferenceElementVolume(elt);

Location :

GetLocalNodalNumber

Syntax

Vector<int> GetLocalNodalNumber(int type, int num_loc)

This method returns the nodal numbers of the face num_loc of a tetrahedron (if type is 0) or a pyramid (if type is 1) or a prism (if type is 2) or an hexahedron (if type is 3).

Example :

// starting mesh from a file
Mesh<Dimension3> mesh;
mesh.SetOrderGeometry(3);
mesh.Read("test.mesh");

// number of nodal points for the face 2 of the pyramid
int num_loc = 2;
IVect num_nodes = mesh.GetLocalNodalNumber(1, num_loc);

Location :

GetNbTetrahedra

Syntax

int GetNbTetrahedra() const

This method computes and returns the number of tetrahedra contained in the mesh. This number is computed by performing a loop over the elements of the mesh.

Example :

// starting mesh from a file
Mesh<Dimension3> mesh;
mesh.SetOrderGeometry(3);
mesh.Read("test.mesh");

// counting the number of tetrahedra
int nb_tet = mesh.GetNbTetrahedra();

Location :

GetNbPyramids

Syntax

int GetNbPyramids() const

This method computes and returns the number of pyramids contained in the mesh. This number is computed by performing a loop over the elements of the mesh.

Example :

// starting mesh from a file
Mesh<Dimension3> mesh;
mesh.SetOrderGeometry(3);
mesh.Read("test.mesh");

// counting the number of pyramids
int nb_pyr = mesh.GetNbPyramids();

Location :

GetNbWedges

Syntax

int GetNbWedges() const

This method computes and returns the number of wedges contained in the mesh. This number is computed by performing a loop over the elements of the mesh.

Example :

// starting mesh from a file
Mesh<Dimension3> mesh;
mesh.SetOrderGeometry(3);
mesh.Read("test.mesh");

// counting the number of wedges
int nb_wed = mesh.GetNbWedges();

Location :

GetNbHexahedra

Syntax

int GetNbHexahedra() const

This method computes and returns the number of hexahedra contained in the mesh. This number is computed by performing a loop over the elements of the mesh.

Example :

// starting mesh from a file
Mesh<Dimension3> mesh;
mesh.SetOrderGeometry(3);
mesh.Read("test.mesh");

// counting the number of hexahedra
int nb_hex = mesh.GetNbHexahedra();

Location :

GetNbTrianglesRef

Syntax

int GetNbTrianglesRef() const

This method computes and returns the number of referenced triangles contained in the mesh. This number is computed by performing a loop over the referenced faces of the mesh.

Example :

// starting mesh from a file
Mesh<Dimension3> mesh;
mesh.SetOrderGeometry(3);
mesh.Read("test.mesh");

// counting the number of referenced triangles
int nb_tri = mesh.GetNbTrianglesRef();

Location :

GetNbQuadranglesRef

Syntax

int GetNbQuadranglesRef() const

This method computes and returns the number of referenced quadrangles contained in the mesh. This number is computed by performing a loop over the referenced faces of the mesh.

Example :

// starting mesh from a file
Mesh<Dimension3> mesh;
mesh.SetOrderGeometry(3);
mesh.Read("test.mesh");

// counting the number of referenced quadrangles
int nb_quad = mesh.GetNbQuadranglesRef();

Location :

GetNbTriangles

Syntax

int GetNbTriangles() const

This method computes and returns the number of triangles contained in the mesh. This number is computed by performing a loop over the faces of the mesh.

Example :

// starting mesh from a file
Mesh<Dimension3> mesh;
mesh.SetOrderGeometry(3);
mesh.Read("test.mesh");

// counting the number of triangles
int nb_tri = mesh.GetNbTriangles();

Location :

GetNbQuadrangles

Syntax

int GetNbQuadrangles() const

This method computes and returns the number of quadrangles contained in the mesh. This number is computed by performing a loop over the faces of the mesh.

Example :

// starting mesh from a file
Mesh<Dimension3> mesh;
mesh.SetOrderGeometry(3);
mesh.Read("test.mesh");

// counting the number of quadrangles
int nb_quad = mesh.GetNbQuadrangles();

Location :

GetNbEdgesRef

Syntax

int GetNbEdgesRef() const

This method returns the number of referenced edges contained in the mesh.

Example :

// starting mesh from a file
Mesh<Dimension3> mesh;
mesh.SetOrderGeometry(3);
mesh.Read("test.mesh");

// number of referenced edges
int nb_edges = mesh.GetNbEdgesRef();

Location :

GetNbFaces

Syntax

int GetNbFaces() const

This method returns the number of faces contained in the mesh.

Example :

// starting mesh from a file
Mesh<Dimension3> mesh;
mesh.SetOrderGeometry(3);
mesh.Read("test.mesh");

// number of faces
int nb_faces = mesh.GetNbFaces();

Location :

SetGeometryOrder

Syntax

void SetGeometryOrder(int r)

void SetGeometryOrder(int r, bool only_hex)

This method changes the order of approximation used for the definition of the geometry. It is necessary to call that method before reading the mesh, otherwise the mesh will be converted into a first order mesh, and you will lose the information about curved boundaries contained in the mesh file. Usually in Montjoie codes (except those in the directory src/Program/Mesh), this step is performed when the data file is read (for the field OrderDiscretization). When a mesh is read, it is translated into Montjoie structures, so at the order specified when you have called SetGeometryOrder (the default order is 1). You can change the order of approximation after reading the mesh, in that case it will perform an interpolation to obtain the new nodal points on referenced edges of the mesh or exploit the informations provided for the curves. Of course, if you have decreased the order of approximation, some information is lost, and if you get back to the initial order of approximation, the internal points will not be exactly the same.The second argument is optional, if you put true, only quadrilateral/hexahedral finite element is computed. It is assumed that the mesh only contain hexehadra in that case.

Example :

Mesh<Dimension3> mesh;
// first you specify which order you wish
mesh.SetGeometryOrder(3);
// you can specify a given curve if you want (you don't need if the input mesh is already curved)
mesh.SetCurveType(1, mesh.CURVE_SPHERE);
// if you don't provide parameters with method SetCurveParameters, the
// parameters will be automatically found 
// we read the mesh
mesh.Read("test.mesh");
// you can decrease the order of approximation if you want
mesh.SetGeometryOrder(2);

Location :

HybridMesh

Syntax

bool HybridMesh() const

This method returns true if the mesh contains a mix of elements. If the mesh contains only tetrahedra or only hexahedra, it will return false.

Example :

Mesh<Dimension3> mesh;
// we read the mesh
mesh.Read("test.mesh");
// it is an hybrid mesh ?
if (mesh.HybridMesh())
  cout << "The mesh is hybrid " << endl;

Location :

IsOnlyTetrahedral

Syntax

bool IsOnlyTetrahedral() const

This method returns true if the mesh contains only tetrahedra.

Example :

Mesh<Dimension3> mesh;
// we read the mesh
mesh.Read("test.mesh");
// it is a purely tetrahedral mesh ?
if (mesh.IsOnlyTetrahedral())
  cout << "The mesh contains only tetrahedra " << endl;

Location :

IsOnlyHexahedral

Syntax

bool IsOnlyHexahedral() const

This method returns true if the mesh contains only hexahedra.

Example :

Mesh<Dimension3> mesh;
// we read the mesh
mesh.Read("test.mesh");
// it is a purely hexahedral mesh ?
if (mesh.IsOnlyHexahedral())
  cout << "The mesh contains only hexahedra " << endl;

Location :

GetMemorySize

Syntax

size_t GetMemorySize() const

This method returns the memory used to store the mesh (in bytes).

Example :

Mesh<Dimension3> mesh;
// we read the mesh
mesh.Read("test.mesh");

cout << "Memory used to store the mesh = " << mesh.GetMemorySize() << " bytes" << endl;

Location :

GetUpperBoundNumberOfFaces

Syntax

int GetUpperBoundNumberOfFaces() const

This method returns an upper bound for the number of faces. This upper bound is used when the faces are constructed. The actual number of faces is given by GetNbFaces.

Location :

GetUpperBoundNumberOfEdges

Syntax

int GetUpperBoundNumberOfEdges() const

This method returns an upper bound for the number of edges. This upper bound is used when the edges are constructed. The actual number of edges is given by GetNbEdges.

Location :

GetNodesCurvedMesh

Syntax

int GetNodesCurvedMesh(VectR3& PosNodes, Vector<IVect>& Nodle, int rmax) const

int GetNodesCurvedMesh(VectR3& PosNodes, Vector<IVect>& Nodle, int rmax, bool lobatto) const

This method computes the positions of each node of the mesh and the array containing node numbers for each element. For first-order meshes, the nodes of the mesh are the vertices, and Nodle will contain the vertex numbers for each element. For high-order meshes, vertices and intern nodes are computed, and nodes numbers are stored for each element. The local numbering of nodes on a tetrahedron is displayed in the method ConstructTriangularNumbering, and on a hexahedron, you can look at the picture of the method ConstructQuadrilateralNumbering. You can require to have nodes for an order rmax lower than the order of approximation of the mesh, but if you ask nodes for order rmax greater, it will give you nodes for the order of approximation of the mesh, and the method will return this order. If you want to avoid this drawback, you can call SetGeometryOrder before. If the last argument is set to true, the nodal points are computed for Gauss-Lobatto points. Otherwise, the nodal points are computed for a regular subdivision.

Example :

Mesh<Dimension3> mesh;
mesh.SetGeometryOrder(3);
// we read the mesh
mesh.Read("test.mesh");
// then you want to explicit all the nodes and node numbering
VectR3 PosNodes; Vector<IVect> Nodle;
// here you will get only third-order mesh (r = 3)
int r = mesh.GetNodesCurvedMesh(PosNodes, Nodle, 4);
cout << "Actual order of nodes " << r << endl;
// printing all the nodes
cout << "Position of nodes " << endl;
for (int i = 0; i < PosNodes.GetM(); i++)
  cout << PosNodes(i) << endl;
    
for (int i = 0; i < Nodle.GetM(); i++)
  cout << "Nodes of element " << i << endl << Nodle(i) << endl;

Location :

Read

Syntax

void Read(string file_name)

This method reads a mesh from a file. The mesh format is automatically found with the extension of the file name. If the mesh file is curved, you will have to call SetGeometryOrder before, so that the mesh is converted to an high-order mesh with the order specified by the call of SetGeometryOrder. In Montjoie, we use generally isoparametric elements, the order of approximation is usually the same for the geometry and the finite element space.

Example :

Mesh<Dimension3> mesh;
mesh.SetGeometryOrder(3);
// we read the mesh
mesh.Read("test.mesh");

Location :

Write

Syntax

void Write(string file_name) const

This method writes a mesh in a file. The mesh format is automatically found with the extension of the file name.

Example :

Mesh<Dimension3> mesh;
mesh.SetGeometryOrder(3);
// we read the mesh
mesh.Read("test.mesh");
// and writing in another format
mesh.Write("test.msh");

Location :

ChangeLocalNumberingMesh

Syntax

void ChangeLocalNumberingMesh()

This method permutes the local numbering of tetrahedra such that the vertex numbers are sorted in decreasing order. It works only for purely tetrahedral meshes.

Example :

Mesh<Dimension3> mesh;
// we read mesh
mesh.Read("test.mesh");
// then you change the local numbering of tetrahedra
mesh.ChnageLocalNumberingMesh();

Location :

ReorientElements

Syntax

void ReorientElements()

This method changes the local numbering of elements, so that the jacobian is positive for all elements. This method is called when a mesh is read from a file so that you probably don't need to call it. For most of the methods (except low-level methods such as Vertex, Element, etc) defined in class Mesh, the orientation of elements is set so that jacobians are always positive.

Example :

Mesh<Dimension3> mesh;
// if you construct by your-self a mesh
mesh.ReallocateVertices(4);
mesh.Vertex(0).Init(-1.0, -1.0, 2.0);
// etc
mesh.ReallocateElements(5);
mesh.Element(0).InitTetrahedral(4, 2, 5, 8, 1);
// etc

// you will need to reorient elements such that jacobian is positive
mesh.ReorientElements();

Location :

ReorientElementCartesian

Syntax

void ReorientElementCartesian(IVect& num, VectR3& s)

This method permutes the numbers contained in num such that the jacobian matrix is diagonal. It works only for a rectangular element (num and s are arrays of size 8). The second argument s is not modified and contains the vertices of the element.

Example :

Mesh<Dimension3> mesh;
mesh.Read("test.mesh");

// constructing num and ptE
int num_elem = 23; int ref = mesh.Element(num_elem).GetReference();
VectR3 s(8); IVect num(8);
for (int i = 0; i < 8; i++)
{
num(i) = mesh.Element(num_elem).numVertex(i);
s(i) = mesh.Vertex(num(i));
}

// we compute a permutation of num to provide a diagonal jacobian matrix
mesh.ReorientElementCartesian(num, ptE);

// we changes the numbers in the mesh
mesh.Element(num_elem).Init(num, ref);

// if you change the mesh => call to FindConnectivity
mesh.FindConnectivity();

Location :

ReorientFaces

Syntax

void ReorientFaces(int ref_target, const IVect& ref_cond, const R3& normale)

This method changes the local numbering of referenced faces such that they are oriented counterclockwise. The operation is performed for all references faces such that ref_cond(ref) = ref_target. normale is the approximative direction of the desired normale for all the referenced faces. It is mainly intended for planar surfaces where an unique normale exists.

Example :

Mesh<Dimension3> mesh;
mesh.Read("plate.mesh");

// if you want to have the same orientation of faces of reference 2 and 3
int ref_target = 1;
IVect ref_cond(mesh.GetNbReferences()+1);
ref_cond.Zero(); ref_cond(2) = ref_target; ref_cond(3) = ref_target;

mesh.ReorientFaces(ref_target, ref_cond, R3(0, 0, 1.0));

Location :

FindConnectivity

Syntax

void FindConnectivity()

This method finds all the edges and faces of the mesh. Referenced edges (resp. faces) are placed at the first position and then intern edges (resp. faces).

Example :

Mesh<Dimension3> mesh;

// we read the mesh (here FindConnectivity is called by Read)
mesh.Read("test.mesh");

// you can ask to recompute edges dand faces (not needed in this case)
mesh.FindConnectivity()

// printing the number of edges
cout << "Number of edges " << mesh.GetNbEdges() << endl;

Location :

RemoveDuplicateVertices

Syntax

void RemoveDuplicateVertices()

This method removes from the mesh duplicate vertices, i.e. vertices which are twice in the mesh, so that in the new mesh, each vertex is unique.

Example :

Mesh<Dimension3> mesh;
// we read the mesh
mesh.Read("test.mesh");
// we remove duplicate vertices
mesh.RemoveDuplicateVertices();
// printing the new number of vertices
cout << "Number of vertices " << mesh.GetNbVertices() << endl;

Location :

ForceCoherenceMesh

Syntax

void ForceCoherenceMesh()

This method removes from the mesh unused vertices, i.e. vertices which are not belonging to elements. The referenced edges/faces that do not belong to elements are removed.

Example :

Mesh<Dimension3> mesh;
// we read the mesh
mesh.Read("test.mesh");
// we remove unused vertices
mesh.ForceCoherenceMesh();
// printing the new number of vertices
cout << "Number of vertices " << mesh.GetNbVertices() << endl;

Location :

ClearZeroBoundaryRef

Syntax

void ClearZeroBoundaryRef()

This method removes from the mesh referenced faces whose reference is equal to 0.

Example :

Mesh<Dimension3> mesh;
// we read the mesh
mesh.Read("test.mesh");
// we remove faces of reference 0
mesh.ClearZeroBoundaryRef();
// printing the new number of referenced faces
cout << "Number of reference faces " << mesh.GetNbBoundaryRef() << endl;

Location :

SymmetrizeMesh

Syntax

void SymmetrizeMesh(int num_coor, Real_wp d, R3 normale, bool keep_face=false)

This method symmetrizes a mesh with respect to a plane. The equation of the plane depends on the value of num_coor :

num_coor = 0 ⇒ x = d
num_coor = 1 ⇒ y = d
num_coor = 2 ⇒ z = d
num_coor = -1 ⇒ a x + b y + c z + d = 0

In the last case (num_coor = -1), the parameters a, b and c are stored in the vector normale. The last argument is optional. If equal to true, the references faces on the symmetry plane are kept. Otherwise these references faces are removed. In the figure below, we show an exemple of symmetrization:

⇒

Example :

Mesh<Dimension3> mesh;
// we read the mesh
mesh.Read("test.mesh");

// we symmetrize the mesh with respect to the plane z = 0.5
mesh.SymmetrizeMesh(2, 0.5, R3());

mesh.Read("other.mesh");

// symmetry with respect to plane a x + b y + c z + d = 0
Real_wp a = 1.0, b = 2.0, c = 3.0, d = 4.0;
mesh.SymmetrizeMesh(-1, d, R3(a, b, c));

Location :

SplitIntoHexahedra

Syntax

void SplitIntoHexahedra()

This method converts a purely tetrahedral mesh to a purely hexahedral mesh by splitting each tetrahedron into four hexahedra. Below, we show an illustration of this functionality (we show the boundary of the mesh and the interior):

	⇒
	⇒

Example :

Mesh<Dimension3> mesh;
// we read a tetrahedral mesh
mesh.Read("test.mesh");

// we split tetrahedra into hexahedra
mesh.SplitIntoHexahedra();

Location :

SplitIntoTetrahedra

Syntax

void SplitIntoTetrahedra()

This method converts a mixed mesh (containing hexahedra, tetrahedra, pyramids and/or wedges) to a purely tetrahedral mesh by splitting each element into tetrahedra. Below, we show an illustration of this functionality (we show the boundary of the mesh):

⇒

Example :

Mesh<Dimension3> mesh;
// we read an hexahedral-dominant mesh
mesh.Read("test.mesh");

// we split into tetrahedra
mesh.SplitIntoTetrahedra();

Location :

GetMeshSubdivision

Syntax

void GetMeshSubdivision	(const VectReal_wp& outside_subdiv, const Vector<VectR3>& points_div, const Vector<VectR2>& points_surf,
	VectR3& PosNodes, Vector<IVect>& Nodle, Vector<IVect>& NodleSurf) const

This method returns a subdivision of the mesh through arrays PosNodes (nodal points), Nodle (connectivity) and NodleSurf (connectivity of surface). In this method, the user can provide its own points for triangles, quadrangles, tetrahedra, hexahedra, etc. Nodle(i) contains the node numbers for the element i. NodleSurf(i) contains the node numbers for the reference face i.

Example :

Mesh<Dimension3> mesh;
// we read the mesh
mesh.Read("test.mesh");

// defining regular subdivision
int order = 3;
VectReal_wp step_x(order+1);
for (int i = 0; i ≤ order; i++)
  step_x(i) = Real_wp(i)/order;
	
Vector<VectR2> points_surf(2);
points_surf(0).Reallocate((order+1)*(order+2)/2);
points_surf(1).Reallocate((order+1)*(order+1));

// regular points on triangles
Matrix<int> NumNodes2D, coor;
mesh.ConstructTriangularNumbering(order, NumNodes2D, coor);
for (int i = 0; i ≤ order; i++)
   for (int j = 0; j ≤ order-i; j++)
      points_surf(0)(NumNodes2D(i, j)).Init(step_x(i), step_x(j));
	
// regular points on quadrangles
mesh.ConstructQuadrilateralNumbering(order, NumNodes2D, coor);
for (int i = 0; i ≤ order; i++)
   for (int j = 0; j ≤ order; j++)
      points_surf(1)(NumNodes2D(i, j)).Init(step_x(i), step_x(j));

Vector<VectR3> points_div(4);
points_div(0).Reallocate((order+1)*(order+2)*(order+3)/6);
points_div(1).Reallocate((order+1)*(order+2)*(2*order+3)/6);
points_div(2).Reallocate((order+1)*(order+2)*(order+1)/2);
points_div(3).Reallocate((order+1)*(order+1)*(order+1));

// regular points on tetrahedra
Array3D<int> NumNodes3D;
MeshNumbering<Dimension3>::ConstructTetrahedralNumbering(order, NumNodes3D, coor);
for (int i = 0; i <= order; i++)
  for (int j = 0; j <= order-i; j++)
    for (int k = 0; k <= order-i-j; k++)
      points_div(0)(NumNodes3D(i, j, k)).Init(step_x(i), step_x(j), step_x(k));

// regular points on pyramid
MeshNumbering<Dimension3>::ConstructPyramidalNumbering(order, NumNodes3D, coor);
for (int k = 0; k <= order; k++)
  for (int i = 0; i <= order-k; i++)
    for (int j = 0; j <= order-k; j++)
      {
        Real_wp z = step_x(k);
        Real_wp x(0), y(0);
        if (k < order)
          {
	    x = step_x(i)/step_x(order-k);
	    y = step_x(j)/step_x(order-k);
          }

         points_div(1)(NumNodes3D(i, j, k)).Init((1.0-z)*(2.0*x-1.0), (1.0-z)*(2.0*y-1.0), z);
       }

// regular points on triangular prism
MeshNumbering<Dimension3>::ConstructPrismaticNumbering(order, NumNodes3D, coor);
for (int i = 0; i <= order; i++)
  for (int j = 0; j <= order-i; j++)
    for (int k = 0; k <= order; k++)
      points_div(2)(NumNodes3D(i, j, k)).Init(step_x(i), step_x(j), step_x(k));

// regular points on hexahedron
MeshNumbering<Dimension3>::ConstructHexahedralNumbering(order, NumNodes3D, coor);
for (int i = 0; i <= order; i++)
  for (int j = 0; j <= order; j++)
    for (int k = 0; k <= order; k++)
      points_div(3)(NumNodes3D(i, j, k)).Init(step_x(i), step_x(j), step_x(k));

// we get a subdivision of the mesh
VectR3 PosNodes; Vector<IVect> Nodle, NodleSurf;
mesh.GetMeshSubdivision(step_x, points_div, points_surf, PosNodes, Nodle, NodleSurf);

Location :

SubdivideMesh

Syntax

void SubdivideMesh(	const VectReal_wp& outside_subdiv)
void SubdivideMesh(	const VectReal_wp& outside_subdiv, const Vector<VectR2>& points_surf, Vector<VectR3>& points_div,
	Vector<IVect>& Nodle, Vector<IVect>& NodleSurf)

This method subdivides a mesh by giving subdivision on the edge [0,1] in array outside_subdiv. You can retrieve the subdivided points of triangle and quadrangle in array points_div, and the new vertex numbers on each element in array Nodle. In the array NodleSurf, the vertex numbers on each referenced face is given.

Example :

Mesh<Dimension3> mesh;
// we read the mesh
mesh.Read("test.mesh");

// defining regular subdivision
int order = 3;
VectReal_wp step_x(order+1);
for (int i = 0; i ≤ order; i++)
  step_x(i) = Real_wp(i)/order;

// subdividing mesh
mesh.SubdivideMesh(step_x);

We see below the result obtained on a mesh by this method

⇒

Location :

CreateRegularMesh

Syntax

void CreateRegularMesh(R3 ptMin, R3 ptMax, TinyVector<int,3> nbPoints, int ref_domain, TinyVector<int,6> ref_boundary, int type_mesh, R3 ratio)

This method creates a regular mesh of a rectangular zone defined by the left bottom corner ptMin and the right top corner ptMax. You specify the number of points of the mesh on each direction (x, y and z) in nbPoints, the reference to attribute to each boundary is given in ref_boundary (plane x=xmin in ref_boundary(0), y=ymin in ref_boundary(1), z=zmin in ref_boundary(2), z=zmax in ref_boundary(3), y=ymax in ref_boundary(4), z=zmax in ref_boundary(5)). type_mesh describes the elements to use in order to mesh the rectangular zone. You can choose between

HEXAHEDRAL_MESH : only hexahedra
TETRAHEDRAL_MESH : only tetrahedra
PYRAMID_MESH : only pyramids
WEDGE_MESH : only wedges
HYBRID_MESH : pyramids and tetrahedra
CRUSH_MESH : degenerated hexahedra

The last argument ratio is optional. If present, the positions will follow a geometric progression (ratio(0) is the common ratio for x-coordinate, ratio(1) for y-coordinate, ratio(2) for z-coordinate).

Parameters

ptMin (in): lower extremity of the rectangular zone to mesh
ptMax (in): upper extremity of the rectangular zone to mesh
nbPoints (in): number of points in x, y and z
ref_domain (in): reference of created elements
ref_boundary (in): reference of boundary faces
type_mesh (in): type of mesh
ratio (optional): geometric progression in x and y

Example :

Mesh<Dimension3> mesh;
// we construct a regular mesh of the cube [-2, 2]^3
// with 20 points along x, 11 points along y, and 5 points along z,
TinyVector<int, 6> ref_boundary;
ref_boundary.Fill(3);
mesh.CreateRegularMesh(R3(-2, -2, -2), R3(2, 2, 2), 1, TinyVector<int, 3>(20, 11, 5),
                       ref_boundary, mesh.HEXAHEDRAL_MESH);

Location :

CreateStructuredMesh

Syntax

void CreateStructuredMesh(	const VectReal_wp& pos_x, const VectReal_wp& pos_y, const VectReal_wp& pos_z,
	const IVect& nb_x, const IVect& nb_y, const IVect& nb_z,
	const Array3D<int>& ref_domain, TinyVector<int, 6> ref_boundary)

This method creates a structured mesh made of rectangular zones. Each zone is then meshed with hexahedra. The x-coordinates of the different zones are given in pos_x (similarly y-coordinates and z-coordinates in pos_y and pos_z). The number of cells for each subdivision is given in nb_x, nb_y and nb_z. ref_domain(i, j, k) is the reference of the zone (i, j, k). If ref_domain(i, j, k) is lower or equal to 0, we assume that this zone is a hole (no elements). ref_boundary is the reference for the extern boundaries of the mesh (x=xmin, y=ymin, z=zmin, z=zmax, y=ymax, x=xmax) similarly to the method CreateRegularMesh. The intern boundaries created due to the presence of holes are attributed a new reference. In the figure below, we show an exemple of mesh created with this method.

Mesh of a dolmen

Example :

Mesh<Dimension3> mesh;

// we construct a regular mesh of the cube [-2, 2]^3 with a hole (cube [-1, 1]^3)
TinyVector<int, 6> ref_boundary;
ref_boundary.Fill(3);

// position of interfaces
VectReal_wp pos_x(4), pos_y, pos_z;
pos_x(0) = -2.0; pos_x(1) = -1.0; pos_x(2) = 1.0; pos_x(3) = 2.0;
pos_y = pos_x; pos_z = pos_x;

// number of cells in each part
Vector<int> nb_x(3), nb_y, nb_z;
nb_x(0) = 5; nb_x(1) = 10; nb_x(2) = 5; nb_y = nb_x; nb_z = nb_x;

// references for each zone
Array3D<int> ref_domain;
ref_domain.Fill(1); ref_domain(1, 1, 1) = 0;

mesh.CreateStructuredMesh(pos_x, pos_y, pos_z, nb_x, nb_y, nb_z,
                          ref_domain, ref_boundary);

Location :

CreateSphericalCrown

Syntax

void CreateSphericalCrown(Real_wp a, Real_wp b, int N, bool intern_sphere, bool extern_sphere, VectReal_wp step_subdiv, bool all_ref)

This method creates the mesh of a spherical crown (zone between two spheres). There can be several layers. The intern boundary can be a sphere or a cube, and similarly for the extern boundary.

Parameters

a: Radius of intern sphere
b: Radius of extern sphere
N: Number of points per unit (N = 1/h)
intern_sphere: if true, the intern boundary is a sphere, otherwise a cube
extern_sphere: if true, the extern boundary is a sphere, otherwise a cube
step_subdiv: intermediate positions between a and b. These positions define the interface between spherical layers
all_ref: if true, the six faces of the extern cube have a different reference

Example :

Mesh<Dimension3> mesh;

// basic case with only one spherical layer
VectReal_wp subdiv;
mesh.CreateSphericalCrown(1.0, 3.0, 4, true, true, subdiv, false);

// if you want that the extern boundary is a cube with different references on the faces of the cube
mesh.CreateSphericalCrown(1.0, 3.0, 4, true, false, subdiv, true);

// case with two spherical layers
subdiv.Reallocate(1); subdiv(0) = 2.0;
// first layer : elements such that 1 <= r <= 2
// second layer : elements such that 2 <= r <= 3
mesh.CreateSphericalCrown(1.0, 3.0, 4, true, true, subdiv, false);

Location :

CreateSphericalBall

Syntax

void CreateSphericalBall(Real_wp a, Real_wp b, int N, int ref_inside, bool extern_sphere, int type_mesh, int ref_outside, int Nsphere, int Nline, int ref_extern)

This method subdivides an initial spherical mesh and adds a spherical layer between the initial mesh and an extern sphere. The extern boundary can be a sphere or a cube.

Parameters

a: Radius of intern sphere
b: Radius of extern sphere
N: Number of points per unit (N = 1/h)
ref_inside: Reference of the intern sphere
extern_sphere: if true, the extern boundary is a sphere, otherwise a cube
type_mesh: type of elements, you can choose between TETRAHEDRAL_MESH and HEXAHEDRAL_MESH
ref_outside (optional): volume reference of the outside layer ( a ≤ r ≤ b)
Nsphere (optional): if different from 0, the number of subdivisions used to split the initial mesh.
Nline (optional): if different from 0, the number of subdivisions for the interval [a, b].
ref_extern (optional): Reference of the extern sphere

Example :

Mesh<Dimension3> mesh;

// first step, you have to create an initial mesh for the spherical ball r<= 1
// here we use a basic pattern with 8 tetrahedra
int reference_sphere = 3;
mesh.ReallocateVertices(7);
mesh.Vertex(0).Init(0.0, 0.0, 0.0);
mesh.Vertex(1).Init(1.0, 0.0, 0.0);
mesh.Vertex(2).Init(-1.0, 0.0, 0.0);
mesh.Vertex(3).Init(0.0, 1.0, 0.0);
mesh.Vertex(4).Init(0.0, -1.0, 0.0);
mesh.Vertex(5).Init(0.0, 0.0, 1.0);
mesh.Vertex(6).Init(0.0, 0.0, -1.0);
mesh.ReallocateElements(8); int ref_inside = 2;
mesh.Element(0).InitTetrahedral(0, 1, 3, 5, ref_inside);
mesh.Element(1).InitTetrahedral(0, 4, 1, 5, ref_inside);
mesh.Element(2).InitTetrahedral(0, 4, 6, 1, ref_inside);
mesh.Element(3).InitTetrahedral(0, 6, 3, 1, ref_inside);
mesh.Element(4).InitTetrahedral(0, 3, 2, 5, ref_inside);
mesh.Element(5).InitTetrahedral(0, 2, 4, 5, ref_inside);
mesh.Element(6).InitTetrahedral(0, 6, 4, 2, ref_inside);
mesh.Element(7).InitTetrahedral(0, 3, 6, 2, ref_inside);
mesh.ReallocateBoundariesRef(8);
mesh.BoundaryRef(0).InitTriangular(1, 3, 5, reference_sphere);
mesh.BoundaryRef(1).InitTriangular(1, 6, 3, reference_sphere);
mesh.BoundaryRef(2).InitTriangular(1, 4, 5, reference_sphere);
mesh.BoundaryRef(3).InitTriangular(1, 6, 4, reference_sphere);
mesh.BoundaryRef(4).InitTriangular(2, 3, 5, reference_sphere);
mesh.BoundaryRef(5).InitTriangular(2, 5, 4, reference_sphere);
mesh.BoundaryRef(6).InitTriangular(2, 6, 3, reference_sphere);
mesh.BoundaryRef(7).InitTriangular(2, 4, 6, reference_sphere);
                
mesh.ReorientElements();
mesh.FindConnectivity();
mesh.ProjectPointsOnCurves();

// second step you call CreateSphericalBall to subdivide the initial mesh and add a spherical layer (1 <= r <= 2)
mesh.CreateSphericalBall(1.0, 2.0, 4.0, reference_sphere,
                             true, mesh.HEXAHEDRAL_MESH);

Location :

ExtrudeCoordinate

Syntax

void ExtrudeCoordinate(int num_coor, int nb_layers, Real_wp pos, Real_wp delta)

This method adds layers between x= pos and x=pos+delta. If num_coor is equal to 1, is between y=pos and y=pos+delta (and z if num_coor is equal to 2). It is assumed that the initial mesh has a plane boundary at x=pos (or y, z) such that the extrusion is possible.

Parameters

num_coor: coordinate of extrusion (0 for x, 1 for y and 2 for z)
nb_layers: number of layers to add to the initial mesh
pos: Position of the planar surface to extrude (e.g. x = pos)
delta: The region between x=pos and x=pos+delta is meshed. It can be negative if you want to extrude towards the bottom (or left).

Example :

Mesh<Dimension3> mesh;
// starting from an initial mesh
mesh.Read("init.mesh");

// we want to add layers for -3 <= y <= -2
// and we assume the mesh contains a plane surface at y = -2
int nb_layers = 4;
mesh.ExtrudeCoordinate(1, nb_layers, -2.0, -1.0);

Location :

ExtrudeOrigin

Syntax

void ExtrudeOrigin(	const IVect& nb_interval, const Mesh<Dimension3>& mesh,
	const IVect& ref_surf, const IVect& ref_domain, const VectReal_wp& step_subdiv, bool all_ref)

This method adds spherical layers between the initial mesh and a given extern surface.

Parameters

nb_intervals: number of cells for each spherical layer
mesh: mesh defining the extern surface (we assume a matching between vertices of this mesh with vertices of the initial mesh)
ref_surf: surface reference for each spherical interface
ref_domain: volume reference for each spherical layer
step_subdiv: positions of interfaces (between 0 and 1)
all_ref: if true, we use the references of the extern surface, otherwise we use ref_surf(N).

Example :

Mesh<Dimension3> mesh;
// starting from an initial mesh
mesh.Read("init.mesh");

// you have to create an extern boundary
// such that you want to fill the space between the initial mesh and the boundary
// the vertices of this extern boundary must match vertices of the initial mesh
// one way is to extract the boundary of the initial mesh :
int ref_boundary = 5; Vector<int> ref_cond(mesh.GetNbReferences()+1); ref_cond.Fill();
SurfacicMesh<Dimension3> mesh_extern;
mesh.GetBoundaryMesh(ref_boundary, mesh_extern, ref_cond);

// we multiply coordinates by two to have a distinct surface
for (int i = 0; i < mesh_extern.GetNbVertices(); i++)
  mesh_extern.Vertex(i) *= 2.0;

// we want to add two layers
IVect nb_intervals(2), ref_surf(3), ref_domain(2);
nb_intervals(0) = 4; nb_intervals(1) = 3;
ref_surf(0) = ref_boundary; ref_surf(1) = 6; ref_surf(2) = 7;
ref_domain(0) = 3; ref_domain(1) = 4;

// interface is located at mid-point => 0.5
VectReal_wp step_subdiv(1); step_subdiv(0) = 0.5;
mesh.ExtrudeOrigin(nb_intervals, mesh_extern, ref_surf, ref_domain, step_subdiv, false);

Location :

ExtrudeSurfaceMesh

Syntax

void ExtrudeSurfaceMesh(	const Mesh<Dimension2>& mesh2d, const IVect& nbCells_layer
	const VectReal_wp& step_subdiv, const Vector<IVect>& ref_surface, const Vector<IVect>& ref_volume, R3 u, R3 v, R3 w)

This method extrudes a 2-D mesh in a given direction. This method is called when you provide the parameter EXTRUDE in the keyword FileMesh. In the description of this keyword, surface and volume references are explained.

Parameters

mesh2d: 2-D mesh to be extruded
nbCells_layer: number of cells for each layer
step_subdiv: position of the different layers
ref_surface: new references of lateral and top faces for each layer
ref_volume: new references of volumes for each layer
u: first vector plane
v: second vector plane
w: direction of extrusion

The vertices of the extruded mesh will be located at x*u + y*v + z*w where the vectors u, v, w have been given as parameters. (x, y) is the initial position of the 2-D mesh, whereas z is the coordinate of extrusion (between step_subdiv(0) and step_subdiv(N)).

Example :

Mesh<Dimension2> mesh2d;
// starting from a surface mesh
mesh2d.Read("section.mesh");

// two layers
IVect nbCells(2);
nbCells(0) = 3; nbCells(1) = 5;

// extrusion along z, z=0, z=0.4 and z=0.9 are the positions of the interfaces
VectReal_wp step(3);
step(0) = 0.0; step(1) = 0.4; step(2) = 0.9;

// new references (explained in FileMesh
Vector<IVect> ref_surf(2), ref_vol(2);
ref_surf(0).Reallocate(4); ref_surf(0).Zero();
ref_surf(1).Reallocate(4); ref_surf(1).Zero();
ref_surf(0)(2) = 2; ref_surf(0)(3) = 0;
ref_surf(1)(2) = 2; ref_surf(1)(3) = 3;

ref_vol(0).Reallocate(2); ref_vol(0).Zero(); ref_vol(0)(1) = 1;
ref_vol(1).Reallocate(2); ref_vol(1).Zero(); ref_vol(1)(1) = 2;

// creation of the 3-D extruded mesh
Mesh<Dimension3> mesh;
mesh.ExtrudeSurfaceMesh(mesh2d, nbCells, step, ref_surf, ref_vol, R3(1, 0, 0), R3(0, 1, 0), R3(0, 0, 1));

Location :

AppendMesh

Syntax

void AppendMesh(Mesh<Dimension2> mesh, bool elimine = true)

This method appends a given mesh to the existing mesh. Duplicate vertices can be removed or kept. By default, duplicate vertices are removed.

Parameters

mesh: given mesh to append
elimine (optional): if true, duplicate vertices are removed

Example :

Mesh<Dimension3> mesh;
// starting from an initial mesh
mesh.Read("init.mesh");

// you can append an another mesh
mesh.AppendMesh("suite.mesh");

Location :

CreateSubmesh

Syntax

void CreateSubmesh(Mesh<Dimension3>& sub_mesh, int nb_vertices, int nb_elt, Vector<bool> vertex_on_subdomain, Vector<bool> element_on_subdomain)

This method extracts a part of a mesh to create a small sub-mesh.

Parameters

sub_mesh: created sub-mesh
nb_vertices: number of vertices to extract
nb_elt: number of elements to extract
vertex_on_subdomain: if vertex_on_subdomain(i) is true the vertex i must be extracted
element_on_subdomain: if element_on_subdomain(i) is true the element i must be extracted

Example :

Mesh<Dimension3> mesh;
mesh.Read("toto.mesh");

// for example, we are marking elements with reference equal to 3
int nb_vertices = 0, nb_elt = 0;
Vector<bool> vertex_on_subdomain(mesh.GetNbVertices()), element_on_subdomain(mesh.GetNbElt());
vertex_on_subdomain.Fill(false);
element_on_subdomain.Fill(false);

for (int i = 0; i < mesh.GetNbElt(); i++)
  if (mesh.Element(i).GetReference() == 3)
    {
      element_on_subdomain(i) = true;
      nb_elt++;
      for (int j = 0; j < mesh.Element(i).GetNbVertices(); j++)
        {
          int nv = mesh.Element(i).numVertex(j);
          if (!vertex_on_subdomain(nv))
            {
              vertex_on_subdomain(nv) = true;
              nb_vertices++;
            }
        }
    }

// and extracting the sub-mesh
Mesh<Dimension3> sub_mesh;
mesh.CreateSubmesh(sub_mesh, nb_vertices, nb_elt, vertex_on_subdomain, element_on_subdomain);

Location :

ConstructMesh

Syntax

void ConstructMesh(int type_mesh, VectString param)

This method constructs a mesh with parameters given in array param. These parameters are the same as parameters described in field FileMesh. If type_mesh is equal to HEXAHEDRAL_MESH, the mesh will be split into hexahedra if it is containing tetrahedra. If type_mesh is equal to TETRAHEDRAL_MESH, the mesh will be split into tetrahedra if it is containing hexahedra. If type_mesh is equal to HYBRID_MESH, no splitting is performed. The method is summarized in the diagram below :

Diagramme ConstructMesh

Example :

Mesh<Dimension3> mesh;
VectString param(1);
param(0) = string("cube.mesh");
mesh.ConstructMesh(mesh.HYBRID_MESH, param);

Location :

RearrangeElements

Syntax

void RearrangeElements()

This method changes the ordring of elements, so that the tetrahedra are placed first in the list of elements, then pyramids, prisms and finally hexahedra. The method ConstructMesh calls already this method.

Example :

  Mesh<Dimension3> mesh;
  mesh.Read("test.mesh");

  // if you want to be sure that tetrahedra are placed first
  mesh.RearrangeElements();

  int N = mesh.GetNbTetrahedra();
  int nb_elt = mesh.GetNbElt();
  // tetrahedra will be between 0 and N-1, other elements between N and nb_elt-1

Location :

GetTetaMinMax

Syntax

void GetTetaMinMax(R3 center, Real_wp& teta_min, Real_wp& teta_max)

This method is used to determine the minimal and maximal value of theta (in cylindrical coordinates) of all the vertices of the mesh.

Parameters

center (in): center of polar coordinates
teta_min (out): minimal value of angle θ
teta_max (out): maximal value of angle θ

Example :

Mesh<Dimension3> mesh, mesh2;
mesh.Read("toto.mesh");

double teta_min, teta_max;
R3 center;
mesh.GetTetaMinMax(center, teta_min, teta_max);

Location :

PeriodizeMeshTeta

Syntax

void PeriodizeMeshTeta(const R3& center)

This method generates a complete cyclic mesh with an initial cell. You specify the center of the cylindrical coordinates, usually (0, 0, 0).

Example :

Mesh<Dimension3> mesh;
// we read the mesh
mesh.Read("test.mesh");
// we symmetrize mesh by cyclicity
R3 center;
mesh.PeriodizeMeshTeta(center);

Location :

ApplyLocalRefinement

Syntax

void ApplyLocalRefinement(const IVect& num_vertex, const IVect& num_edge, int nb_levels, Real_wp ratio)

This method performs a local refinement around vertices and edges. Currently it works only with hexahedral meshes and for some configurations.

Parameters

num_vertex: list of vertices to be refined
num_edges: list of edges to be refined
nb_levels: level of refinement (= number of iterations)
ratio: refinement ratio

Example :

Mesh<Dimension3> mesh;
// we read the mesh
mesh.Read("test.mesh");
// we apply a local refinement near vertex 1 and edges 2, 4, 5
IVect num_v(1), num_edge(3);
num_v(0) = 1; num_edge(0) = 2; num_edge(1) = 4; num_edge(2) = 5;
mesh.ApplyLocalRefinement(num_v, num_edge, 3, 2.0);

Location :

GetThicknessPML

Syntax

Real_wp GetThicknessPML() const

This method returns the PML thickness.

Example :

PmlRegionParameter<Dimension3> pml;

Real_wp delta = pml.GetThicknessPML();

Location :

GetOriginRadialPML

Syntax

R3 GetOriginRadialPML() const

This method returns the center of PML.

Example :

PmlRegionParameter<Dimension3> pml;

R3 center = pml.GetOriginRadialPML();

Location :

GetRadiusPML

Syntax

Real_wp GetRadiusPML() const

This method returns the PML radius.

Example :

PmlRegionParameter<Dimension3> pml;

Real_wp r = pml.GetRadiusPML();

Location :

SetThicknessPML

Syntax

void SetThicknessPML(Real_wp delta)

This method sets PML thickness.

Example :

PmlRegionParameter<Dimension3> pml;

pml.SetThicknessPML(2.5);

Location :

GetTypeAdditionPML

Syntax

int GetTypeAdditionPML(int num_coor) const

This method returns PML type with respect to x-coordinate (or y-coordinate or z-coordinate).

Example :

PmlRegionParameter<Dimension3> pml;

// pml added for x < xmin and/or x > xmax ?
int type_add_x = pml.GetTypeAdditionPML(0);

Location :

GetNbLayersPML

Syntax

int GetNbLayersPML() const

This method returns the numbers of layers in PML.

Example :

PmlRegionParameter<Dimension3> pml;

// number of layers ?
int n = pml.GetNbLayersPML();

Location :

SetRadiusPML

Syntax

void SetRadiusPML(Real_wp r)

This method sets the radius of PML.

Example :

PmlRegionParameter<Dimension3> pml;

// radius for PML layers
pml.SetRadiusPML(2.0);

Location :

SetOriginRadialPML

Syntax

void SetOriginRadialPML(R3 center)

This method sets the center of PML.

Example :

PmlRegionParameter<Dimension3> pml;

// center for PML layers
pml.SetOriginRadialPML(R3(1, 0, 0));

Location :

SetAdditionPML

Syntax

void SetAdditionPML(int add_x, int add_y, int add_z, int nb_layers)

This method is used to set PML to add. PML are effectively added when you call AddPML. On x-coordinate, you can add PML on negative side (x < xmin), positive side (x > xmax) or both sides. If you set nb_layers to 0, the number of layers will be automatically computed when you call AddPML.

Example :

Mesh<Dimension3> mesh;

// reading the mesh
mesh.Read("exemple.mesh");

// if you want only one PML region
mesh.ReallocatePmlAreas(1);
PmlRegionParameter<Dimension3>& pml = mesh.GetPmlArea(0);

// adding PML for x < xmin, y < ymin and y > ymax, z > zmax
int nb_layers = 2;
pml.SetAdditionPML(pml.PML_NEGATIVE_SIDE, pml.PML_BOTH_SIDES, pml.PML_POSITIVE_SIDE, nb_layers);
pml.SetThicknessPML(1.5);

// mesh is modified in order to add those PML
pml.AddPML(0, mesh);

Location :

SetParameters

Syntax

void SetParameters(VectString param)

This method sets the PML region with a line of the data file. This function is called when the data file is read (keyword AddPML). Outside of a data file, it seems easier to call SetAdditionPML.

Example :

Mesh<Dimension3> mesh;

// reading the mesh
mesh.Read("exemple.mesh");

// if you want only one PML region
mesh.ReallocatePmlAreas(1);
PmlRegionParameter<Dimension3>& pml = mesh.GetPmlArea(0);

// adding PML for x < xmin, y < ymin and y > ymax, z> zmax
// here we use the syntax of AddPML keyword
Vector<string> param(4);
param(0) = "YES"; param(1) = "X-YZ+"; param(2) = to_str(2.0); param(3) = to_str(4);
pml.SetParameters(param);

// mesh is modified in order to add those PML
pml.AddPML(0, mesh);

Location :

AddPML

Syntax

void AddPML(int num_region, Mesh<Dimension3>& mesh)

This method is used to add PML elements to a given mesh. num_region is the number of the PML region.

Example :

Mesh<Dimension3> mesh;

// reading the mesh
mesh.Read("exemple.mesh");

// if you want only one PML region
mesh.ReallocatePmlAreas(1);
PmlRegionParameter<Dimension3>& pml = mesh.GetPmlArea(0); // number of the region is 0

// adding PML for x < xmin, y < ymin and y > ymax, z > zmax
int nb_layers = 2;
pml.SetAdditionPML(pml.PML_NEGATIVE_SIDE, pml.PML_BOTH_SIDES, pml.PML_POSITIVE_SIDE, nb_layers);
pml.SetThicknessPML(1.5);

// mesh is modified in order to add those PML
pml.AddPML(0, mesh);

Location :

GetAverageLengthOnBoundary

Syntax

Real_wp GetAverageLengthOnBoundary(const Mesh<Dimension3>& mesh) const

This method returns the mesh size for all the edges of the outer boundary of the PML region.

Example :

Mesh<Dimension3> mesh;

mesh.SetGeometryOrder(3);
mesh.Read("test.mesh");

// mesh size on the outer boundary of PML
PmlRegionParameter<Dimension3>& pml = mesh.GetPmlArea(0);

double h = pml.GetAverageLengthOnBoundary(mesh);

Location :

AddPMLElements

Syntax

void AddPMLElements(int nb_layers, int num, const Mesh<Dimension3>& mesh)

This method adds PML layers to a mesh. You need to provide the number of layers. If you want to compute automatically this number (from the mesh size and thickness of PML), the method AddPML should be used.

Example :

Mesh<Dimension3> mesh;

// reading the mesh
mesh.Read("exemple.mesh");

// if you want only one PML region
mesh.ReallocatePmlAreas(1);
PmlRegionParameter<Dimension3>& pml = mesh.GetPmlArea(0); // number of the region is 0

// adding PML for x < xmin, y < ymin and y > ymax, z > zmax
int nb_layers = 2;
pml.SetAdditionPML(mesh.PML_NEGATIVE_SIDE, mesh.PML_BOTH_SIDES, mesh.PML_POSITIVE_SIDE, nb_layers);
pml.SetThicknessPML(1.5);

// mesh is modified in order to add those PML
pml.AddPMLElements(nb_layers, 0, mesh);

Location :

GetNbParameters

Syntax

int GetNbParameters() const

This method returns the number of parameters associated with the PML region.

Example :

Mesh<Dimension3> mesh;

// reading the mesh
mesh.Read("exemple.mesh");

// if you want only one PML region
mesh.ReallocatePmlAreas(1);
PmlRegionParameter<Dimension3>& pml = mesh.GetPmlArea(0); // number of the region is 0

// adding PML for x < xmin, y < ymin and y > ymax, z > zmax
int nb_layers = 2;
pml.SetAdditionPML(mesh.PML_NEGATIVE_SIDE, mesh.PML_BOTH_SIDES, mesh.PML_POSITIVE_SIDE, nb_layers);
pml.SetThicknessPML(1.5);

// number of parameters ?
int nb_param = pml.GetNbParameters();

Location :

FillParameters

Syntax

void FillParameters(VectReal_wp& all_param, int& param_num)

This method appends to the array all_param the parameters associated with the PML region. The values are appended from the index param_num which is incremented.

Example :

Mesh<Dimension3> mesh;

// reading the mesh
mesh.Read("exemple.mesh");

// if you want only one PML region
mesh.ReallocatePmlAreas(1);
PmlRegionParameter<Dimension3>& pml = mesh.GetPmlArea(0); // number of the region is 0

// adding PML for x < xmin, y < ymin and y > ymax, z > zmax
int nb_layers = 2;
pml.SetAdditionPML(mesh.PML_NEGATIVE_SIDE, mesh.PML_BOTH_SIDES, mesh.PML_POSITIVE_SIDE, nb_layers);
pml.SetThicknessPML(1.5);

// storing parameters of the PML
VectReal_wp all_param(20);
int num_param = 10;
pml.FillParameters(all_param, num_param);
// all_param(10:10+num_param) will contain parameters of the PML

Location :

SetRegion

Syntax

void SetRegion(const VectReal_wp& all_param, int& param_num)

This method sets parameters of the PML region with the array all_param. The values are read from the index param_num which is incremented. This method is the reciprocal of FillParameters.

Example :

Mesh<Dimension3> mesh;

// reading the mesh
mesh.Read("exemple.mesh");

// if you want only one PML region
mesh.ReallocatePmlAreas(1);
PmlRegionParameter<Dimension3>& pml = mesh.GetPmlArea(0); // number of the region is 0

// adding PML for x < xmin, y < ymin and y > ymax, z > zmax
int nb_layers = 2;
pml.SetAdditionPML(mesh.PML_NEGATIVE_SIDE, mesh.PML_BOTH_SIDES, mesh.PML_POSITIVE_SIDE, nb_layers);
pml.SetThicknessPML(1.5);

// storing parameters of the PML
VectReal_wp all_param(20);
int num_param = 10;
pml.FillParameters(all_param, num_param);
// all_param(10:10+num_param) will contain parameters of the PML

// you can set a region with the stored parameters
PmlRegionParameter<Dimension3> pml2;
num_param = 10;
pml2.SetRegion(all_param, num_param);

Location :

GetNbReferences

Syntax

int GetNbReferences() const

This method returns the number of references (Physical Line for Gmsh) potentially present in the mesh. We take into account only references related to edges. If you want to create a new reference number, use the method GetNewReference so that arrays are resized correctly.

Example :

Mesh<Dimension3> mesh;
// we read the mesh
mesh.Read("test.mesh");
// loop over references of the mesh
for (int ref = 0; ref <= mesh.GetNbReferences(); ref++)
  if (mesh.GetCurveType(ref) > 0)
    cout << "Type of curve : " << mesh.GetCurveType(ref) << endl;

Location :

GetCurveType

Syntax

int GetCurveType(int ref) const

This method returns the curve type associated with a reference (e.g. CURVE_SPHERE, CURVE_CYLINDER).

Example :

Mesh<Dimension3> mesh;
// we read the mesh
mesh.Read("test.mesh");
// loop over references of the mesh
for (int ref = 0; ref <= mesh.GetNbReferences(); ref++)
  if (mesh.GetCurveType(ref) > 0)
    cout << "Type of curve : " << mesh.GetCurveType(ref) << endl;

Location :

GetBoundaryCondition

Syntax

int GetBoundaryCondition(int ref) const

const IVect& GetBoundaryCondition() const

This method returns the boundary condition associated with a reference (e.g. LINE_DIRICHLET, LINE_NEUMANN).

Example :

Mesh<Dimension3> mesh;
// we read the mesh
mesh.Read("test.mesh");
// loop over references of the mesh
for (int ref = 0; ref <= mesh.GetNbReferences(); ref++)
  if (mesh.GetBoundaryCondition(ref) > 0)
    cout << "Boundary condition of curve : " << mesh.GetBoundaryCondition(ref) << endl;

// you can also retrieve the array containing all the boundary conditions
const IVect& Cond_curve = mesh.GetBoundaryCondition();

Location :

GetBodyNumber

Syntax

int GetBodyNumber(int ref) const

const IVect& GetBodyNumber() const

This method returns the body number associated with a reference. Bodies are currently used to specify transparent condition in Montjoie.

Example :

Mesh<Dimension3> mesh;
// we read the mesh
mesh.Read("test.mesh");

// you can get a single body number
int n = mesh.GetBodyNumber(4);

// you can also retrieve the array containing all the body numbers
const IVect& Cond_curve = mesh.GetBodyNumber();

Location :

GetCurveParameter

Syntax

void GetCurveParameter(int ref, VectReal_wp& param) const

const VectReal_wp& GetCurveParameter(int ref) const

This method returns the curve parameters associated with a curve. For example, parameters of sphere consist of the center and radius.

Example :

Mesh<Dimension3> mesh;
// we read the mesh
mesh.SetCurveType(1, mesh.CURVE_SPHERE);
mesh.Read("test.mesh");

// the parameters of sphere should have been found 
Vector<double> param = mesh.GetCurveParameter(1);

// center of sphere and radius
R3 center; Real_wp radius;
center.Init(param(0), param(1), param(2));
radius = param(3);

Location :

GetCurveFunctions1D

Syntax

Globatto<Real_wp>& GetCurveFunctions1D() const

This method returns the basis functions associated with Gauss-Lobatto points (for curved edges).

Example :

Mesh<Dimension3> mesh;
// we read the mesh
mesh.SetOrderGeometry(4);
mesh.Read("test.msh");

// if you need basis functions used for curved boundaries
Globatto<Real_wp>& lob = mesh.GetCurveFunctions1D();

// you can evaluate basis functions
VectReal_wp phi; Real_wp x(0.6);
lob.ComputeValuesPhiRef(x, phi);
DISP(phi);

Location :

GetNbPmlAreas

Syntax

int GetNbPmlAreas() const

This method returns the number of PML regions in the mesh.

Example :

Mesh<Dimension3> mesh;

// you change the number of PML regions
mesh.ReallocatePmlAreas();

// you can access to a PML region
PmlRegionParameter<Dimension3>& pml0 = mesh.GetPmlArea(0);
PmlRegionParameter<Dimension3>& pml1 = mesh.GetPmlArea(1);

// sets PML parameters for each region
pml0.SetAdditionPML(pml0.PML_POSITIVE_SIDE, pml0.PML_NO, pml0.PML_BOTH_SIDES, 3);
pml1.SetAdditionPML(pml0.PML_NO, pml0.PML_NEGATIVE_SIDE, pml0.PML_NO, 4);

// if you call ConstructMesh, the PMLs will be automatically added
// with the provided parameters
Vector<string> param(1); param(0) = "test.mesh";
mesh.ConstructMesh(mesh.HEXAHEDRAL_MESH, param);

// you can retrieve the number of PML regions
int nb_pml_area = mesh.GetNbPmlAreas()

Location :

ReallocatePmlAreas

Syntax

void ReallocatePmlAreas(int n)

This method changes the number of PML regions in the mesh (previous parameters are cleared).

Example :

Mesh<Dimension3> mesh;

// you change the number of PML regions
mesh.ReallocatePmlAreas();

// you can access to a PML region
PmlRegionParameter<Dimension3>& pml0 = mesh.GetPmlArea(0);
PmlRegionParameter<Dimension3>& pml1 = mesh.GetPmlArea(1);

// sets PML parameters for each region
pml0.SetAdditionPML(pml0.PML_POSITIVE_SIDE, pml0.PML_NO, pml0.PML_BOTH_SIDES, 3);
pml1.SetAdditionPML(pml0.PML_NO, pml0.PML_NEGATIVE_SIDE, pml0.PML_NO, 4);

// if you call ConstructMesh, the PMLs will be automatically added
// with the provided parameters
Vector<string> param(1); param(0) = "test.mesh";
mesh.ConstructMesh(mesh.HEXAHEDRAL_MESH, param);

// you can retrieve the number of PML regions
int nb_pml_area = mesh.GetNbPmlAreas()

Location :

GetPmlArea

Syntax

PmlRegionParameter<Dimension3>& GetPmlArea(int i) const

This method gives an access to a PML region.

Example :

Mesh<Dimension3> mesh;

// you change the number of PML regions
mesh.ReallocatePmlAreas();

// you can access to a PML region
PmlRegionParameter<Dimension3>& pml0 = mesh.GetPmlArea(0);
PmlRegionParameter<Dimension3>& pml1 = mesh.GetPmlArea(1);

// sets PML parameters for each region
pml0.SetAdditionPML(pml0.PML_POSITIVE_SIDE, pml0.PML_NO, pml0.PML_BOTH_SIDES, 3);
pml1.SetAdditionPML(pml0.PML_NO, pml0.PML_NEGATIVE_SIDE, pml0.PML_NO, 4);

// if you call ConstructMesh, the PMLs will be automatically added
// with the provided parameters
Vector<string> param(1); param(0) = "test.mesh";
mesh.ConstructMesh(mesh.HEXAHEDRAL_MESH, param);

// you can retrieve the number of PML regions
int nb_pml_area = mesh.GetNbPmlAreas()

Location :

SetBoundaryCondition

Syntax

void SetBoundaryCondition(int ref, int cond)

This method sets the boundary condition associated with a reference (e.g. LINE_DIRICHLET, LINE_NEUMANN). The list of boundary conditions is present in class BoundaryConditionEnum, the following boundary conditions are available :

LINE_INSIDE : no boundary condition
LINE_DIRICHLET : Dirichlet boundary condition
LINE_NEUMANN : Neumann boundary condition
LINE_ABSORBING : Absorbing boundary condition
LINE_HIGH_CONDUCTIVITY : High-conductivity boundary condition (for Helmholtz equation only)
LINE_IMPEDANCE : Impedance boundary condition (Robin)
LINE_THIN_SLOT : thin-slot boundary condition (for 2-D Helmholtz equation only)
LINE_NEIGHBOR : boundary shared by two different processors (parallel computation)
LINE_TRANSMISSION : Transmission boundary condition
LINE_DTN : Non-local Dirichlet-To-Neumann (not implemented)
LINE_SUPPORTED : Dirichlet boundary condition on some unknowns (Neumann for other unknowns)
LINE_TRANSPARENT : Transparent boundary condition

Example :

Mesh<Dimension3> mesh;
// we read the mesh
mesh.Read("test.mesh");

// setting Dirichlet boundary condition with reference 2
mesh.SetBoundaryCondition(2, mesh.LINE_DIRICHLET);

Location :

SetCurveType

Syntax

void SetCurveType(int ref, int type)

This method sets the curve type associated with a reference (e.g. CURVE_CIRCLE, CURVE_SPLINE). The following types of curve are available

NO_CURVE : default type (straight faces)
CURVE_SPHERE : part of a sphere
CURVE_CYLINDER : part of a cylinder
CURVE_CONIC : part of a conical cylinder
CURVE_FILE : intermediary points defined on the file mesh

For CURVE_FILE, it is automatically managed (you don't need to specify it) when you read a file. For all the curves, it is required to call SetGeometryOrder with the desired order of approximation (for computation of intermediary points).

Example :

Mesh<Dimension3> mesh;

// setting order of geometry
mesh.SetGeometryOrder(3);

// setting curves before reading mesh
mesh.SetCurveType(2, mesh.CURVE_CYLINDER);

// we read the mesh
mesh.Read("test.mesh");

Location :

SetBodyNumber

Syntax

void SetBodyNumber(int ref, int num)

This method sets the body number associated with a reference. It may be useful to group several references into a single body. Bodies are currently used to specify transparent condition in Montjoie.

Example :

Mesh<Dimension3> mesh;
// we read the mesh
mesh.Read("test.mesh");

// you can set a body with references 2 4 5
int num = 1;
mesh.SetBodyNumber(2, num);
mesh.SetBodyNumber(4, num);
mesh.SetBodyNumber(5, num);

Location :

SetCurveParameter

Syntax

void SetCurveParameter(int ref, const VectReal_wp& param)

This method modifies the parameters associated with a curve. For example, parameters of circles consist of the center and radius. Here the list of 3-D curved surfaces with parameters :

CURVE_SPHERE : center Ox, Oy, Oz and radius r
CURVE_CYLINDER : center Ox, Oy, Oz, axis ux, uy, uz and radius r
CURVE_CONIC : center Ox, Oy, Oz, axis ux, uy, uz and angle teta

Example :

Mesh<Dimension3> mesh;
// we read the mesh
mesh.SetCurveType(1, mesh.CURVE_SPHERE);
// parameters : center of sphere and radius
Vector<double> param(4);
param(0) = 0;
param(1) = 0;
param(2) = 0;
param(3) = 2.0;
mesh.SetCurveParameter(1, param);
mesh.Read("test.mesh");

Location :

CopyCurves

Syntax

void CopyCurves(const Mesh<Dimension3>& mesh)

This method copies the curves of a mesh.

Example :

Mesh<Dimension3> mesh;
// we read the mesh
mesh.SetCurveType(1, mesh.CURVE_SPHERE);
// parameters : center of sphere and radius
Vector<double> param(4);
param(0) = 0;
param(1) = 0;
param(2) = 0;
param(3) = 2.0;
mesh.SetCurveParameter(1, param);
mesh.Read("test.mesh");

Mesh<Dimension3> mesh2;

// we copy curves of first mesh
mesh2.CopyCurves(mesh);

Location :

CopyInputData

Syntax

void CopyInputData(Mesh<Dimension3>& mesh)

This method copies the input datas of another mesh. The input datas are the parameters provided in the data file.

Example :

Mesh<Dimension3> mesh;
// we read the mesh
mesh.SetCurveType(1, mesh.CURVE_SPHERE);
// parameters : center of sphere and radius
Vector<double> param(4);
param(0) = 0;
param(1) = 0;
param(2) = 0.0;
param(3) = 2.0;
mesh.SetCurveParameter(1, param);
mesh.Read("test.mesh");

Mesh<Dimension3> mesh2;

// we copy all input data of the mesh
mesh2.CopyInputData(mesh);

Location :

GetNewReference

Syntax

int GetNewReference()

This method returns an unused reference number.

Example :

Mesh<Dimension3> mesh;
mesh.Read("test.mesh");

// new reference number
int new_ref = mesh.GetNewReference();

Location :

ResizeNbReferences

Syntax

void ResizeNbReferences(int n)

This method modifies the number of available references (arrays are resized). If you want to add a new reference, you can call GetNewReference instead.

Example :

Mesh<Dimension3> mesh;
mesh.Read("test.mesh");

mesh.ResizeNbReferences(20);

Location :

SetNewReference

Syntax

void SetNewReference(int ref, int type, int cond)

This method modifies the curve type and boundary condition associated with a reference.

Example :

Mesh<Dimension3> mesh;
mesh.Read("test.mesh");

// new reference number
int new_ref = mesh.GetNewReference();

// setting curve type and boundary condition
mesh.SetNewReference(new_ref, mesh.CURVE_SPHERE, mesh.LINE_NEUMANN);

Location :

GetNbPeriodicReferences

Syntax

int GetNbPeriodicReferences() const

This method returns the number of periodic conditions, each time you wrote PERIODICITY, PERIODIC_X, PERIODIC_Y, PERIODIC_Z or CYCLIC in the data file.

Example :

Mesh<Dimension3> mesh;

// adding periodic conditions
TinyVector<int, 2> num;
num(0) = 3; num(1) = 6;
mesh.AddPeriodicCondition(num, BoundaryConditionEnum::PERIODIC_CTE);

// reading the mesh
mesh.Read("exemple.mesh");

// GetNbPeriodicReferences should return 1 here
int nb_per = mesh.GetNbPeriodicReferences();

Location :

GetPeriodicReference

Syntax

int GetPeriodicReference(int num, int j) const

This method returns the first or second reference for the periodic condition num. Indeed, for each boundary condition, the user provides two references (the two curves that face them-selves), which can be accessed through this method.

Example :

Mesh<Dimension3> mesh;

// adding periodic conditions
TinyVector<int, 2> num;
num(0) = 3; num(1) = 6;
mesh.AddPeriodicCondition(num, int n0 = mesh.GetPeriodicReference(0, 0);PERIODIC_CTE);

// reading the mesh
mesh.Read("exemple.mesh");

// GetPeriodicReference to retrieve the numbers given in AddPeriodicCondition
int n0 = mesh.GetPeriodicReference(0, 0);
int n1 = mesh.GetPeriodicReference(0, 1);
// here n0 should be equal to 3 and n1 to 6

Location :

AddPeriodicCondition

Syntax

void AddPeriodicCondition(const TinyVector<int, 2>& ref, int type_periodicity)

This method adds periodic condition to the mesh. You give the two opposite references in the array ref, and the type of periodicity. The following types of periodicity are accepted :

PERIODIC_CTE : trace of solution is the same on two boundaries
PERIODIC_THETA : cyclic domain (periodicity with respect to theta)
PERIODIC_X : periodicity of the mesh with respect to x
PERIODIC_Y : periodicity of the mesh with respect to y
PERIODIC_Z : periodicity of the mesh with respect to z

Example :

Mesh<Dimension3> mesh;

// adding periodic conditions for x-coordinate
TinyVector<int, 2> num;
num(0) = 3; num(1) = 6;
mesh.AddPeriodicCondition(num, BoundaryConditionEnum::PERIODIC_X);

// and y-coordinate
num(0) = 2; num(1) = 5;
mesh.AddPeriodicCondition(num, BoundaryConditionEnum::PERIODIC_Y);

// reading the mesh
mesh.Read("exemple.mesh");

// numbering the mesh (assuming that number_map is correctly filled)
mesh.NumberMesh();

Location :

GetPeriodicAlpha, SetPeriodicAlpha

Syntax

Real_wp GetPeriodicAlpha() const

void SetPeriodicAlpha(Real_wp alpha)

The method GetPeriodicAlpha returns the angle of the section (i.e. 2 Pi/N). The method SetPeriodicAlpha sets this angle. Usually, you don't need to call this method because the angle is automatically computed when the mesh is read (or constructed).

Example :

Mesh<Dimension3> mesh;

// adding periodic conditions for a cyclic mesh
TinyVector<int, 2> num(2);
num(0) = 3; num(1) = 6;
mesh.AddPeriodicCondition(num, BoundaryConditionEnum::PERIODIC_THETA);

// reading the mesh
mesh.Read("exemple.mesh");

// when the mesh is read, the angle alpha should have been computed
double alpha = mesh.GetPeriodicAlpha();

Location :

ClearPeriodicCondition

Syntax

void ClearPeriodicCondition()

This method clears informations about periodic conditions associated with the mesh.

Example :

Mesh<Dimension3> mesh;

// adding periodic conditions for cyclic mesh
TinyVector<int, 2> num;
num(0) = 3; num(1) = 6;
mesh.AddPeriodicCondition(num, BoundaryConditionEnum::PERIODIC_THETA);

// you may want to remove them
mesh.ClearPeriodicConditions();

// and adding correct conditions
num(0) = 3; num(1) = 5;
mesh.AddPeriodicCondition(num, BoundaryConditionEnum::PERIODIC_CTE);

// reading the mesh
mesh.Read("exemple.mesh");

Location :

GetSafetyCoef

Syntax

Real_wp GetSafetyCoef(int i) const

This method returns the safety coefficient used for an element in order to invert transformation Fi. Curved elements are attributed a non-null coefficient so that all the points of the display grid are correctly found.

Example :

Mesh<Dimension3> mesh;

cout << "Safety coefficient for element 0 = " << mesh.GetSafetyCoef(0) << endl;

Location :

AreCurveEqual

Syntax

bool AreCurveEqual(int ref1, int ref2) const

This method returns true if the curves associated with references ref1 and ref2 are the same.

Example :

Mesh<Dimension3> mesh;

int ref1 = 2;
int ref2 = 4;
mesh.SetCurveType(ref1, mesh.CURVE_SPHERE);
mesh.SetCurveType(ref2, mesh.CURVE_SPHERE);

mesh.Read("test.mesh");

if (mesh.AreCurveEqual(ref1, ref2)
  cout << "Curve equal" << endl;

Location :

GetGeometryOrder

Syntax

int GetGeometryOrder() const

This method returns the order of approximation r used for the definition of geometry. Each curved edge will then be described by two extremities and r-1 intermediary points (placed at Gauss-Lobatto points).

Example :

Mesh<Dimension3> mesh;

mesh.SetGeometryOrder(3);
mesh.Read("test.mesh");

// should give r = 3
int r = mesh.GetGeometryOrder();

Location :

GetInterpolate1D

Syntax

Real_wp GetInterpolate1D(int i, const Real_wp& x) const

This method returns an evaluation of Lagrange interpolation functions (based on Gauss-Lobatto points).

Example :

Mesh<Dimension3> mesh;

mesh.SetGeometryOrder(3);
mesh.Read("test.mesh");

// returns phi_0(x)
double x = 0.23;
double y = mesh.GetInterpolate1D(0, x);

Location :

GetNodalPointInsideEdge

Syntax

Real_wp GetNodalPointInsideEdge(int i) const

This method returns intermediary points used for curved elements. It should be Gauss-Lobatto points.

Example :

Mesh<Dimension3> mesh;

mesh.SetGeometryOrder(3);
mesh.Read("test.mesh");

// intermediary points (on unit interval [0,1])
for (int i = 0; i < mesh.GetGeometryOrder()-1; i++)
  cout << i << "-th intermediary point " << mesh.GetNodalPointInsideEdge(i) << endl;

Location :

FindEdgeRefWithExtremities, FindEdgeWithExtremities

Syntax

int FindEdgeWithExtremities(int n1, int n2) const

int FindEdgeRefWithExtremities(int n1, int n2) const

This method returns the edge number of edge whose extremities are n1 and n2. You can also retrieve the reference edge number (but it is the same as global edge number, except if the edge is not referenced. In that case, the method will return -1). The cost of this method is in constant time, since we are looking all the edges leaving vertex n1 and n2.

Example :

Mesh<Dimension3> mesh;

mesh.SetGeometryOrder(3);
mesh.Read("test.mesh");

// edge between vertex 13 and 18 ?
int ne = mesh.FindEdgeWithExtremities(13, 18);
if (ne < 0)
  cout << "Edge not existing " << endl;

Location :

ClearCurves

Syntax

void ClearCurves()

This method clears informations about predefined curves.

Example :

Mesh<Dimension3> mesh;

// adding a predefined curve
mesh.SetCurveType(1, mesh.CURVE_SPHERE);

mesh.SetGeometryOrder(3);
mesh.Read("test.mesh");

// clearing predefined curves
mesh.ClearCurves();

// reading another mesh (without sphere)
mesh.Read("test2.mesh");

Location :

IsBoundaryCurved

Syntax

bool IsBoundaryCurved(int i) const

This method returns true if the i-th face is curved.

Example :

Mesh<Dimension3> mesh;

mesh.SetGeometryOrder(3);
mesh.Read("test.msh");

// face 11 is curved ?
if (mesh.IsBoundaryCurved(11))
  cout << "Face 11 is curved" << endl;

Location :

GetPointInsideEdge

Syntax

R3 GetPointInsideEdge(int i, int k) const

This method returns the k-th intermediary point of edge i.

Example :

Mesh<Dimension3> mesh;

mesh.SetGeometryOrder(3);
mesh.Read("test.mesh");

// loop over referenced edges
for (int i = 0; i < mesh.GetNbEdgesRef(); i++)
  for (int k = 0; k < mesh.GetGeometryOrder()-1; k++)
    {
      // intermediary point of edge i
      R3 point = mesh.GetPointInsideEdge(i, k);
    }

Location :

SetPointInsideEdge

Syntax

void SetPointInsideEdge(int i, int k, R3 point)

This method sets the k-th intermediary point of edge i. This low-level routine should not be used in a regular use since, since these points are already computed when the mesh is constructed (or read from a file).

Example :

Mesh<Dimension3> mesh;

mesh.SetGeometryOrder(3);
mesh.Read("test.mesh");

// loop over referenced edges
for (int i = 0; i < mesh.GetNbEdgesRef(); i++)
  {
    // extremities of the edge
    R3 ptA = mesh.Vertex(mesh.EdgeRef(i).numVertex(0));
    R3 ptB = mesh.Vertex(mesh.EdgeRef(i).numVertex(1));
    for (int k = 0; k < mesh.GetGeometryOrder()-1; k++)
      {
        // intermediary point of edge i, for example barycenter (straight edge)
        Real_wp lambda = mesh.GetNodalPointInsideEdge(k);
        R3 point = (1.0-lambda)*ptA + lambda*ptB;
        mesh.SetPointInsideEdge(i, k, point);
      }
   }

Location :

GetPointInsideFace

Syntax

R3 GetPointInsideFace(int i, int k) const

VectR3 GetPointInsideFace(int i) const

This method returns the k-th internal point of face i. It can also return all the internal points of the face. For a third-order approximation, a curved triangle will contain only one internal point (other points are located on the edges), whereas a curved quadrilateral will contain four internal points.

Example :

Mesh<Dimension3> mesh;

mesh.SetGeometryOrder(3);
mesh.Read("test.mesh");

// loop over referenced faces
for (int i = 0; i < mesh.GetNbBoundaryRef(); i++)
{
   for (int k = 0; k < mesh.GetNbPointsInsideFace(i); k++)
    {
      // internal point of face i
      R3 point = mesh.GetPointInsideFace(i, k);
    }

   // if you need all the points of the face i :
   VectR3 all_points = mesh.GetPointInsideFace(i);
}

Location :

SetPointInsideFace

Syntax

void SetPointInsideFace(int i, int k, R3 point)

void SetPointInsideFace(int i, VectR3 point)

This method sets the k-th intern point of face i. It can also set all the points. This low-level routine should not be used in a regular use since, since these points are already computed when the mesh is constructed (or read from a file).

Location :

GetNbPointInsideFace

Syntax

int GetNbPointInsideFace(int i) const

This method returns the number of intern points associated with the curved face i. It should return (r-1)² for a curved quadrilateral and (r-1)(r-2)/2 for a curved triangle where r stands for the geometry order.

Example :

Mesh<Dimension3> mesh;

mesh.SetGeometryOrder(3);
mesh.Read("test.mesh");

// loop over referenced faces
for (int i = 0; i < mesh.GetNbBoundaryRef(); i++)
{
   for (int k = 0; k < mesh.GetNbPointsInsideFace(i); k++)
    {
      // internal point of face i
      R3 point = mesh.GetPointInsideFace(i, k);
    }
}

Location :

RemoveReference

Syntax

void RemoveReference(int ref)

This method removes all the faces whose reference is ref.

Example :

Mesh<Dimension3> mesh;

mesh.SetGeometryOrder(3);
mesh.Read("test.mesh");

// removing faces of reference 3
mesh.RemoveReference(3);

Location :

GetSurfaceFiniteElement, GetSurfaceFiniteElement2

Syntax

TriangleGeomReference& GetSurfaceFiniteElement() const

QuadrangleGeomReference& GetSurfaceFiniteElement2() const

The method GetSurfaceFiniteElement returns the triangular finite element used for curved triangles. The method GetSurfaceFiniteElement2 returns the quadrangular finite element used for curved quadrilaterals.

Example :

Mesh<Dimension3> mesh;

mesh.SetGeometryOrder(3);
mesh.Read("test.msh");

// we retrieve the triangular finite element
TriangleGeomReference& tri = mesh.GetSurfaceFiniteElement();

// we retrieve the quadrangular finite element
QuadrangleGeomReference& quad = mesh.GetSurfaceFiniteElement2();

Location :

SortPeriodicBoundaries

Syntax

void SortPeriodicBoundaries()

This method changes vertex numbers of the mesh so that matching faces (of two opposite boundaries) have the same orientation. This method is automatically called when reading a mesh, so you should not call this method in regular use.

Example :

Mesh<Dimension3> mesh;

mesh.SetGeometryOrder(3);
mesh.Read("test.mesh");

// if you set a periodic condition after reading
TinyVector<int, 2> num;
num(0) = 3; num(1) = 5;
mesh.AddPeriodicCondition(num, BoundaryConditionEnum::PERIODIC_CTE);

// changing vertex numbers because of that periodic condition
mesh.SortPeriodicBoundaries();

// then you need to call those two functions
mesh.SortEdgesRef();
mesh.SortBoundariesRef();
mesh.FindConnectivity();

Location :

SortBoundariesRef

Syntax

void SortBoundariesRef()

This method sorts referenced faces so that the first extremity has the lowest number. This method is actually called when reading a mesh, so you don't need to call that method in regular use.

Example :

Mesh<Dimension3> mesh;

mesh.SetGeometryOrder(3);
mesh.Read("test.mesh");

// if you set a periodic condition after reading
TinyVector<int, 2> num;
num(0) = 3; num(1) = 5;
mesh.AddPeriodicCondition(num, BoundaryConditionEnum::PERIODIC_CTE);

// changing vertex numbers because of that periodic condition
mesh.SortPeriodicBoundaries();

// then you need to call those two functions
mesh.SortEdgesRef();
mesh.SortBoundariesRef();
mesh.FindConnectivity();

Location :

SortEdgesRef

Syntax

void SortEdgesRef()

This method sorts referenced edges so that the first extremity has the lowest number. This method is actually called when reading a mesh, so you don't need to call that method in regular use.

Example :

Mesh<Dimension3> mesh;

mesh.SetGeometryOrder(3);
mesh.Read("test.mesh");

// if you set a periodic condition after reading
TinyVector<int, 2> num;
num(0) = 3; num(1) = 5;
mesh.AddPeriodicCondition(num, BoundaryConditionEnum::PERIODIC_CTE);

// changing vertex numbers because of that periodic condition
mesh.SortPeriodicBoundaries();

// then you need to call those two functions
mesh.SortEdgesRef();
mesh.SortBoundariesRef();
mesh.FindConnectivity();

Location :

GetGeometryFaceRotation

Syntax

void GetGeometryFaceRotation(Matrix<int>& RotationTri, Matrix<int>& RotationQuad) const

This method fills the arrays RotationTri and RotationTri that contain the rotation of nodal numbers on triangles and quadrangles. The orientations are explained in the method GetRotationFaceDof.

Example :

Mesh<Dimension3> mesh;

mesh.SetGeometryOrder(3);
mesh.Read("test.mesh");

// if you want to retrieve node numbers after a rotation of a triangle/quadrangle;
Matrix<int> RotationTri, RotationQuad;
mesh.GetGeometryFaceRotation(RotationTri, RotationQuad);

Location :

ConstructCrossReferenceBoundaryRef

Syntax

void ConstructCrossReferenceBoundaryRef()

This method links referenced faces with global faces. This should not be called in regular use. It is already called when the mesh is read/constructed or if you call FindConnectivity.

Example :

Mesh<Dimension3> mesh;

mesh.SetGeometryOrder(3);
mesh.Read("test.mesh");

// already done, so useless to call it
mesh.ConstructCrossReferenceBoundaryRef();

Location :

ConstructCrossReferenceEdgeRef

Syntax

void ConstructCrossReferenceEdgeRef()

This method links referenced edges with global edges. This should not be called in regular use. It is already called when the mesh is read/constructed or if you call FindConnectivity.

Example :

Mesh<Dimension3> mesh;

mesh.SetGeometryOrder(3);
mesh.Read("test.mesh");

// already done, so useless to call it
mesh.ConstructCrossReferenceEdgeRef();

Location :

AddBoundaryFaces

Syntax

void AddBoundaryFaces()

void AddBoundaryEdges()

This method detects isolated faces (located on the boundary) without reference, and gives them a new reference. It is already called when reading a mesh. It can be useful to call this function if you constructed manually a mesh. Actually the function AddBoundaryEdges is equal to the function AddBoundaryFaces, isolated faces are retrieved.

Example :

Mesh<Dimension3> mesh;

// you construct manually a mesh
mesh.ReallocateVertices(25);
mesh.Vertex(0).Init(1.0, 2.4, 0.8);
// ...
mesh.ReallocateElements(10);
mesh.Element(0).InitTetrahedral(0, 2, 5, 8, 1);
// ...

// you call FindConnectivity to construct all the faces
mesh.FindConnectivity();

// you did not provide boundary faces in the array BoundaryRef
// a way to retrieve them is to call AddBoundaryFaces
mesh.AddBoundaryFaces();

Location :

ProjectPointsOnCurves

Syntax

void ProjectPointsOnCurves()

This method projects intern points of edges/faces on predefined curves of the mesh. In regular use, you don't need to call that method.

Example :

Mesh<Dimension3> mesh;

// reading mesh
mesh.SetGeometryOrder(3);
mesh.Read("test.mesh");

// SetCurve should have been called before but you call it after 
mesh.SetCurveType(1, mesh.CURVE_SPHERE);

// in that case, you need to call ProjectPointsOnCurves to project points on the curved surfaces
mesh.ProjectPointsOnCurves();

Location :

RedistributeReferences

Syntax

void RedistributeReferences()

This method redistribute references for boundary faces. For each isolated curved surface, a different reference is given. This method is useful if you have a mesh without referenced faces, since each boundary will be attributed with a different reference.

Example :

Mesh<Dimension3> mesh;

// reading mesh
mesh.SetGeometryOrder(3);
mesh.Read("test.mesh");

// the mesh does not have referenced faces, you call RedistributeReferences
// to distinguish the different boundaries/holes of the mesh
mesh.RedistributeReferences();

Location :

GetNeighboringBoundariesAroundVertex

Syntax

void GetNeighboringBoundariesAroundVertex(int i, IVect& num) const

This method returns a list of faces sharing the point i. Only faces such that i is the lowest number are retrieved.

Location :

CheckCurveParameter

Syntax

void CheckCurveParameter(int ref)

This method checks that the parameters associated with the reference ref are correct. If one parameter is not correct, a message and displayed and the program is aborted.

Example :

Mesh<Dimension3> mesh;

// setting curve parameters
mesh.SetCurveType(1, mesh.CURVE_SPHERE);
// parameters : center of sphere and radius
Vector<double> param(4);
param(0) = 0;
param(1) = 0;
param(2) = 0;
param(3) = 2.0;
mesh.SetCurveParameter(1, param);

// you can check that parameters of reference 1 are correct
mesh.CheckCurveParameter(1);

// reading mesh
mesh.SetGeometryOrder(3);
mesh.Read("test.mesh");

Location :

GetNodalPointsOnFace

Syntax

void GetNodalPointsOnFace(int i, VectR3& PtFace) const

This method fills the array PtFace with nodal points of the face i. It computes all nodal points of the face i, including vertices and nodal points located on the edges of the face i.

Example :

Mesh<Dimension3> mesh;

// setting curve parameters
mesh.SetCurveType(1, mesh.CURVE_SPHERE);
// parameters : center of sphere and radius
Vector<double> param(4);
param(0) = 0;
param(1) = 0;
param(2) = 0;
param(3) = 2.0;
mesh.SetCurveParameter(1, param);

// reading mesh
mesh.SetGeometryOrder(3);
mesh.Read("test.mesh");

// if you want to display nodal points of a given face
int num_face = 15; VectR3 nodal_points;
mesh.GetNodalPointsOnFace(num_face, nodal_points);
cout << "Nodal points = " << nodal_points << endl;

Location :

SetStraightEdge

Syntax

void SetStraightEdge(int i)

This method overwrites intern points of the edge i such as the edge would be straight (i.e. not curved).

Example :

Mesh<Dimension3> mesh;

// setting curve parameters
mesh.SetCurveType(1, mesh.CURVE_SPHERE);
// parameters : center of sphere and radius
Vector<double> param(4);
param(0) = 0;
param(1) = 0;
param(2) = 0;
param(3) = 2.0;
mesh.SetCurveParameter(1, param);

// reading mesh
mesh.SetGeometryOrder(3);
mesh.Read("test.mesh");

// if you want to force a straight edge for edge 4 :
mesh.SetStraightEdge(4);

Location :

SetStraightFace

Syntax

void SetStraightFace(int i)

This method overwrites intern points of the face i such as the curvature of the faces comes only from curved edges.

Example :

Mesh<Dimension3> mesh;

// setting curve parameters
mesh.SetCurveType(1, mesh.CURVE_SPHERE);
// parameters : center of sphere and radius
Vector<double> param(4);
param(0) = 0;
param(1) = 0;
param(2) = 0;
param(3) = 2.0;
mesh.SetCurveParameter(1, param);

// reading mesh
mesh.SetGeometryOrder(3);
mesh.Read("test.mesh");

// if you want to force a ruled surface for face 4 :
mesh.SetStraightFace(4);

Location :

GetNodalPointInsideTriangle

Syntax

R2 GetNodalPointInsideTriangle(int i)

This method returns the i-th intern nodal point of the unit triangle.

Example :

Mesh<Dimension3> mesh;

// reading mesh
mesh.SetGeometryOrder(3);
mesh.Read("test.mesh");

// if you want to retrieve the nodal point 2 of the unit triangle
R2 pt = mesh.GetNodalPointInsideTriangle(2);

Location :

ReadCurveType

Syntax

void ReadCurve(const IVect& ref, string keyword)

This method sets curve types of all the references in array ref. The curve type is provided through the string keyword. The method SetCurveType should be preferred.

Example :

Mesh<Dimension3> mesh;

// predefined curves
IVect ref(3);
ref(0) = 1; ref(1) = 4; ref(2) = 5;
mesh.ReadCurveType(ref, string("SPHERE")); // SPHERE, CYLINDER or CONE

// reading mesh
mesh.SetGeometryOrder(3);
mesh.Read("test.mesh");

Location :

ProjectToSphere

Syntax

void ProjectToSphere(R3& ptA, R3 center, Real_wp radius)

This method projects a point on a sphere.

Parameters

ptA: Point that will be projected
center: Center of the sphere
radius: radius of the sphere

Example :

R3 pt(0.4, 0.6, 0.9);

// you want to project pt on a sphere
R3 center(0, 0, 0); Real_wp radius = 1.0;
Mesh<Dimension3>::ProjectToSphere(pt, center, radius);

cout << "Projected point = " << pt << endl;

Location :

ProjectToConicCylinder

Syntax

void ProjectToConicCylinder(R3& ptA, R3 center, R3 axis, Real_wp teta)

This method projects a point on a conical cylinder.

Parameters

ptA: Point that will be projected
center: Center of the cone
axis: Axis of the cone
teta: Angle of the cone

Example :

R3 pt(0.4, 0.6, 0.9);

// you want to project pt on a conical cylinder
R3 center(0, 0, 0), axis(0, 0, 1); Real_wp teta = pi_wp/6;
Mesh<Dimension3>::ProjectToConicCylinder(pt, center, axis, teta);

cout << "Projected point = " << pt << endl;

Location :

ProjectToCylinder

Syntax

void ProjectToCylinder(R3& ptA, R3 center, R3 axis, Real_wp radius)

This method projects a point on a cylinder.

Parameters

ptA: Point that will be projected
center: Center of the cylinder
axis: Axis of the cylinder
radius: Radius of the cylinder

Example :

R3 pt(0.4, 0.6, 0.9);

// you want to project pt on a cylinder
R3 center(0, 0, 0), axis(0, 0, 1); Real_wp radius = 2.0;
Mesh<Dimension3>::ProjectToCylinder(pt, center, axis, radius);

cout << "Projected point = " << pt << endl;

Location :

ProjectToCurve

Syntax

void ProjectToCurve(R3& ptM, int ref)

This method projects the point ptM to the curved surface whose reference is ref. If this reference is not associated with a predefined curve, the point will not be modified.

Example :

Mesh<Dimension3> mesh;

// predefined curves
mesh.SetCurveType(2, mesh.CURVE_SPHERE);

// reading mesh
mesh.SetGeometryOrder(3);
mesh.Read("test.mesh");

// then you can project a point to the curve 2 (which is a sphere)
R3 pt(0.3, 0.5, 0.8);
mesh.ProjectToCurve(pt, 2);

Location :

GetAllPointsOnReference

Syntax

void GetAllPointsOnReference(int ref, VectR3& points, VectR3& normale)

void GetAllPointsOnReference(int ref_target, const IVect& ref_cond, VectR3& points, VectR3& normale)

This method retrieves all the points and normales for a curved surface whose reference is ref. In the second syntax, we consider all the references i such that ref_cond(i) is equal to ref_target.

Example :

Mesh<Dimension3> mesh;

// reading mesh
mesh.SetGeometryOrder(3);
mesh.Read("test.mesh");

// points and normale of reference 3
VectR3 points, normale;
mesh.GetAllPointsOnReference(3, points, normale);

Location :

GetDistantPointsOnReference

Syntax

void GetDistantPointsOnReference(int ref, VectR3& points, VectR3& normale, int nb_points)

void GetDistantPointsOnReference(int ref_target, const IVect& ref_cond, VectR3& points, VectR3& normale,
int nb_points)

This method retrieves some points and normales for a curved surface whose reference is ref. In the second syntax, we consider all the references i such that ref_cond(i) is equal to ref_target. It tries to find nb_points differents points which are distant enough (possibly non-collinear).

Example :

Mesh<Dimension3> mesh;

// reading mesh
mesh.SetGeometryOrder(4);
mesh.Read("test.mesh");

// 3 distants points and normale of reference 5
VectR3 points, normale;
mesh.GetDistantPointsOnReference(5, points, normale, 3);

Location :

FindParametersPlane

Syntax

void FindParametersPlane(int ref, VectReal_wp& param)

This method finds coefficients a, b, c, d (equation a x + b y + c z + d = 0) of a plane. We assume that faces with reference equal to ref are on this plane. The coefficients are placed on the output argument param

Example :

Mesh<Dimension3> mesh;

// reading mesh
mesh.SetGeometryOrder(4);
mesh.Read("test.mesh");

// coefficients a, b, c, d of a planar surface whose reference is 4 
VectReal_wp param(4);
mesh.FindParametersPlane(4, param);

Location :

FindParametersSphere

Syntax

void FindParametersSphere(int ref, R3& center, Real_wp& radius)

This method finds the center and radius of a sphere. We assume that faces with reference equal to ref are on this sphere.

Example :

Mesh<Dimension3> mesh;

// reading mesh
mesh.SetGeometryOrder(4);
mesh.Read("test.mesh");

// center and radius of a sphere (reference = 4) ?
R3 center; Real_wp radius;
mesh.FindParametersSphere(4, center, radius);

Location :

FindParametersConic

Syntax

void FindParametersConic(int ref, R3& center, R3& axis, Real_wp& teta)

This method finds the center, axis and angle of a cone. We assume that faces with reference equal to ref are on this cone.

Example :

Mesh<Dimension3> mesh;

// reading mesh
mesh.SetGeometryOrder(4);
mesh.Read("test.mesh");

// center, axis and angle of a cone (reference = 4) ?
R3 center, axis; Real_wp teta;
mesh.FindParametersConic(4, center, axis, teta);

Location :

FindParametersCylinder

Syntax

void FindParametersCylinder(int ref, R3& center, R3& axis, Real_wp& radius)

This method finds the center, axis and radius of a cylinder. We assume that faces with reference equal to ref are on this cylinder.

Example :

Mesh<Dimension3> mesh;

// reading mesh
mesh.SetGeometryOrder(4);
mesh.Read("test.mesh");

// center, axis and radius of a cylinder (reference = 4) ?
R3 center, axis; Real_wp radius;
mesh.FindParametersConic(4, center, axis, radius);

Location :

FindParametersCurve

Syntax

void FindParametersCurve()

This method finds parameters of all predefined curves of a mesh. It is automatically called when reading a mesh, so you don't need to call it in regular use.

Example :

Mesh<Dimension3> mesh;

// reading mesh
mesh.SetGeometryOrder(4);
mesh.Read("test.mesh");

// useless (already called in Read)
mesh.FindParametersCurve();

Location :

GetBoundaryMesh

Syntax

void GetBoundaryMesh(int ref_target, SurfacicMesh<Dimension3>& mesh, const IVect& ref_cond)

void GetBoundaryMesh(int ref_target, Mesh<Dimension3>& mesh, IVect& ListeFace, IVect& ListeVertex, IVect& NumElement, IVect& NumLocal, const IVect& ref_cond)

This method extracts all the referenced faces whose reference i satisfies ref_cond(i) = ref_target.

Example :

Mesh<Dimension3> mesh;

// reading the mesh
mesh.Read("exemple.mesh");

// extracting reference 2 and 3
IVect ref_cond(mesh.GetNbReferences()+1);
ref_cond.Fill(0);
ref_cond(2) = 1; ref_cond(3) = 1;
SurfacicMesh<Dimension3> surf_mesh;
mesh.GetBoundaryMesh(1, surf_mesh, ref_cond);

// you can also retrieve a simple 3-D mesh
Mesh<Dimension3> sub_mesh;
// and you get additional arrays giving vertex numbers, face numbers,
// and for each extracted face, the element and local position on the original mesh
IVect ListeFace, ListeVertex, NumElem, NumLocalBoundary;
mesh.GetBoundaryMesh(1, sub_mesh, ListeFace, ListeVertex, NumElem,
                     NumLocalBoundary, ref_cond);

Location :

print_level

This attribute stores the level of messages to be printed. You can set it to -1 for silent mode (nothing will be displayed), to 10 for a very verbose mode, 2 for an intermediate mode.

Example :

Mesh<Dimension3> mesh;
mesh.print_level = 3;

Location :

MeshBase.hxx

GlobElementNumber_Subdomain, GlobFaceNumber_Subdomain, GlobEdgeNumber_Subdomain, GlobVertexNumber_Subdomain

These attributes are used in Montjoie to store the global element number, face number, edge number and vertex number. They are relevant only for parallel computation where each processor stores his part of the mesh, you can access to global numbers with these arrays.

Example :

Mesh<Dimension3> mesh;

// global number of element 0 ?
int num_glob = mesh.GlobElementNumber_Subdomain(0);

Location :

MeshBase.hxx

Glob_invSqrtJacobian, Glob_invSqrtJacobianNeighbor, Glob_GradJacobian

These attributes are used in Montjoie to store the inverse of square root of J_i (determinant of DF_i). It is used for the Warburton's trick (useful for curved tetrahedra).

Location :

MeshBase.hxx

GetNbElt

Syntax

int GetNbElt() const

This method returns the number of elements in the mesh.

Example :

Mesh<Dimension3> mesh;
// we read the mesh
mesh.Read("test.mesh");
// we display the number of elements in the mesh
cout << "Number of elements " << mesh.GetNbElt();

Location :

GetNbVertices

Syntax

int GetNbVertices() const

This method returns the number of vertices in the mesh.

Example :

Mesh<Dimension3> mesh;
// we read the mesh
mesh.Read("test.mesh");
// we display the number of vertices in the mesh
cout << "Number of vertices " << mesh.GetNbVertices();

Location :

GetNbEdges

Syntax

int GetNbEdges() const

This method returns the number of edges in the mesh.

Example :

Mesh<Dimension3> mesh;
// we read the mesh
mesh.Read("test.mesh");
// we display the number of edges in the mesh
cout << "Number of edges " << mesh.GetNbEdges();

Location :

GetOriginalNeighborReference

Syntax

const IVect& GetOriginalNeighborReference() const

This method returns the list of original references of the mesh. This method is relevent only in parallel computation when the mesh is split. Because of this splitting, new references are created (for the interface between two processors) that can coincide with previous references. So you can know the original reference number for a given referenced edge.

Example :

Mesh<Dimension3> mesh;
// we read the mesh
mesh.Read("test.mesh");

// we assume the mesh is split

// then you can access the original references
const IVect& original_ref = mesh.GetOriginalNeighborReference();

// original reference of reference 8 :
int ref0 = original_ref(8);

Location :

SetOriginalNeighborReference

Syntax

void SetOriginalNeighborReference(const IVect& ref)

This method sets the list of original references of the mesh. This method is relevent only in parallel computation when the mesh is split. Because of this splitting, new references are created (for the interface between two processors) that can coincide with previous references. This method is called during the splitting process.

Location :

GetPathName

Syntax

string GetPathName() const

This method returns path of the directory where meshes are searched when ConstructMesh is called.

Example :

Mesh<Dimension3> mesh;
// path ?
cout << "Path where meshes are searched " << mesh.GetPathName() << endl;

Location :

SetPathName

Syntax

void SetPathName(const string& path)

This method sets the path of the directory where meshes are searched when ConstructMesh is called.

Example :

Mesh<Dimension3> mesh;
// path ?
mesh.SetPathName("MAILLAGES/");

Location :

IsElementAffine

Syntax

bool IsElementAffine(int i)

This method returns true if the element i is affine. An affine element is an element such that the transformation F_i (that transforms the reference element to an element of the mesh) is affine. For example, a parallelogram is affine whereas a trapezoid is not affine. Straight triangles and tetrahedra are affine.

Example :

Mesh<Dimension3> mesh;
// we read the mesh
mesh.Read("test.mesh");
// then you can see if an element is affine
for (int i = 0; i < mesh.GetNbElt(); i++)
  if (mesh.IsElementAffine(i))
    cout << "Element " << i << " affine ";

Location :

ReallocateElements

Syntax

void ReallocateElements(int n)

This method changes the number of elements present in the mesh. Previous elements stored will be lost, so you have to construct all the elements (with InitTriangular, InitQuadrangular for instance).

Example :

Mesh<Dimension3> mesh;
// we construct a mesh with two elements
mesh.ReallocateElements(2);
int ref = 1;
mesh.Element(0).InitTetrahedral(0, 1, 5, 4, ref);
mesh.Element(1).InitTetrahedral(1, 2, 5, 6, ref);

Location :

ResizeElements

Syntax

void ResizeElements(int n)

This method changes the number of elements present in the mesh. Previous elements stored will be conserved, so that you have to construct only the new elements (if there are more elements than before).

Example :

Mesh<Dimension3> mesh;
// we construct a mesh with two elements
mesh.ReallocateElements(2);
int ref = 1;
mesh.Element(0).InitTetrahedral(0, 1, 5, 4, ref);
mesh.Element(1).InitTetrahedral(1, 2, 5, 8, ref);
// then we add two new elements
mesh.ResizeElements(4);
IVect num(4); num(0) = 2; num(1) = 4; num(2) = 5; num(3) = 7;
mesh.Element(2).Init(num, ref);
num(0) = 2; num(1) = 4; num(2) = 3; num(3) = 6;
mesh.Element(3).Init(num, ref);

Location :

ClearElements

Syntax

void ClearElements()

This method removes all the elements present in the mesh

Example :

Mesh<Dimension3> mesh;
// we construct a mesh with two elements
mesh.ReallocateElements(2);
int ref = 1;
mesh.Element(0).InitTetrahedral(0, 1, 5, 4, ref);
mesh.Element(1).InitTetrahedral(1, 2, 5, 3, ref);
mesh.ResizeElements(4);
IVect num(4); num(0) = 2; num(1) = 4; num(2) = 5; num(3) = 8;
mesh.Element(2).Init(num, ref);
num(0) = 2; num(1) = 4; num(2) = 3; num(3) = 7;
mesh.Element(3).Init(num, ref);
// then you clear all those modifications
mesh.ClearElements();

Location :

Element

Syntax

Volume& Element(int i)

This method gives access to an element of the mesh.

Example :

Mesh<Dimension3> mesh;
// we construct a mesh with two elements
mesh.ReallocateElements(2);
int ref = 1;
mesh.Element(0).InitTetrahedral(0, 1, 5, 4, ref);
mesh.Element(1).InitHexahedral(1, 2, 5, 4, 6, 8, 10, 7, ref);
// you can also print an element
cout << "Second element : " << mesh.Element(1);

// retrieve the vertex numbers of an element :
int n0 = mesh.Element(1).numVertex(0);
int n1 = mesh.Element(1).numVertex(1);
// etc

Location :

GetTypeElement

Syntax

int GetTypeElement(int i) const

This method returns the type of the element, i.e. 0 if it is a tetrahedron, 1 for a pyramid, 2 for a triangular prism and 3 for an hexahedron.

Example :

Mesh<Dimension3> mesh;
// we construct a mesh with two elements
mesh.ReallocateElements(2);
int ref = 1;
mesh.Element(0).InitTetrahedral(0, 1, 5, 4, ref);
mesh.Element(1).InitHexahedral(1, 2, 5, 3, 4, 6, 9, 8, ref);
// you can also print the type of the element
cout << "Type of second element : " << mesh.GetTypeElement(1);

Location :

GetEdge

Syntax

Edge<Dimension3>& GetEdge(int i)

This method gives access to an edge of the mesh.

Example :

Mesh<Dimension3> mesh;
// we read the mesh
mesh.Read("test.mesh");
// we count edges on the boundary
int nb_edges_bound = 0;
for (int i = 0; i < mesh.GetNbEdges(); i++)
  if (mesh.GetEdge(i).GetNbElements() == 1)
    nb_edges_bound++;

Location :

ReallocateEdges

Syntax

void ReallocateEdges(int n)

This method changes the number of edges stored in the mesh. Previous edges will be removed. Usually, we don't enter directly edge connectivity, but we call FindConnectivity.

Example :

Mesh<Dimension3> mesh;
// you specify the number of edges
mesh.ReallocateEdges(5);
// then you can set edges
mesh.GetEdge(0).Init(0, 2, 1);
mesh.GetEdge(1).Init(1, 12, 1);
// ...

Location :

ResizeEdges

Syntax

void ResizeEdges(int n)

This method changes the number of edges stored in the mesh. Previous edges will be kept. Usually, we don't enter directly edge connectivity, but we call FindConnectivity.

Example :

Mesh<Dimension3> mesh;
// you specify the number of edges
mesh.ResizeEdges(5);
// then you can set edges
mesh.GetEdge(0).Init(0, 2, 1);
mesh.GetEdge(1).Init(1, 12, 1);
// ...

Location :

ReallocateVertices

Syntax

void ReallocateVertices(int n)

This low-level method changes the number of vertices stored in the mesh. Previous vertices will be removed and replaced by 0. After, you can modify each vertex with the method Vertex.

Example :

Mesh<Dimension3> mesh;
// you specify the number of vertices
mesh.ReallocateVertices(5);
// then you fill each point
mesh.Vertex(0).Init(-1.5, -1.5, 1.4); mesh.Vertex(1) = R3(0, -1.5, 1.6);
mesh.Vertex(2).Init(1.5, 0, 0.7); mesh.Vertex(3) = R3(1.5, 1.5, -0.9);
mesh.Vertex(4) = R3(0, 1.5, -0.3);

Location :

ResizeVertices

Syntax

void ResizeVertices(int n)

This low-level method changes the number of vertices stored in the mesh. Previous vertices will be conserved. After, you have to specify each new vertex with the method Vertex.

Example :

Mesh<Dimension3> mesh;
// you specify the number of vertices
mesh.ReallocateVertices(5);
// then you fill each point
mesh.Vertex(0).Init(-1.5, -1.5, 0.9); mesh.Vertex(1) = R3(0, -1.5, 0.7);
mesh.Vertex(2).Init(1.5, 0); mesh.Vertex(3) = R3(1.5, 1.5, -0.4);
mesh.Vertex(4) = R3(0, 1.5, 1.2);
// we add a new point
mesh.ResizeVertices(6);
mesh.Vertex(5).Init(0.2, 0.2, 0.8);

Location :

ClearVertices

Syntax

void ClearVertices(int n)

This method removes all the vertices of the mesh.

Example :

Mesh<Dimension3> mesh;
// you specify the number of vertices
mesh.ReallocateVertices(5);
// then you fill each point
mesh.Vertex(0).Init(-1.5, -1.5, 0.9); mesh.Vertex(1) = R3(0, -1.5, 1.2);
mesh.Vertex(2).Init(1.5, 0, -0.7); mesh.Vertex(3) = R3(1.5, 1.5, -0.4);
mesh.Vertex(4) = R3(0, 1.5, -2.0);
// you can clear all the vertices
mesh.ClearVertices();

Location :

Vertex

Syntax

R3& Vertex(int i)

This method gives access to a vertex of the mesh.

Example :

Mesh<Dimension3> mesh;
// you specify the number of vertices
mesh.ReallocateVertices(5);
// then you fill each point
mesh.Vertex(0).Init(-1.5, -1.5, 4.1); mesh.Vertex(1) = R3(0, -1.5, -0.6);
mesh.Vertex(2).Init(1.5, 0, 1.9); mesh.Vertex(3) = R3(1.5, 1.5, 2.1);
mesh.Vertex(4) = R3(0, 1.5, -0.7);

Location :

GetXmin, GetXmax, GetYmin, GetYmax, GetZmin, GetZmax

Syntax

Real_wp GetXmin()

Real_wp GetYmin()

Real_wp GetZmin()

Real_wp GetXmax()

Real_wp GetYmax()

Real_wp GetZmax()

These methods return the minimum/maximum of x, y or z-coordinate of vertices in the mesh. These values are computed when you read or construct the mesh.

Example :

Mesh<Dimension3> mesh;
mesh.Read("test.mesh");
cout << "Mesh is contained in box [" << mesh.GeXmin() << ", " << mesh.GetXmax() << "] x [ "
<< mesh.GetYmin() << ", " << mesh.GetYmax() << "] x [" << mesh.GetZmin() << ", " << mesh.GetZmax() << "] ";

// if you construct the mesh manually
mesh.Clear();
// you specify the number of vertices
mesh.ReallocateVertices(5);
// then you fill each point
mesh.Vertex(0).Init(-1.5, -1.5, 0.9); mesh.Vertex(1) = R3(0, -1.5, 1.3);
mesh.Vertex(2).Init(1.5, 0, 0.8); mesh.Vertex(3) = R3(1.5, 1.5, -0.2);
mesh.Vertex(4) = R3(0, 1.5, -2.0);
// the bounding box is updated when you call ReorientElements
mesh.ReorientElements();
cout << "Mesh is contained in box [" << mesh.GeXmin() << ", " << mesh.GetXmax() << "] x [ "
<< mesh.GetYmin() << ", " << mesh.GetYmax() << "] x [" << mesh.GetZmin() << ", " << mesh.GetZmax() << "] ";

Location :

FindVertexNumber

Syntax

int FindVertexNumber(const R3& pt)

This method returns the vertex number by knowing only its coordinates. The cost of this method is in linear time, since we are browsing all the vertices of the mesh.

Example :

Mesh<Dimension3> mesh;

mesh.SetGeometryOrder(3);
mesh.Read("test.mesh");

// vertex number of point -1, 0, 2 ?
R3 point(-1, 0, 2);
int nv = mesh.FindVertexNumber(point);

Location :

GetReferenceElement

Syntax

ElementGeomReference<Dimension3> GetReferenceElement(int i) const

Vector<ElementGeomReference<Dimension3>* > GetReferenceElement() const

This method returns the finite element used for the i-th element. In the second syntax, you can also retrieve the finite elements for all the elements.

Example :

Mesh<Dimension3> mesh;

mesh.SetGeometryOrder(3);
mesh.Read("test.mesh");

// finite element for element 4
ElementGeomReference<Dimension3> Fb = mesh.GetReferenceElement(4);

Location :

GetVerticesElement

Syntax

void GetVerticesElement(int i, VectR3& vertices)

This method retrieves the vertices of an element.

Example :

Mesh<Dimension3> mesh;
// mesh is read on a file
mesh.Read("test.mesh");
VectR3 s;
// loop over elements
for (int i = 0; i < mesh.GetNbElt(); i++)
  {
    mesh.GetVerticesElement(i, s);
    // then you can perform operations over vertices s
    cout << "Second vertex " << s(1) << endl;
  }

Location :

GetDofsElement

Syntax

void GetDofsElement(int i, VectR3& points, const ElementGeomReference<Dimension3>& fem)

This method retrieves the locations of degrees of freedom on an element. It does not need a numbering of the mesh, but a finite element object fem where points on degrees of freedom are defined. The finite element must be of the same type as the element (e.g. triangular if the element is a triangle).

Example :

Mesh<Dimension3> mesh;

// mesh is read on a file
mesh.Read("test.mesh");

// finite element with dofs
HexahedronLobatto hex;
hex.ConstructFiniteElement(5);

// Gauss-Lobatto points after transformation Fi for a given element i
VectR3 points; int i = 10;
mesh.GetDofsElement(i, points, hex);
DISP(points);

Location :

SetInputData

Syntax

void SetInputData(const string& keyword, VectString& param)

This method is used during the reading of the data file. You can look at the section devoted to the data file and see the fields related to the mesh.

Example :

Mesh<Dimension3> mesh;
// some parameters are read on a data file
ReadInputFile("test.ini", &mesh);

Location :

PointsOnSameEdge

Syntax

bool PointsOnSameEdge(int n1, int n2, int& num_edge)

This method returns true if vertices n1 and n2 are the extremities of the same edge. On exit, num_edge contains the edge number.

Example :

Mesh<Dimension3> mesh;
// we read mesh
mesh.Read("test.mesh");
// we test if two points share the same edge
int n1 = 2, n2 = 5, ne = -1;
if (PointsOnSameEdge(n1, n2, ne))
  cout << "Points are on the edge " << ne << endl;

Location :

GetNeighboringElementsAroundVertex

Syntax

void GetNeighboringElementsAroundVertex(int i, IVect& num)

This method fills the array num with the numbers of the elements sharing the point i.

Example :

Mesh<Dimension3> mesh;
// we read mesh
mesh.Read("test.mesh");
// we find all the elements around vertex 3
IVect num;
mesh.GetNeighboringElementsAroundVertex(3, num);
cout << "Elements around vertex 3 : " << num;

Location :

GetNeighboringEdgesAroundVertex

Syntax

void GetNeighboringEdgesAroundVertex(int i, IVect& num)

This method fills the array num with the numbers of the edges sharing the point i.

Example :

Mesh<Dimension3> mesh;
// we read mesh
mesh.Read("test.mesh");
// we find all the edges around vertex 3
IVect num;
mesh.GetNeighboringEdgesAroundVertex(3, num);
cout << "Edges around vertex 3 : " << num;

Location :

SetVerticesToBeAdded

Syntax

void SetVerticesToBeAdded(const VectR3& pts)

This method sets the points that will be added when ConstructMesh will be called.

Example :

Mesh<Dimension3> mesh;

// you set the vertices to add to the final mesh
VectR3  s(2);
s(0).Init(-2.0, -0.8, -2.4); s(1).Init(-1.0, -0.5, 2.2);
mesh.SetVerticesToBeAdded(s);

// then ConstructMesh will add these vertices
VectString param(1);
param(0) = string("cube.mesh");
mesh.ConstructMesh(mesh.HYBRID_MESH, param);

Location :

SetVerticesToBeRefined

Syntax

void SetVerticesToBeRefined(const VectR3& pts, int lvl, Real_wp ratio)

This method sets the points that will be refined when ConstructMesh will be called.

Example :

Mesh<Dimension3> mesh;

// you set the vertices around which the final mesh will be refined
// level : refinement level, ratio : refinement ratio
int level = 2; Real_wp ratio = 3.0;
VectR3  s(2);
s(0).Init(-2.0, -0.8, 1.5); s(1).Init(-1.0, -0.5, 0.6);
mesh.SetVerticesToBeRefined(s, level, ratio);

// then ConstructMesh will refine locally the mesh around these vertices
VectString param(1);
param(0) = string("cube.mesh");
mesh.ConstructMesh(mesh.HYBRID_MESH, param);

Location :

CreateReferenceVertices

Syntax

void CreateReferenceVertices(IVect& ref_vertex) const

This method attributes a reference for each vertex. The reference is 0 if the vertex does not belong to a referenced face, otherwise the reference is equal to the reference of the face.

Example :

Mesh<Dimension3> mesh;
// we read mesh
mesh.Read("test.mesh");
IVect ref_vertex;
mesh.CreateReferenceVertices(ref_vertex);

Location :

GetMeshSize

Syntax

Real_wp GetMeshSize() const

This method returns the mesh size, which is evaluated as the average value of edge length.

Example :

Mesh<Dimension3> mesh;
// we read mesh
mesh.Read("test.mesh");
// we return the mesh size
cout << "h = " << mesh.GetMeshSize();

Location :

ClearConnectivity

Syntax

void ClearConnectivity()

This method clears edge and face numbers for each element, and all the edges and faces. Therefore, the mesh is stored as if you didn't call the method FindConnectivity (which is called when reading a mesh, and lots of other methods). So, it can reduce the storage required by the mesh. Some methods may disfunction when clearing connectivity.

Example :

Mesh<Dimension3> mesh;
// we read mesh
mesh.Read("test.mesh");
// then you clear arrays containing edges
mesh.ClearConnectivity();

Location :

Clear

Syntax

void Clear()

This method clears the mesh.

Example :

Mesh<Dimension3> mesh;
// we read mesh
mesh.Read("test.mesh");
// then you can clear all the mesh
mesh.Clear();

Location :

ClearInput

Syntax

void ClearInput()

This method clears the input parameters of the mesh. These parameters can have been set by calling SetInputData for example.

Example :

Mesh<Dimension3> mesh;
// if you called SetInputData

// you can clear input data
mesh.ClearInput();

Location :

AddOverlapRegion

Syntax

void AddOverlapRegion(int n, int& nb_vert, int& nb_elt, Vector<bool>& VertexOnSubdomain, Vector<bool>& ElementOnSubdomain) const

This method adds n layers around a subdomain of the mesh. It is used by the method SplitIntoBoxes, SplitMetis and equivalents if overlapping subdomains are required by the user.

Parameters

n (in): number of layers to add
nb_vert (in/out): number of vertices in the subdomain (this number is updated)
nb_elt(in/out): number of elements in the subdomain (this number if updated)
VertexOnSubdomain(in/out): if VertexOnSubdomain(i) is true the vertex i lies in the subdomain
ElementOnSubdomain(in/out): if ElementOnSubdomain(i) is true the element i lies in the subdomain

Example :

Mesh<Dimension3> mesh;

// we read mesh
mesh.Read("test.mesh");

// for example you consider a single element
int nb_elt = 1; int num_elem = 23;
Vector<bool> ElementOnSubdomain(mesh.GetNbElt()); ElementOnSubdomain.Fill(false);
ElementOnSubdomain(num_elem) = true;
// and vertices of this element
int nb_vert = mesh.Element(num_elem).GetNbVertices();
Vector<bool> VertexOnSubdomain(mesh.GetNbVertices()); VertexOnSubdomain.Fill(false);
for (int i = 0; i < nb_vert; i++)
  VertexOnSubdomain(mesh.Element(num_elem).numVertex(i)) = true;

// then you add 3 layers of elements around this initial element
mesh.AddOverlapRegion(3, nb_vert, nb_elt, VertexOnSubdomain, ElementOnSubdomain);

// you can create a mesh with the updated informations
mesh.CreateSubMesh(sub_mesh, nb_vert, nb_elt, VertexOnSubdomain, ElementOnSubdomain);
sub_mesh.Write("subdomain.mesh");

Location :

SplitIntoBoxes

Syntax

void SplitIntoBoxes(int nx, int ny, int nz, int& nb_parts, Vector<IVect>& num_elem, Vector<Mesh<Dimension3> >& sub_mesh, int noverlap) const

This method splits the current mesh within a cartesian grid, with nx cells along x, ny cells along y, and nz cells for z-direction. The number of subdomains is returned in variable nb_parts, and can be different from nx*ny*nz, if there are holes for example. You can define an overlapping level by increasing noverlap, if equal to 0, there will be no overlapping. On exit, num_elem contains the element numbers for each subdomain.

Parameters

nx(in): number of subdivisions along x
ny(in): number of subdivisions along y
nz(in): number of subdivisions along z
nb_parts(in/out): number of subdomains
num_elem(out): Element numbers for all subdomains
sub_mesh(out): Meshes of the subdomains
noverlap(in): overlapping level

Example :

Mesh<Dimension3> mesh;

// we read mesh
mesh.Read("test.mesh");

// we split mesh into 2x2x2 grid without overlap
int nb_parts = 0;
Vector<IVect> num_elt;
Vector<Mesh<Dimension3> > sub_mesh;
mesh.SplitIntoBoxes(2, 2, 2, nb_parts, sub_mesh, 0);

// then you can write the small meshes
for (int i = 0; i < nb_parts; i++)
  sub_mesh(i).Write(string("subdomain")+to_str(i)+".mesh");

Location :

SplitMetis

Syntax

void SplitMetis(int nb_parts, IVect& weight_elt, Vector<IVect>& num_elem, Vector<Mesh<Dimension3> >& sub_mesh, int noverlap) const

This method splits the current mesh into nb_parts balanced parts by using Metis routines. weight_elt denotes the weight attributed to each element. You can define an overlapping level by increasing noverlap, if equal to 0, there will be no overlapping. On exit, num_elem contains the element numbers for each subdomain.

Parameters

nb_parts(in): number of subdomains
weight_elt(in): weight for each element
num_elem(out): Element numbers for all subdomains
sub_mesh(out): Meshes of the subdomains
noverlap(in): overlapping level

Example :

Mesh<Dimension3> mesh;
// we read mesh
mesh.Read("test.mesh");

// we split mesh into 7 parts with weight equal to 1
IVect weight_elt(mesh.GetNbElt()); weight_elt.Fill(1);
Vector<IVect> num_elt;
Vector<Mesh<Dimension3> > sub_mesh;
mesh.SplitMetis(7, weight_elt, num_elt, sub_mesh, 0);

// then you can write the small meshes
for (int i = 0; i < nb_parts; i++)
  sub_mesh(i).Write(string("subdomain")+to_str(i)+".mesh");

Location :

SplitScotch

Syntax

void SplitScotch(int nb_parts, IVect& weight_elt, Vector<IVect>& num_elem, Vector<Mesh<Dimension3> >& sub_mesh, int noverlap) const

This method splits the current mesh into nb_parts balanced parts by using Scotch routines. weight_elt denotes the weight attributed to each element. You can define an overlapping level by increasing noverlap, if equal to 0, there will be no overlapping. On exit, num_elem contains the element numbers for each subdomain.

Parameters

nb_parts(in): number of subdomains
weight_elt(in): weight for each element
num_elem(out): Element numbers for all subdomains
sub_mesh(out): Meshes of the subdomains
noverlap(in): overlapping level

Example :

Mesh<Dimension3> mesh;

// we read mesh
mesh.Read("test.mesh");

// we split mesh into 7 parts with weight equal to 1
IVect weight_elt(mesh.GetNbElt()); weight_elt.Fill(1);
Vector<IVect> num_elt;
Vector<Mesh<Dimension3> > sub_mesh;
mesh.SplitScotch(7, weight_elt, num_elt, sub_mesh, 0);

// then you can write the small meshes
for (int i = 0; i < nb_parts; i++)
  sub_mesh(i).Write(string("subdomain")+to_str(i)+".mesh");

Location :

SplitConcentric

Syntax

void SplitConcentric(int nb_parts, VectReal_wp& radius, Vector<IVect>& num_elem, Vector<Mesh<Dimension3> >& sub_mesh, int noverlap) const

This method splits the current mesh by using the radii provided by the user. The subdomain 0 will comprise elements such that r ≤ r₀ (here r stands for the radius of spherical coordinates), the subdomain 1 will comprise elements such that r₀ < r ≤ r₁, etc. The last subdomain comprises elements such taht r ≥ r_N.

Parameters

nb_parts(in): number of subdomains
radius(in): list of radii used to distinguish subdomains
num_elem(out): Element numbers for all subdomains
sub_mesh(out): Meshes of the subdomains
noverlap(in): overlapping level

Example :

Mesh<Dimension3> mesh;
// we read mesh
mesh.Read("test.mesh");

// we split mesh into 3 concentric parts
int nb_parts = 3;
VectReal_wp radius(2); radius(0) = 0.5; radius(1) = 2.0;

Vector<IVect> num_elt;
Vector<Mesh<Dimension3> > sub_mesh;
mesh.SplitConcentric(nb_parts, radius, num_elt, sub_mesh, 0);

// then you can write the small meshes
for (int i = 0; i < nb_parts; i++)
  sub_mesh(i).Write(string("subdomain")+to_str(i)+".mesh");

Location :

SplitLayered

Syntax

void SplitLayered(int nb_parts, const Vector<IVect>& ref_layer, Vector<IVect>& num_elem, Vector<Mesh<Dimension3> >& sub_mesh, int noverlap) const

This method splits the current mesh by using the references provided by the user. The subdomain i will comprise elements whose reference is contained in the array ref_layer(i).

Parameters

nb_parts(in): number of subdomains
ref_layer(in): list of references for each subdomain
num_elem(out): Element numbers for all subdomains
sub_mesh(out): Meshes of the subdomains
noverlap(in): overlapping level

Example :

Mesh<Dimension3> mesh;
// we read mesh
mesh.Read("test.mesh");

// we split mesh into 3 parts
// first part will comprise elements of reference 1,
// second part elements of reference 2 and 3
// last part will contain elements of reference 2
int nb_parts = 3;
Vector<IVect> ref_layer(3);
ref_layer(0).PushBack(1);
ref_layer(1).PushBack(3); ref_layer(1).PushBack(4);
ref_layer(2).PushBack(2);

Vector<IVect> num_elt;
Vector<Mesh<Dimension3> > sub_mesh;
mesh.SplitLayered(nb_parts, ref_layer, num_elt, sub_mesh, 0);

// then you can write the small meshes
for (int i = 0; i < nb_parts; i++)
  sub_mesh(i).Write(string("subdomain")+to_str(i)+".mesh");

Location :

PartMesh

Syntax

void PartMesh(int nb_parts, const IVect& epart, Vector<IVect>& num_elem, Vector<Mesh<Dimension3> >& sub_mesh, int noverlap) const

This method splits the current mesh by using the array epart provided by the user. The subdomain i will comprise elements j such that epart(j) is equal to i.

Parameters

nb_parts(in): number of subdomains
epart(in): subdomain number for each element of the mesh
num_elem(out): Element numbers for all subdomains
sub_mesh(out): Meshes of the subdomains
noverlap(in): overlapping level

Example :

Mesh<Dimension3> mesh;
// we read mesh
mesh.Read("test.mesh");

// the user gives the subdomain number in epart
IVect epart; int nb_parts = 4;
epart.Read("epart.dat");

Vector<IVect> num_elt;
Vector<Mesh<Dimension3> > sub_mesh;
PartMesh(nb_parts, epart, num_elt, sub_mesh, 0);

// then you can write the small meshes
for (int i = 0; i < nb_parts; i++)
  sub_mesh(i).Write(string("subdomain")+to_str(i)+".mesh");

Location :

UpdatePeriodicReferenceSplit

Syntax

void UpdatePeriodicReferenceSplit(const IVect& epart, const IVect& NumLoc, Vector<Mesh<Dimension3> >& sub_mesh)

This methods updates references if periodic conditions have been set on the mesh. If the splitting of the mesh has been constructed such that periodic boundaries are separated (one element on a processor, and the opposite element on another processor), a new reference is created for this boundary.

Parameters

epart(in): subdomain number for each element of the mesh
NumLoc(in): local number of element i in its subdomain
sub_mesh(in/out): Meshes of the subdomains

Example :

Mesh<Dimension3> mesh;
// we read mesh
mesh.Read("test.mesh");

// the user gives the subdomain number in epart
IVect epart; int nb_parts = 4;
epart.Read("epart.dat");

Vector<IVect> num_elt;
Vector<Mesh<Dimension3> > sub_mesh;
PartMesh(nb_parts, epart, num_elt, sub_mesh, 0);

// numloc(i) is the local element number in the corresponding subdomain
IVect numloc(mesh.GetNbElt());
IVect num(nb_parts); num.Zero();
for (int i = 0; i < mesh.GetNbElt(); i++)
  numloc(i) = num(epart(i))++;

// updating periodic references
UpdatePeriodicReferenceSplit(epart, numloc, sub_mesh);

Location :

WriteOrder

Syntax

void WriteOrder(const string& file_name, const MeshNumbering<Dimension3>& mesh_num)

This method writes a mesh in a file, on which references attributed to elements are equal to the order (given by mesh_num). The mesh is not modified when calling this method.

Example :

Mesh<Dimension3> mesh;

// we read mesh
mesh.Read("test.mesh");

// we compute a numbering
MeshNumbering<Dimension3> mesh_num(mesh);
mesh_num.ComputeVariableOrder(true);
mesh_num.NumberMesh();

// then you can see the result
mesh.WriteOrder("order.mesh", mesh_num);

Location :

FjElemNodal

Syntax

void FjElemNodal(const VectR3& s, SetPoints<Dimension3>& Pts, const Mesh<Dimension3>& mesh, int n) const

This method computes nodal points of an element.

Parameters

s (in): vertices of the element
Pts (out): computed nodal points
mesh (in): current mesh
n (in): element number

Example :

Mesh<Dimension3> mesh, mesh2;
mesh.Read("toto.mesh");

// nodal points of element 18
int n = 18;
VectR3 s;
mesh.GetVerticesElement(n, s);
SetPoints<Dimension3> Pts;
mesh.FjElemNodal(s, Pts, mesh, n);

for (int j = 0; j < Pts.GetNbPointsNodal(); j++)
  cout << "Nodal point " << j << " : " << Pts.GetPointNodal(j) << endl;

Location :

DFjElemNodal

Syntax

void DFjElemNodal(const VectR3& s, const SetPoints<Dimension3>& Pts, SetMatrices<Dimension3>& Mat, const Mesh<Dimension3>& mesh, int n) const

This method computes jacobian matrices on nodal points of an element.

Parameters

s (in): vertices of the element
Pts (in): nodal points
Mat (out): computed jacobian matrices
mesh (in): current mesh
n (in): element number

Example :

Mesh<Dimension3> mesh, mesh2;
mesh.Read("toto.mesh");

// nodal points of element 18
int n = 18;
VectR3 s;
mesh.GetVerticesElement(n, s);
SetPoints<Dimension3> Pts;
mesh.FjElemNodal(s, Pts, mesh, n);

// then jacobian matrices on these nodal points
SetMatrices<Dimension3> Pts;
mesh.DFjElemNodal(s, Pts, Mat, mesh, n);

Location :

Fj

Syntax

void Fj(const VectR3& s, const SetPoints<Dimension3>& Pts, const R3& pt_loc, R3& pt_glob, const Mesh<Dimension3>& mesh, int n) const

This method computes the image by transformation Fi of a local point placed on the reference element.

Parameters

s (in): vertices of the element
Pts (in): nodal points
pt_loc (in): local coordinates of point
pt_glob (out): global coordinates of point
mesh (in): current mesh
n (in): element number

Example :

Mesh<Dimension3> mesh, mesh2;
mesh.Read("toto.mesh");

// nodal points of element 18
int n = 18;
VectR3 s;
mesh.GetVerticesElement(n, s);
SetPoints<Dimension3> Pts;
mesh.FjElemNodal(s, Pts, mesh, n);

// then computation of pt_glob = Fi(pt_loc)
R3 pt_loc(0.3, 0.2, 0.4);
R3 pt_glob;
mesh.Fj(s, Pts, pt_loc, pt_glob, mesh, n);

Location :

DFj

Syntax

void DFj(const VectR3& s, const SetPoints<Dimension3>& Pts, const R3& pt_loc, Matrix3_3& dfj, const Mesh<Dimension3>& mesh, int n) const

This method computes jacobian matrix DFi on a point of the reference element.

Parameters

s (in): vertices of the element
Pts (in): nodal points
pt_loc (in): local coordinates of point
dfj (out): jacobian matrix
mesh (in): current mesh
n (in): element number

Example :

Mesh<Dimension3> mesh, mesh2;
mesh.Read("toto.mesh");

// nodal points of element 18
int n = 18;
VectR3 s;
mesh.GetVerticesElement(n, s);
SetPoints<Dimension3> Pts;
mesh.FjElemNodal(s, Pts, mesh, n);

// then computation of dfj = DFi(pt_loc)
R3 pt_loc(0.3, 0.4, 0.2);
Matrix3_3 dfj;
mesh.DFj(s, Pts, pt_loc, dfj, mesh, n);

Location :

GetNbPointsNodalElt

Syntax

int GetNbPointsNodalElt(int i)

This method returns the number of nodal points associated with the element i.

Example :

Mesh<Dimension3> mesh, mesh2;
mesh.Read("toto.mesh");

// number of nodal points of element 18 ?
int nb_pts = mesh.GetNbPointsNodalElt(18);

Location :

GetNbPointsNodalBoundary

Syntax

int GetNbPointsNodalBoundary(int num_elem, int num_loc)

This method returns the number of nodal points associated with an edge.

Example :

Mesh<Dimension3> mesh, mesh2;
mesh.Read("toto.mesh");

// number of nodal points of an edge
int nb_pts = mesh.GetNbPointsNodalBoundary(18, 0);

Location :

GetNodalNumber

Syntax

int GetNodalNumber(int num_elem, int num_loc, int k)

This method returns the number of the k-th nodal point of the edge num_loc of element num_elem.

Example :

Mesh<Dimension3> mesh, mesh2;
mesh.Read("toto.mesh");

// number of a nodal point ?
int num_elem = 18, num_loc = 1, k = 2;
int num_node = mesh.GetNodalNumber(num_elem, num_loc, k);

Location :

GetNormale

Syntax

void GetNormale(const Matrix3_3& dfjm1, R3& normale, Real_wp& dsj, int num_elem, int num_loc)

This method computes the normale and surface element ds_i from the inverse of jacobian matrix.

Parameters

dfjm1 (in): inverse of jacobian matrix
normale (out): outgoing normale to the selected edge
dsj (out): surface element ds_i (used for integration)
num_elem (in): element number
num_loc (in): local edge number (in the element)

Example :

Mesh<Dimension3> mesh, mesh2;
mesh.Read("toto.mesh");

// nodal points of element 18
int n = 18;
VectR3 s;
mesh.GetVerticesElement(n, s);
SetPoints<Dimension2> Pts;
mesh.FjElemNodal(s, Pts, mesh, n);

// then computation of dfj = DFi(pt_loc)
R3 pt_loc(1.0, 0.4, 0.3);
Matrix3_3 dfjm1;
mesh.DFj(s, Pts, pt_loc, dfjm1, mesh, n);
GetInverse(dfjm1); // we store dfi^-1

// normale and ds
R3 normale; Real_wp ds;
int num_loc = 1; // local number of edge
mesh.GetNormale(dfjm1, normale, ds, n, num_loc);

Location :

GetDistanceToBoundary

Syntax

Real_wp GetDistanceToBoundary(const R3& pt_loc, int n)

This method returns the distance between a point and the boundary on the reference element. If the distance is negative, it means that the point is outside the reference element.

Example :

Mesh<Dimension3> mesh, mesh2;
mesh.Read("toto.mesh");

R3 pt_loc(0.1, 0.3, 0.25); int n = 10;
Real_wp dist = mesh.GetDistanceToBoundary(pt_loc, n);

Location :

ProjectPointOnBoundary

Syntax

void ProjectPointOnBoundary(R3& pt_loc, int n)

This method projects a point on the boundary of reference element.

Example :

Mesh<Dimension3> mesh, mesh2;
mesh.Read("toto.mesh");

R3 pt_loc(0.01, 1.0, 0.0);

// if the point is slightly outside the reference element, you may want to project it on the boundary
mesh.ProjectPointOnBoundary(pt_loc, n);

Location :

GetBoundingBox

Syntax

void GetBoundingBox(const VectR3& s, Real_wp coef, VectR3& box, TinyVector<R3, 2>& enveloppe) const

void GetBoundingBox(int i, const VectR3& s, const SetPoints<Dimension3>& pts, TinyVector<R3, 2>& enveloppe) const

This method computes the bounding box containing the element defined by its vertices s. box is a bounding polygon, enveloppe the bounding box, and coef is a safety coefficient (which can be used for curved elements for example). In the second syntax, the user provides the nodal points of the element, such that the computed bounding box is much more accurate.

Parameters

i (in): element number
s (in): vertices of the element
Pts (in): nodal points
coef (in): safety coefficient (for curved elements)
box (out): polyhedral enveloppe
enveloppe (out): rectangular bounding box

Example :

Mesh<Dimension2> mesh, mesh2;
mesh.Read("toto.mesh");

// bounding box of element 18 ?
VectR3 s;
int n = 18;
mesh.GetVerticesElement(n, s);

// estimating the bounding box with a safety coefficient of 10%
// put 0 if the element is straight
VectR3 box(s.GetM());
TinyVector<R3, 2> enveloppe;
mesh.GetBoundingBox(s, 0.1, box, enveloppe);
cout << "the element is included in box " << "[" << enveloppe(0)(0) << "," << enveloppe(1)(0) << "] x ["
     << enveloppe(0)(1) << "," << enveloppe(1)(1) << "] x ["
     << enveloppe(0)(2) << "," << enveloppe(1)(2) << " ]" << endl;

// other approach : compute nodal points
SetPoints<Dimension3> Pts;
mesh.FjElemNodal(s, Pts, mesh, n);

// in that case the bounding box is more accurate
mesh.GetBoundingBox(n, s, Pts, enveloppe);

Location :

ComputeValuesPhiNodalRef

Syntax

void ComputeValuesPhiNodalRef(int i, const R3& pt_loc, VectReal_wp& phi) const

This method computes the nodal shape functions on the local point pt_loc.

Parameters

i (in): element number
pt_loc (in): local coordinates of point
phi (out): values of shape functions on the given point

Example :

Mesh<Dimension3> mesh, mesh2;
mesh.Read("toto.mesh");

// you can compute the values of shape functions of element 18 on a local point
R3 pt_loc(0.6, 0.4, 0.1); // local coordinates on the reference element
mesh.ComputeValuesPhiNodalRef(18, pt_loc, phi);

Location :

ComputeNodalGradient

Syntax

void ComputeNodalGradient(const SetMatrices<Dimension3>& mat, const Vector& Uloc, Vector& gradU, int i) const

This method computes the gradient of Uloc on nodal points of the element i.

Parameters

mat (in): jacobian matrices on nodal points
Uloc (in): values of u on nodal points
gradU (out): gradient of u on nodal points
i (in): element number

Example :

Mesh<Dimension3> mesh, mesh2;
mesh.Read("toto.mesh");

// nodal points of element 18
int n = 18;
VectR3 s;
mesh.GetVerticesElement(n, s);
SetPoints<Dimension3> Pts;
mesh.FjElemNodal(s, Pts, mesh, n);

SetMatrices<Dimension3> Mat;
mesh.DFjElemNodal(s, Pts, Mat, mesh, n);

// then if you define Uloc on the element
int nb_nodes = Pts.GetNbPointsNodal();
Vector<double> Uloc(nb_nodes);
double x, y;
for (int i = 0; i < nb_nodes; i++)
  {
    x = Pts.GetPointNodal(i)(0);
    y = Pts.GetPointNodal(i)(1);
    w = Pts.GetPointNodal(i)(2);
    Uloc(i) = sin(pi_wp*x)*sin(pi_wp*y)*(x+y) + z;
  }

// you can compute the gradient on nodal points of the element
VectR3 gradU(nb_nodes);
mesh.ComputeNodalGradient(Mat, Uloc, gradU, n);

Location :

number_map

This attribute stores the numbering scheme to use, i.e. number of dofs per vertex, edge, triangle, tetrahedron, how the numbers are transformed after rotation of a face. If you want more details, you can look at the methods of class NumberMap.

Example :

Mesh<Dimension3> mesh;
mesh.Read("test.mesh");

MeshNumbering<Dimension3> mesh_num(mesh);
int order = 3;
// constant order on all the mesh
mesh_num.SetOrder(order);

// number of dofs per vertex, edge, etc
mesh_num.number_map.SetNbDofVertex(order, 1);
mesh_num.number_map.SetNbDofEdge(order, order-1);
mesh_num.number_map.SetNbDofQuadrangle(order, (order-1)*(order-1));
mesh_num.number_map.SetNbDofTriangle(order, (order-1)*(order-2)/2);
mesh_num.number_map.SetNbDofTetrahedron(order, (order-1)*(order-2)*(order-3)/6);

// then you can number the mesh
mesh_num.NumberMesh();

// and display global numbers
for (int i = 0; i < mesh.GetNbElt(); i++)
  for (int j = 0; j < mesh_num.Element(i).GetNbDof(); j++)
    cout << "Global dof number of local dof " << j
         << " and element  " << i << " : " << mesh_num.Element(i).GetNumberDof(j) << endl;

Location :

OffsetDofVertexNumber, OffsetDofEdgeNumber, OffsetDofFaceNumber, OffsetDofElementNumber, OffsetQuadElementNumber

The attribute OffsetDofVertexNumber (continuous elements only) stores offsets used to number dofs on vertices. The attribute OffsetDofEdgeNumber (continuous elements only) stores offset used to number dofs on edges. The attribute OffsetDofFaceNumber (continuous elements only) stores offset used to number dofs on faces. For continuous elements, the attribute OffsetDofElementNumber stores offset used to number interior dofs on elements. Fod discontinuous elements, this attribute stores offset used to number all the dofs (that are only associated with elements. The attribute OffsetDofFaceNumber (HDG formulation only) stores offset used to number boundary unknown λ on edges of the mesh. Finally the attribute OffsetQuadElementNumber stores the offsets for the quadrature points on faces of each element.

Example :

Mesh<Dimension3> mesh;
mesh.Read("test.mesh");

// we consider a 3-D mesh numbering (with continuous elements)
MeshNumbering<Dimension3> mesh_num(mesh);
mesh_num.NumberMesh();

// if you want to know the first dof associated with a given vertex :
int num_vertex = 15;
int first_dof = mesh_num.OffsetDofVertexNumber(num_vertex);

// if you want to know the first dof associated with a given edge :
int num_edge = 21;
int first_dof_edge = mesh_num.OffsetDofVertexNumber(num_edge);

// if you want to know the first dof associated with a given face :
int num_face = 26;
int first_dof_face = mesh_num.OffsetDofFaceNumber(num_face);

// if you want to know the first dof associated with a given element :
int num_elem = 3;
int first_dof_elt = mesh_num.OffsetDofElementNumber(num_elem);

// offset for quadrature points
int offset_quad = mesh_num.OffsetQuadElementNumber(num_elem);

Location :

GlobDofNumber_Subdomain

The attribute GlobDofNumber_Subdomain stores the global dof number (for parallel computation) of a local dof. The attribute GlobDofPML_Subdomain stores the global pml dof numbers of local pml dofs

Example :

Mesh<Dimension3> mesh;
mesh.Read("test.mesh");

// we consider a 3-D mesh numbering (with continuous elements)
MeshNumbering<Dimension3> mesh_num(mesh);
mesh_num.NumberMesh();

// global dof of a local dof (assuming that the mesh has been split and distributed over processors)
int num_loc = 42;
int glob_dof = mesh_num.GlobDofNumber_Subdomain(num_loc);

// and for PMLs :
int num_loc_pml = 12;
int glob_dof_pml = mesh_num.GlobDofPML_Subdomain(num_loc_pml);

Location :

treat_periodic_condition_during_number

If the attribute treat_periodic_condition_during_number is true, the periodic conditions will be treated when the mesh is numbered. Otherwise the periodic conditions are not treated. By default this attribute is set to true.

Example :

Mesh<Dimension3> mesh;
mesh.Read("test.mesh");

// we consider a 3-D mesh numbering (with continuous elements)
MeshNumbering<Dimension3> mesh_num(mesh);
mesh_num.treat_periodic_condition_during_number = false; // if you do not want to find periodic dofs
mesh_num.NumberMesh();

Location :

compute_dof_pml, drop_interface_pml_dof

If the attribute compute_dof_pml is true, degrees of freedom associated with PMLs are numbered when NumberMesh is called. GetDofPML(i) will return the pml dof number of the i-th dof. If the i-th dof is not inside the PML, GetDofPML(i) returns -1. By default this attribute is set to false. If the attribute drop_interface_pml_dof is true, the dofs that are shared by the physical domain and PMLs will not be considered as PML. This approach will reduce the number of PML dofs.

Example :

Mesh<Dimension3> mesh;
mesh.Read("test.mesh");

// we consider a 3-D mesh numbering (with continuous elements)
MeshNumbering<Dimension3> mesh_num(mesh);
mesh_num.compute_dof_pml = true; // you want to number dofs of PMLs
mesh_num.drop_interface_pml_dof = true; // dofs on the interface are not PML
mesh_num.NumberMesh();

// number of dofs in PMLs ?
int nb_dof_pml = mesh_num.GetNbDofPML();

Location :

CopyInputData

Syntax

void CopyInputData(MeshNumbering<Dimension3>& mesh_num)

This method copies the input datas of another mesh numbering. The input datas are the parameters provided in the data file.

Example :

Mesh<Dimension3> mesh;
MeshNumbering<Dimension3> mesh_num(mesh);
mesh_num.SetOrder(4);

MeshNumberingh<Dimension3> mesh_num2(mesh);

// we copy all input data of the numbering
mesh_num2.CopyInputData(mesh_num);

Location :

ReallocateNeighborElements

Syntax

void ReallocateNeighborElements(int N)

This method allocates the arrays storing informations about neighbor elements.

Example :

Mesh<Dimension3> mesh;
MeshNumbering<Dimension3> mesh_num(mesh);
mesh_num.SetOrder(4);

// if you know the number of neighbor elements (elements on another processor)
mesh_num.ReallocateNeighborElements(10);

// filling informations : order, edge number, type of element
mesh_num.SetOrderNeighborElement(0, 4);
mesh_num.SetEdgeNeighborElement(0, 11);
mesh_num.SetTypeNeighborElement(0, 0);
mesh_num.SetOrderNeighborElement(1, 5);
mesh_num.SetEdgeNeighborElement(1, 27);
mesh_num.SetTypeNeighborElement(1, 0);
// ..

// once you filled informations, you call FinalizeNeighborElements()
mesh_num.FinalizeNeighborElements(mesh.GetNbBoundaryRef());

Location :

FinalizeNeighborElements

Syntax

void FinalizeNeighborElements(int N)

This method finalizes the arrays storing informations about neighbor elements. N is the number of referenced edges.

Example :

Mesh<Dimension3> mesh;
MeshNumbering<Dimension3> mesh_num(mesh);
mesh_num.SetOrder(4);

// if you know the number of neighbor elements (elements on another processor)
mesh_num.ReallocateNeighborElements(10);

// filling informations : order, edge number, type of element
mesh_num.SetOrderNeighborElement(0, 4);
mesh_num.SetEdgeNeighborElement(0, 11);
mesh_num.SetTypeNeighborElement(0, 0);
mesh_num.SetOrderNeighborElement(1, 5);
mesh_num.SetEdgeNeighborElement(1, 27);
mesh_num.SetTypeNeighborElement(1, 0);
// ..

// once you filled informations, you call FinalizeNeighborElements()
mesh_num.FinalizeNeighborElements(mesh.GetNbBoundaryRef());

Location :

GetMemorySize

Syntax

size_t GetMemorySize() const

This method returns the memory used to store the object in bytes.

Example :

Mesh<Dimension3> mesh;
MeshNumbering<Dimension3> mesh_num(mesh);
mesh_num.SetOrder(4);

mesh_num.NumberMesh();

// size used to store the numbering ?
size_t N = mesh_num.GetMemorySize();

Location :

SetInputData

Syntax

void SetInputData(const string& keyword, VectString& param)

This method is used during the reading of the data file. You can look at the section devoted to the data file and see the fields related to the mesh numbering.

Example :

Mesh<Dimension3> mesh;
MeshNumbering<Dimension3> mesh_num(mesh);
// some parameters are read on a data file
ReadInputFile("test.ini", &mesh_num);

Location :

ClearDofs

Syntax

void ClearDofs()

This method clears degrees of freedom present in the mesh. It cancels task performed by method NumberMesh.

Example :

Mesh<Dimension3> mesh;
MeshNumbering<Dimension3> mesh_num(mesh);
mesh.Read("toto.mesh");
mesh_num.SetOrder(5);

// mesh is numbered
mesh_num.NumberMesh();

// then you remove dof numbers
mesh_num.ClearDofs();

Location :

Clear

Syntax

void Clear()

This method clears the mesh numbering.

Example :

Mesh<Dimension3> mesh;
MeshNumbering<Dimension3> mesh_num(mesh);

// we read mesh
mesh.Read("test.mesh");
// we number the mesh
mesh_num.SetOrder(2);
mesh_num.NumberMesh();

// then you can clear the mesh numbering
mesh_num.Clear();

Location :

NumberMesh

Syntax

void NumberMesh()

This methods numbers the mesh, by attributing global dof numbers to each element. The number of dofs per vertex, edge, face and element is defined in object number_map. If discontinuous formulation is set in object number_map, we store only the first dof number on each element (since other dof numbers of the element are obtained by incrementing this initial dof number). Local numbers for reference elements are assumed to respect the following order :

Dofs on vertices of the element
Dofs on edges of the element
Dofs on faces of the element
Dofs inside the element

The Montjoie finite element classes are based on that ordering.

Example :

Mesh<Dimension3> mesh;
mesh.Read("toto.mesh");

MeshNumbering<Dimension3> mesh_num(mesh);
int order = 3;
mesh_num.SetOrder(order);

// using classical nodal numbering scheme (one dof per vertex, r dofs per edge, etc)
mesh_num.number_map.SetOrder(mesh, order);

// for specific finite element classes you can use ConstructNumberMap :
HexahedronHcurlFirstFamily fe_hcurl;
fe_hcurl.ConstructFiniteElement(order);
fe_hcurl.ConstructNumberMap(mesh_num.number_map, false);

// the mesh is numbered
mesh_num.NumberMesh();

cout << "Number of degrees of freedom : " << mesh_num.GetNbDof() << endl;

Location :

Element

Syntax

ElementNumbering& Element(int i)

This method gives access to an element of the mesh numbering.

Example :


// mesh is read  
Mesh<Dimension3> mesh;
mesh.Read("test.mesh");

// mesh is numbered
MeshNumbering<Dimension3> mesh_num(mesh);

mesh_num.SetOrder(r);
mesh_num.number_map.SetOrder(mesh, r);
mesh_num.NumberMesh();

// you can retrieve dof numbers
int i = 15, j = 1;
int num_dof = mesh_num.Element(i).GetNumberDof(j);

Location :

GetNbNeighborElt

Syntax

int GetNbNeighborElt() const

This method returns the number of neighbor elements.

Example :

Mesh<Dimension3> mesh;
MeshNumbering<Dimension3> mesh_num(mesh);
mesh_num.SetOrder(4);

// assuming that the mesh has been numbered and distributed
int nb_elt_neighbor = mesh_num.GetNbNeighborElt();

Location :

GetOrderNeighborElement

Syntax

int GetOrderNeighborElement(int i) const

This method returns the order of the i-th neighbor element.

Example :

Mesh<Dimension3> mesh;
MeshNumbering<Dimension3> mesh_num(mesh);
mesh_num.SetOrder(4);

// assuming that the mesh has been numbered and distributed
// you can retrieve the order of a neighbor element
int order_neighbor = mesh_num.GetOrderNeighborElement(1);

Location :

GetTypeNeighborElement

Syntax

int GetTypeNeighborElement(int i) const

This method returns the type of the i-th neighbor element. This type is equal to 0 for a tetrahedron, 1 for a pyramid, 2 for a wedge, 3 for an hexahedron.

Example :

Mesh<Dimension3> mesh;
MeshNumbering<Dimension3> mesh_num(mesh);
mesh_num.SetOrder(4);

// assuming that the mesh has been numbered and distributed
// you can retrieve the order of a neighbor element
int order_neighbor = mesh_num.GetOrderNeighborElement(1);
// and type of this element
int type = mesh_num.GetTypeNeighborElement(1);

Location :

GetEdgeNeighborElement

Syntax

int GetEdgeNeighborElement(int i) const

int GetLocalEdgeNumberNeighborElement(int n) const

The method GetEdgeNeighborElement returns the face number of the i-th neighbor element. The neighbor element is located on the other side of this face. The method GetLocalEdgeNumberNeighborElement is the reciprocal of method GetEdgeNeighborElement since it returns the neighbor element number i from the face number.

Example :

Mesh<Dimension3> mesh;
MeshNumbering<Dimension3> mesh_num(mesh);
mesh_num.SetOrder(4);

// assuming that the mesh has been numbered and distributed
// you can retrieve the order of a neighbor element
int order_neighbor = mesh_num.GetOrderNeighborElement(1);
// and type of this element
int type = mesh_num.GetTypeNeighborElement(1);
// and face number where this neighbor element is located
int num_face = mesh_num.GetEdgeNeighborElement(1);
// should give 1 here
int i = mesh_num.GetLocalEdgeNumberNeighborElement(num_edge);

Location :

SetOrderNeighborElement

Syntax

void SetOrderNeighborElement(int i, int r)

This method sets the order for the i-th neighbor element.

Example :

Mesh<Dimension3> mesh;
MeshNumbering<Dimension3> mesh_num(mesh);
mesh_num.SetOrder(4);

// if you know the number of neighbor elements (elements on another processor)
mesh_num.ReallocateNeighborElements(10);

// filling informations : order, face number, type of element
mesh_num.SetOrderNeighborElement(0, 4);
mesh_num.SetEdgeNeighborElement(0, 11);
mesh_num.SetTypeNeighborElement(0, 0);
mesh_num.SetOrderNeighborElement(1, 5);
mesh_num.SetEdgeNeighborElement(1, 27);
mesh_num.SetTypeNeighborElement(1, 0);
// ..

// once you filled informations, you call FinalizeNeighborElements()
mesh_num.FinalizeNeighborElements(mesh.GetNbBoundaryRef());

Location :

SetTypeNeighborElement

Syntax

void SetTypeNeighborElement(int i, int type)

This method sets the type for the i-th neighbor element.

Example :

Mesh<Dimension3> mesh;
MeshNumbering<Dimension3> mesh_num(mesh);
mesh_num.SetOrder(4);

// if you know the number of neighbor elements (elements on another processor)
mesh_num.ReallocateNeighborElements(10);

// filling informations : order, face number, type of element
mesh_num.SetOrderNeighborElement(0, 4);
mesh_num.SetEdgeNeighborElement(0, 11);
mesh_num.SetTypeNeighborElement(0, 0);
mesh_num.SetOrderNeighborElement(1, 5);
mesh_num.SetEdgeNeighborElement(1, 27);
mesh_num.SetTypeNeighborElement(1, 0);
// ..

// once you filled informations, you call FinalizeNeighborElements()
mesh_num.FinalizeNeighborElements(mesh.GetNbBoundaryRef());

Location :

SetEdgeNeighborElement

Syntax

void SetEdgeNeighborElement(int i, int num)

This method sets the edge number for the i-th neighbor element.

Example :

Mesh<Dimension3> mesh;
MeshNumbering<Dimension3> mesh_num(mesh);
mesh_num.SetOrder(4);

// if you know the number of neighbor elements (elements on another processor)
mesh_num.ReallocateNeighborElements(10);

// filling informations : order, face number, type of element
mesh_num.SetOrderNeighborElement(0, 4);
mesh_num.SetEdgeNeighborElement(0, 11);
mesh_num.SetTypeNeighborElement(0, 0);
mesh_num.SetOrderNeighborElement(1, 5);
mesh_num.SetEdgeNeighborElement(1, 27);
mesh_num.SetTypeNeighborElement(1, 0);
// ..

// once you filled informations, you call FinalizeNeighborElements()
mesh_num.FinalizeNeighborElements(mesh.GetNbBoundaryRef());

Location :

GetPeriodicityTypeForDof, SetPeriodicityTypeForDof

Syntax

int GetPeriodicityTypeForDof(int i) const

void SetPeriodicityTypeForDof(int i, int type)

The method GetPeriodicityTypeForDof returns the type of periodicity associated with the i-th periodic dof. It can be PERIODIC_CTE, PERIODIC_THETA, PERIODIC_X, PERIODIC_Y, PERIODIC_Z and also a combination of those : PERIODIC_XY, PERIODIC_XZ, PERIODIC_YZ, PERIODIC_XYZ, PERIODIC_ZTHETA. The method SetPeriodicityTypeForDof allows the user to change the type of periodicity.

Example :

Mesh<Dimension3> mesh;
mesh.Read("test.mesh");
  
// adding periodic conditions
TinyVector<int, 2> num(2);
num(0) = 3; num(1) = 6;
mesh.AddPeriodicCondition(num, BoundaryConditionEnum::PERIODIC_X);

// reading the mesh
mesh.Read("exemple.mesh");

MeshNumbering<Dimension3> mesh_num(mesh);

// numbering the mesh (assuming that number_map is correctly filled)
// if same dof numbers are used, no periodic dof
mesh_num.SetSameNumberPeriodicDofs(false);
mesh_num.NumberMesh();

// loop over periodic dofs
for (int i = 0; i < mesh_num.GetNbPeriodicDof(); i++)
  cout << "Type of periodicity for periodic dof " << i
       << " : " << mesh.GetPeriodicityTypeForDof(i) << endl;

Location :

GetPeriodicityTypeForBoundary, SetPeriodicityTypeForBoundary

Syntax

int GetPeriodicityTypeForBoundary(int num_edge) const

void SetPeriodicityTypeForBoundary(int num_edge, int type)

The method GetPeriodicityTypeForBoundary returns the type of periodicity associated with the i-th face. It can be PERIODIC_CTE, PERIODIC_THETA, PERIODIC_X, PERIODIC_Y, PERIODIC_Z. The method SetPeriodicityTypeForBoundary allows the user to change the type of periodicity.

Example :

Mesh<Dimension3> mesh;
mesh.Read("test.mesh");
  
// adding periodic conditions
TinyVector<int, 2> num(2);
num(0) = 3; num(1) = 6;
mesh.AddPeriodicCondition(num, BoundaryConditionEnum::PERIODIC_X);

// reading the mesh
mesh.Read("exemple.mesh");

MeshNumbering<Dimension3> mesh_num(mesh);

// numbering the mesh (assuming that number_map is correctly filled)
// if same dof numbers are used, no periodic dof
mesh_num.SetSameNumberPeriodicDofs(false);
mesh_num.NumberMesh();

// edge 12 is associated with a periodic condition ?
int type_per = mesh_num.GetPeriodicityTypeForBoundary(12);

Location :

GetNbPeriodicDof

Syntax

int GetNbPeriodicDof() const

This method returns the number of periodic dofs (obtained with a translation/rotation of original dofs).

Example :

Mesh<Dimension3> mesh;

// adding periodic conditions
TinyVector<int, 2> num;
num(0) = 3; num(1) = 6;
mesh.AddPeriodicCondition(num, BoundaryConditionEnum::PERIODIC_CTE);

// reading the mesh
mesh.Read("exemple.mesh");

MeshNumbering<Dimension3> mesh_num(mesh);

// numbering the mesh (assuming that number_map is correctly filled)
// if same dof numbers are used, no periodic dof
mesh_num.SetSameNumberPeriodicDofs(false);
mesh_num.NumberMesh();

cout << "Number of periodic dofs " << mesh_num.GetNbPeriodicDof() << endl;

Location :

GetPeriodicDof, SetPeriodicDof

Syntax

int GetPeriodicDof(int i) const

void SetPeriodicDof(int i, int num)

The method GetPeriodicDof returns the dof number of the i-th periodic dof of the mesh. The method SetPeriodicDof allows the user to change this number.

Example :

Mesh<Dimension3> mesh;

// adding periodic conditions
TinyVector<int, 2> num;
num(0) = 3; num(1) = 6;
mesh.AddPeriodicCondition(num, BoundaryConditionEnum::PERIODIC_CTE);

// reading the mesh
mesh.Read("exemple.mesh");

MeshNumbering<Dimension3> mesh_num(mesh);

// numbering the mesh (assuming that number_map is correctly filled)
// if same dof numbers are used, no periodic dof
mesh_num.SetSameNumberPeriodicDofs(false);
mesh_num.NumberMesh();

// display periodic and original dofs
for (int i = 0; i < mesh_num.GetNbPeriodicDof(); i++)
  cout << "Dof " << mesh_num.GetPeriodicDof(i) <<
       "obtained with a translation/rotation from dof " << mesh_num.GetOriginalPeriodicDof(i) << endl;

Location :

GetOriginalPeriodicDof, SetOriginalPeriodicDof

Syntax

int GetOriginalPeriodicDof(int i) const

void SetOriginalPeriodicDof(int i, int num)

The method GetOriginalPeriodicDof returns the original dof number of the i-th periodic dof of the mesh. The method SetOriginalPeriodicDof allows the user to change this number.

Example :

Mesh<Dimension3> mesh;

// adding periodic conditions
TinyVector<int, 2> num;
num(0) = 3; num(1) = 6;
mesh.AddPeriodicCondition(num, BoundaryConditionEnum::PERIODIC_CTE);

// reading the mesh
mesh.Read("exemple.mesh");

MeshNumbering<Dimension3> mesh_num(mesh);

// numbering the mesh (assuming that number_map is correctly filled)
// if same dof numbers are used, no periodic dof
mesh_num.SetSameNumberPeriodicDofs(false);
mesh_num.NumberMesh();

// display periodic and original dofs
for (int i = 0; i < mesh_num.GetNbPeriodicDof(); i++)
  cout << "Dof " << mesh_num.GetPeriodicDof(i) <<
       "obtained with a translation/rotation from dof " << mesh_num.GetOriginalPeriodicDof(i) << endl;

Location :

GetPeriodicBoundary, SetPeriodicBoundary

Syntax

int GetPeriodicBoundary(int num_edge) const

void SetPeriodicBoundary(int n1, int n2)

The method GetPeriodicBoundary returns the face number that is periodic with the given face. If the face does not belong to a periodic boundary, it should return -1. The method SetPeriodicBoundary allows the user to change this number.

Example :

Mesh<Dimension3> mesh;

// adding periodic conditions
TinyVector<int, 2> num;
num(0) = 3; num(1) = 6;
mesh.AddPeriodicCondition(num, BoundaryConditionEnum::PERIODIC_CTE);

// reading the mesh
mesh.Read("exemple.mesh");

MeshNumbering<Dimension3> mesh_num(mesh);

// numbering the mesh (assuming that number_map is correctly filled)
// if same dof numbers are used, no periodic dof
mesh_num.SetSameNumberPeriodicDofs(false);
mesh_num.NumberMesh();

// opposite face to a given face
int num_face = 12;
int num_face_opp = mesh_num.GetPeriodicBoundary(num_edge);
// if the face num_face has a reference 3, the face num_face_opp will have a reference 6 (ref 3 and 6 are said periodic)
// if num_face_opp = -1, it means that the face 12 did not belong to a periodic reference

Location :

SetSameNumberPeriodicDofs

Syntax

void SetSameNumberPeriodicDofs(bool same_number)

By calling this method, you can require (or not) that degrees of freedom located on periodic boundaries are attributed with the same numbers as the original degrees of freedom. If same numbers are attributed, there are no periodic dofs. The periodicity is ensured by construction, however quasi-periodic conditions are currently not implemented with this option. For quasi-periodic conditions (e.g. PERIODIC_X, PERIODIC_THETA), you cannot attribute same numbers.

Example :

Mesh<Dimension3> mesh;

// adding periodic conditions
TinyVector<int, 2> num;
num(0) = 3; num(1) = 6;
mesh.AddPeriodicCondition(num, PERIODIC_CTE);

// reading the mesh
mesh.Read("exemple.mesh");

MeshNumbering<Dimension3> mesh_num(mesh);

// numbering the mesh (assuming that number_map is correctly filled)
mesh_num.SetSameNumberPeriodicDofs(true);
mesh_num.NumberMesh();

Location :

SetFormulationForPeriodicCondition, GetFormulationForPeriodicCondition

Syntax

void SetFormulationForPeriodicCondition(int type)

int GetFormulationForPeriodicCondition() const

The method SetFormulationForPeriodicCondition sets the formulation that will be used in Montjoie to handle periodic conditions (or quasi-periodic). You can choose between

SAME_PERIODIC_DOFS : can handle only periodic conditions, periodic dofs have the same number.
STRONG_PERIODIC : the periodic condition is enforced by adding an equation u_i = phase*u_j to close the system. Quasi-periodic conditions are handled with this approach. This formulation is not correctly treated for parallel computations.
WEAK_PERIODIC : the periodic condition is enforced weakly with boundary integrals (such as for Discontinuous Galerkin). It is not implemented for all the equations in Montjoie. It works in parallel and is used by default if Discontinuous Galerkin method is used.

Example :

Mesh<Dimension3> mesh;

// adding periodic conditions
TinyVector<int, 2> num;
num(0) = 3; num(1) = 6;
mesh.AddPeriodicCondition(num, PERIODIC_X);

// reading the mesh
mesh.Read("exemple.mesh");

MeshNumbering<Dimension3> mesh_num(mesh);

// numbering the mesh (assuming that number_map is correctly filled)
mesh_num.SetFormulationForPeriodicCondition(mesh_num.WEAK_PERIODIC);
mesh_num.NumberMesh();

Location :

UseSameNumberForPeriodicDofs

Syntax

bool UseSameNumberPeriodicDofs() const

This method returns true if degrees of freedom located on periodic boundaries are attributed with the same numbers as the original degrees of freedom.

Example :

Mesh<Dimension3> mesh;

// adding periodic conditions
TinyVector<int, 2> num;
num(0) = 3; num(1) = 6;
mesh.AddPeriodicCondition(num, BoundaryConditionEnum::PERIODIC_CTE);

// reading the mesh
mesh.Read("exemple.mesh");

MeshNumbering<Dimension3> mesh_num(num);

// numbering the mesh (assuming that number_map is correctly filled)
cout << "Same number ? : " mesh_num.UseSameNumberForPeriodicDofs() << endl;
mesh_num.NumberMesh();

Location :

GetOrder

Syntax

int GetOrder() const

void GetOrder(TinyVector<IVect, 4>& order) const

This method returns the order of approximation. If a variable order is specified, it should return the maximal order of approximation. If you use the second syntax, you will get all the orders present in the mesh : order(0) will contain the orders for tetrahedra, order(1) for pyramids, order(2) for triangular prisms, order(3) for hexahedra.

Example :

Mesh<Dimension3> mesh;
mesh.Read("toto.mesh");

MeshNumbering<Dimension3> mesh_num(mesh);
mesh_num.SetOrder(3);
mesh_num.number_map.SetOrder(mesh, 3);


cout << "Order of approximation : " << mesh_num.GetOrder() << endl;

// for variable order, orders are retrieved in arrays
TinyVector<IVect, 4> order;
mesh_num.GetOrder(order);
// orders for tetrahedra in order(0)
cout << "Order for tetrahedra " << order(0) << endl;
// orders for pyramids in order(1)
cout << "Order for pyramids " << order(1) << endl;

Location :

GetNbDof

Syntax

int GetNbDof() const

This method returns the number of degrees of freedom contained in the mesh. If NumberMesh has not been called before, there will be no degree of freedom.

Example :

Mesh<Dimension3> mesh;
mesh.Read("toto.mesh");

MeshNumbering<Dimension3> mesh_num(mesh);
int order = 3;
mesh_num.SetOrder(order);

// using classical nodal numbering scheme (one dof per vertex, r dofs per edge, etc)
mesh_num.number_map.SetOrder(mesh, order);
mesh_num.NumberMesh();

cout << "Number of degrees of freedom : " << mesh_num.GetNbDof() << endl;

Location :

SetNbDof

Syntax

void SetNbDof(int N)

This method sets the number of degrees of freedom contained in the mesh. In a regular use, this number is set when NumberMesh is called and do not need to be modified.

Example :

Mesh<Dimension3> mesh;
mesh.Read("toto.mesh");

MeshNumbering<Dimension3> mesh_num(mesh);
int order = 3;
mesh_num.SetOrder(order);

// using classical nodal numbering scheme (one dof per vertex, r dofs per edge, etc)
mesh_num.number_map.SetOrder(mesh, order);
mesh_num.NumberMesh();

cout << "Number of degrees of freedom : " << mesh_num.GetNbDof() << endl;

// if you want to increase this value
int N = mesh_num.GetNbDof();
mesh_num.SetNbDof(N+1);

Location :

GetNbLocalDof

Syntax

int GetNbLocalDof(int i) const

This method returns the number of degrees of freedom within an element of the mesh. If NumberMesh has not been called before, it should return 0.

Example :

Mesh<Dimension3> mesh;
mesh.Read("toto.mesh");

MeshNumbering<Dimension3> mesh_num(mesh);
int order = 3;
mesh_num.SetOrder(order);

// using classical nodal numbering scheme (one dof per vertex, r dofs per edge, etc)
mesh_num.number_map.SetOrder(mesh, order);
mesh_num.NumberMesh();

for (int i = 0; i < mesh.GetNbElt(); i++)
  cout << "Element i contains " << mesh_num.GetNbLocalDof(i) << "degrees of freedom " << endl;

Location :

GetNbDofPML

Syntax

int GetNbDofPML() const

This method returns the number of degrees of freedom contained in the PMLs. If NumberMesh has not been called before or if there are no pmls in the mesh, it will return 0.

Example :

Mesh<Dimension3> mesh;
mesh.Read("toto.mesh");

// you can add a PML
mesh.ReallocatePmlAreas(1);
PmlRegionParameter<Dimension3>& pml = mesh.GetPmlArea(0);

int nb_layers = 2; Real_wp delta = 0.5;
pml.SetAdditionPML(pml.PML_BOTH_SIDES, pml.PML_BOTH_SIDES, pml.PML_BOTH_SIDES, nb_layers);
pml.SetThicknessPML(delta);
pml.AddPML(0, mesh);

// number the mesh
MeshNumbering<Dimension3> mesh_num(mesh);
int order = 3;
mesh_num.SetOrder(order);

// using classical nodal numbering scheme (one dof per vertex, r dofs per edge, etc)
mesh_num.number_map.SetOrder(mesh, order);
mesh_num.compute_dof_pml = true;
mesh_num.NumberMesh();

// number of degrees of freedom for all the mesh :
cout << "Number of degrees of freedom : " << mesh_num.GetNbDof() << endl;

// number of degrees of freedom for the PML only :
cout << "Number of degrees of freedom in PML : " << mesh_num.GetNbDofPML() << endl;

Location :

GetDofPML

Syntax

int GetDofPML(int i) const

This method returns the PML dof number of the i-th dof. If the i-th dof is not in a PML, the method will return -1.

Example :

Mesh<Dimension3> mesh;
mesh.Read("toto.mesh");

// you can add a PML
mesh.ReallocatePmlAreas(1);
PmlRegionParameter<Dimension3>& pml = mesh.GetPmlArea(0);

int nb_layers = 2; Real_wp delta = 0.5;
pml.SetAdditionPML(pml.PML_BOTH_SIDES, pml.PML_BOTH_SIDES, pml.PML_BOTH_SIDES, nb_layers);
pml.SetThicknessPML(delta);
pml.AddPML(0, mesh);

// number the mesh
MeshNumbering<Dimension3> mesh_num(mesh);
int order = 3;
mesh_num.SetOrder(order);

// using classical nodal numbering scheme (one dof per vertex, r dofs per edge, etc)
mesh_num.number_map.SetOrder(mesh, order);
mesh_num.compute_dof_pml = true;
mesh_num.NumberMesh();

// number of degrees of freedom for all the mesh :
cout << "Number of degrees of freedom : " << mesh_num.GetNbDof() << endl;

// number of degrees of freedom for the PML only :
cout << "Number of degrees of freedom in PML : " << mesh_num.GetNbDofPML() << endl;

// loop over dofs to check dofs in PML
for (int i = 0; i < mesh_num.GetNbDof(); i++)
  if (mesh_num.GetDofPML(i) >= 0)
     cout << "Dof " << i << " is inside a PML region" << endl;

Location :

ReallocateDofPML

Syntax

void ReallocateDofPML(int N)

This method changes the number of degrees of freedom in PML. Usually this number is already computed when the mesh is numbered and does not need to be changed.

Location :

SetDofPML

Syntax

void SetDofPML(int i, int num_pml)

This method changes the dof PML number of the i-th dof. Usually this number is already computed when the mesh is numbered and does not need to be changed.

Location :

SetOrder

Syntax

void SetOrder(int r)

This method sets the order of approximation associated with a mesh numbering. The same order will be set for all the elements of the mesh.

Example :

Mesh<Dimension3> mesh;
mesh.Read("toto.mesh");

// setting an uniform order for all elements
MeshNumbering<Dimension3> mesh_num(mesh);
int order = 3;
mesh_num.SetOrder(order);

// using classical nodal numbering scheme (one dof per vertex, r dofs per edge, etc)
mesh_num.number_map.SetOrder(mesh, order);
mesh_num.NumberMesh();

Location :

IsOrderVariable

Syntax

bool IsOrderVariable() const

This method returns true if a variable order is set for the mesh, false otherwise. Variable order will be present if you have called ComputeVariableOrder or SetOrderElement.

Example :

Mesh<Dimension3> mesh;
mesh.Read("toto.mesh");  

// setting an uniform order
MeshNumbering<Dimension3> mesh_num(mesh);
int order = 3;
mesh_num.SetOrder(order);

// should return false
cout << "Mesh with variable order ? " << mesh_num.IsOrderVariable() << endl;

Location :

SetVariableOrder

Syntax

void SetVariableOrder(int type)

This method sets the type of algorithm used to attribute order to each edge, face, element of the mesh. Currently, there are two provided algorithms MEAN_EDGE_ORDER, and MAX_EDGE_ORDER. The first one uses the average length value of the edges to determine the size h of an element, whereas the second one takes the maximum edge length. The user can also provide the orders for each edge/face/element, in that case USER_ORDER must be chosen instead of MAX_EDGE_ORDER.

Example :

Mesh<Dimension3> mesh;
mesh.Read("toto.mesh");

MeshNumbering<Dimension3> mesh_num(mesh);

Vector<double> step(10);
step.Fill(0);

// setting intervals for each order
// if h < 0.05 => first order
step(2) = 0.05;
// if 0.05 <= h < 0.15 => second order
step(3) = 0.15;
// if 0.15 <= h < 0.3 => third order
step(4) = 0.3;
// etc
mesh_num.SetMeshSizeVariableOrder(step);

// type of variable order
// if you choose mesh_num.USER_ORDER, you have to provide the orders for each edge and face of the mesh
mesh_num.SetVariableOrder(mesh_num.MAX_EDGE_ORDER);

// then computation of order for each edge, face, element
mesh_num.ComputeVariableOrder(false);

// setting the number of dofs for the orders computed
TinyVector<IVect, 4> order_used;
mesh_num.GetOrder(order_used);
for (int i = 0; i < order_used(0).GetM(); i++)
   mesh_num.number_map.SetOrder(mesh, order_used(0)(i));

// and numbering
mesh_num.NumberMesh();

// the orders are written on a mesh
mesh.WriteOrder("order.mesh", mesh_num);

Location :

SetMeshSizeVariableOrder

Syntax

void SetMeshSizeVariableOrder(const VectReal_wp& step)

This method sets the mesh sizes h(r) (given in the parameter step) used to attribute order to each edge. If the length of an edge is between h(r) and h(r+1), the order associated with this edge will be equal to r.

Example :

Mesh<Dimension3> mesh;
mesh.Read("toto.mesh");

MeshNumbering<Dimension3> mesh_num(mesh);

Vector<double> step(10);
step.Fill(0);

// setting intervals for each order
// if h < 0.05 => first order
step(2) = 0.05;
// if 0.05 <= h < 0.15 => second order
step(3) = 0.15;
// if 0.15 <= h < 0.3 => third order
step(4) = 0.3;
// etc
mesh_num.SetMeshSizeVariableOrder(step);

// type of variable order
mesh_num.SetVariableOrder(mesh_num.MAX_EDGE_ORDER);

// then computation of order for each edge, face, element
mesh_num.ComputeVariableOrder(false);

// setting the number of dofs for the orders computed
TinyVector<IVect, 4> order_used;
mesh_num.GetOrder(order_used);
for (int i = 0; i < order_used(0).GetM(); i++)
   mesh_num.number_map.SetOrder(mesh, order_used(0)(i));

// and numbering
mesh_num.NumberMesh();

// the orders are written on a mesh
mesh.WriteOrder("order.mesh", mesh_num);

Location :

SetCoefficientVariableOrder

Syntax

void SetCoefficientSizeVariableOrder(const VectReal_wp& coef)

This method sets the coefficient attributed to each element in order to determine the order of each edge, face, element of the mesh. If the length of an edge multiplied by this coefficient is between h(r) and h(r+1), the order associated with this edge will be equal to r.

Example :

Mesh<Dimension3> mesh;
mesh.Read("toto.mesh");

MeshNumbering<Dimension3> mesh_num(mesh);

Vector<double> step(10);
step.Fill(0);

// setting intervals for each order
// if h < 0.05 => first order
step(2) = 0.05;
// if 0.05 <= h < 0.15 => second order
step(3) = 0.15;
// if 0.15 <= h < 0.3 => third order
step(4) = 0.3;
// etc
mesh_num.SetMeshSizeVariableOrder(step);

// then for each element you can attribute a coefficient
// usually we take into account velocities on each physical domain
Vector<double> coef(mesh.GetNbElt());
coef.Fill(1);
for (int i = 0; i < mesh.GetNbElt(); i++)
  if (mesh.Element(i).GetReference() == 2)
    coef(i) = 2.0;

mesh_num.SetCoefficientVariableOrder(coef);

// type of variable order
mesh_num.SetVariableOrder(mesh_num.MEAN_EDGE_ORDER);

// then computation of order for each edge, face, element
mesh_num.ComputeVariableOrder(false);

// setting the number of dofs for the orders computed
TinyVector<IVect, 4> order_used;
mesh_num.GetOrder(order_used);
for (int i = 0; i < order_used(0).GetM(); i++)
   mesh_num.number_map.SetOrder(mesh, order_used(0)(i));

// and numbering
mesh_num.NumberMesh();

// the orders are written on a mesh
mesh.WriteOrder("order.mesh", mesh_num);

Location :

GetOrderElement

Syntax

int GetOrderElement(int i) const

This method returns the order of approximation for an element of the mesh.

Example :

Mesh<Dimension3> mesh;
mesh.Read("toto.mesh");

MeshNumbering<Dimension3> mesh_num(mesh);

Vector<double> step(10);
step.Fill(0);

// setting intervals for each order
// if h < 0.05 => first order
step(2) = 0.05;
// if 0.05 <= h < 0.15 => second order
step(3) = 0.15;
// if 0.15 <= h < 0.3 => third order
step(4) = 0.3;
// etc
mesh.SetMeshSizeVariableOrder(step);

// type of variable order
mesh_num.SetVariableOrder(mesh_num.MEAN_EDGE_ORDER);

// then computation of order for each edge, face, element
mesh_num.ComputeVariableOrder(false);

// printing orders of element ?
for (int i = 0; i < mesh.GetNbElt(); i++)
  cout << "Order for element " << i << " : " << mesh_num.GetOrderElement(i) << endl;

Location :

GetOrderEdge

Syntax

int GetOrderEdge(int i) const

This method returns the order of approximation for an edge of the mesh.

Example :

Mesh<Dimension3> mesh;
mesh.Read("toto.mesh");

MeshNumbering<Dimension3> mesh_num(mesh);

Vector<double> step(10);
step.Fill(0);

// setting intervals for each order
// if h < 0.05 => first order
step(2) = 0.05;
// if 0.05 <= h < 0.15 => second order
step(3) = 0.15;
// if 0.15 <= h < 0.3 => third order
step(4) = 0.3;
// etc
mesh_num.SetMeshSizeVariableOrder(step);

// type of variable order
mesh_num.SetVariableOrder(mesh_num.MEAN_EDGE_ORDER);

// then computation of order for each edge, face, element
mesh_num.ComputeVariableOrder(false);

// printing orders of edges ?
for (int i = 0; i < mesh.GetNbEdges(); i++)
  cout << "Order for edge " << i << " : " << mesh_num.GetOrderEdge(i) << endl;

Location :

GetOrderFace

Syntax

int GetOrderFace(int i) const

This method returns the order of approximation for a face of the mesh.

Example :

Mesh<Dimension3> mesh;
mesh.Read("toto.mesh");

MeshNumbering<Dimension3> mesh_num(mesh);

Vector<double> step(10);
step.Fill(0);

// setting intervals for each order
// if h < 0.05 => first order
step(2) = 0.05;
// if 0.05 <= h < 0.15 => second order
step(3) = 0.15;
// if 0.15 <= h < 0.3 => third order
step(4) = 0.3;
// etc
mesh_num.SetMeshSizeVariableOrder(step);

// type of variable order
mesh_num.SetVariableOrder(mesh_num.MEAN_EDGE_ORDER);

// then computation of order for each edge, face, element
mesh_num.ComputeVariableOrder(false);

// printing orders of faces ?
for (int i = 0; i < mesh.GetNbBoundary(); i++)
  cout << "Order for edge " << i << " : " << mesh_num.GetOrderFace(i) << endl;

Location :

GetOrderInside

Syntax

int GetOrderInside(int i) const

This method returns the order of approximation for the interior of element i of the mesh.

Location :

SetOrderEdge

Syntax

void SetOrderEdge(int i, int r)

This method sets the order of approximation for an edge of the mesh. If the mesh was previously specified with a constant order, it will be switched to a variable order, so that you can manually attribute an order to each element, face and edge of the mesh.

Example :

Mesh<Dimension3> mesh;
mesh.Read("toto.mesh");

MeshNumbering<Dimension3> mesh_num(mesh);

// attributing orders to each element
for (int i = 0; i < mesh.GetNbElt(); i++)
  {
    int r = 3;
    if (i%2 == 1)
      r = 4;
   
    mesh_num.SetOrderElement(i, r);
  }

// and on edges
for (int i = 0; i < mesh.GetNbEdges(); i++)
  {
    int r = 1;
    for (int k = 0; k < mesh.GetEdge(i).GetNbElements(); k++)
      {
        int ne = mesh.GetEdge(i).numElement(k);
        r = max(r, mesh.GetOrderElement(ne));
      }
   
    mesh_num.SetOrderEdge(i, r);
  }

// and on faces
for (int i = 0; i < mesh.GetNbBoundary(); i++)
  {
    int r = 1;
    for (int k = 0; k < mesh.Boundary(i).GetNbElements(); k++)
      {
        int ne = mesh.Boundary(i).numElement(k);
        r = max(r, mesh.GetOrderElement(ne));
      }
   
    mesh_num.SetOrderFace(i, r);
  }

// setting the number of dofs for the orders computed
mesh_num.number_map.SetOrder(mesh, 3);
mesh_num.number_map.SetOrder(mesh, 4);

// and numbering
mesh_num.NumberMesh();

// the orders are written on a mesh
mesh.WriteOrder("order.mesh", mesh_num);

Location :

SetOrderFace

Syntax

void SetOrderFace(int i, int r)

This method sets the order of approximation for a face of the mesh. If the mesh was previously specified with a constant order, it will be switched to a variable order, so that you can manually attribute an order to each element, face and edge of the mesh.

Example :

Mesh<Dimension3> mesh;
mesh.Read("toto.mesh");

MeshNumbering<Dimension3> mesh_num(mesh);

// attributing orders to each element
for (int i = 0; i < mesh.GetNbElt(); i++)
  {
    int r = 3;
    if (i%2 == 1)
      r = 4;
   
    mesh_num.SetOrderElement(i, r);
  }

// and on edges
for (int i = 0; i < mesh.GetNbEdges(); i++)
  {
    int r = 1;
    for (int k = 0; k < mesh.GetEdge(i).GetNbElements(); k++)
      {
        int ne = mesh.GetEdge(i).numElement(k);
        r = max(r, mesh.GetOrderElement(ne));
      }
   
    mesh_num.SetOrderEdge(i, r);
  }

// and on faces
for (int i = 0; i < mesh.GetNbBoundary(); i++)
  {
    int r = 1;
    for (int k = 0; k < mesh.Boundary(i).GetNbElements(); k++)
      {
        int ne = mesh.Boundary(i).numElement(k);
        r = max(r, mesh.GetOrderElement(ne));
      }
   
    mesh_num.SetOrderFace(i, r);
  }

// setting the number of dofs for the orders computed
mesh_num.number_map.SetOrder(mesh, 3);
mesh_num.number_map.SetOrder(mesh, 4);

// and numbering
mesh_num.NumberMesh();

// the orders are written on a mesh
mesh.WriteOrder("order.mesh", mesh_num);

Location :

SetOrderInside

Syntax

void SetOrderInside(int i, int r)

This method sets the order of approximation for the interior of element i of the mesh.

Location :

GetNbPointsQuadratureBoundary

Syntax

int GetNbPointsQuadratureBoundary(int i) const

This method returns the number of quadrature points used for a face of the mesh.

Example :

Mesh<Dimension3> mesh;
mesh.Read("toto.mesh");

MeshNumbering<Dimension3> mesh_num(mesh);

// type of variable order
mesh_num.SetVariableOrder(mesh_num.MEAN_EDGE_ORDER);

// then computation of order for each edge, face, element
mesh_num.ComputeVariableOrder(true);

// and numbering (assuming that mesh_num.number_map has been filled correctly)
mesh_num.NumberMesh();

// then you can know the number of quadrature points on each face
for (int i = 0; i < mesh.GetNbBoundary(); i++)
  cout << "Edge " << i << " contains " << mesh_num.GetNbPointsQuadratureBoundary(i) << " quadrature points" << endl;

Location :

InitPeriodicBoundary

Syntax

void InitPeriodicBoundary()

This method allocates arrays needed to store periodic boundaries. After calling this methode, you can call the method SetPeriodicBoundary to specify a periodic boundary. In a regular use, this method does not need to be called, since TreatPeriodicCondition fills the arrays for periodic boundaries.

Example :

Mesh<Dimension3> mesh;

// adding periodic conditions
TinyVector<int, 2> num;
num(0) = 3; num(1) = 6;
mesh.AddPeriodicCondition(num, BoundaryConditionEnum::PERIODIC_CTE);

// reading the mesh
mesh.Read("exemple.mesh");

MeshNumbering<Dimension3> mesh_num(mesh);

// you did not number the mesh but you want to provide periodic boundaries
mesh_num.InitPeriodicBoundary();
mesh_num.SetPeriodicBoundary(3, 7);
// etc

Location :

GetTranslationPeriodicDof, SetTranslationPeriodicDof

Syntax

R3 GetTranslationPeriodicDof(int i) const

void SetTranslationPeriodicDof(int i, R3 u)

The method GetTranslationPeriodicDof returns the translation vector between two periodic degrees of freedom. The method SetTranslationPeriodicDof allows the user to change this translation vector.

Example :

Mesh<Dimension3> mesh;

// adding periodic conditions
TinyVector<int, 2> num;
num(0) = 3; num(1) = 6;
mesh.AddPeriodicCondition(num, BoundaryConditionEnum::PERIODIC_CTE);

// reading the mesh
mesh.Read("exemple.mesh");

MeshNumbering<Dimension3> mesh_num(mesh);

// numbering the mesh (assuming that number_map is correctly filled)
// if same dof numbers are used, no periodic dof
mesh_num.SetSameNumberPeriodicDofs(false);
mesh_num.NumberMesh();

// display translation
for (int i = 0; i < mesh_num.GetNbPeriodicDof(); i++)
  cout << "Dof " << mesh_num.GetPeriodicDof(i) <<
       "obtained with a translation of " << mesh_num.GetTranslationPeriodicDof(i) << endl;

Location :

GetTranslationPeriodicBoundary

Syntax

R3 GetTranslationPeriodicBoundary(int i) const

VectR3& GetTranslationPeriodicBoundary() const

This method returns the translation vector between two periodic boundaries. With the second syntax, you can retrieve the translation vectors for all the referenced faces.

Example :

Mesh<Dimension3> mesh;

// adding periodic conditions
TinyVector<int, 2> num;
num(0) = 3; num(1) = 6;
mesh.AddPeriodicCondition(num, BoundaryConditionEnum::PERIODIC_CTE);

// reading the mesh
mesh.Read("exemple.mesh");

MeshNumbering<Dimension3> mesh_num(mesh);

// numbering the mesh (assuming that mesh_num.number_map is correctly filled)
// if same dof numbers are used, no periodic dof
mesh_num.SetSameNumberPeriodicDofs(false);
mesh_num.NumberMesh();

// display translation vector between face 0 and its opposite face
cout << "Translation = " << mesh.GetTranslationPeriodicBoundary(0) << endl;

Location :

ReallocateElements

Syntax

void ReallocateElements(int n)

This method changes the number of elements present in the mesh numbering. On a regular use, this method should not be called, since NumberMesh will allocate the array correctly.

Location :

ReallocatePeriodicDof

Syntax

void ReallocatePeriodicDof(int n)

This method changes the number of periodic dofs in the mesh numbering. On a regular use, this method should not be called, since NumberMesh will compute this number automatically (and allocate the arrays related to periodic degrees of freedom).

Location :

ComputeVariableOrder

Syntax

void ComputeVariableOrder(int dg_formulation)

This method attributes an order of approximation to each edge, face and element of the mesh in the case where the order is variable. This should be called before NumberMesh so that numbering of the mesh is correctly performed. In 3-D, we attribute an order r_e to each edge e of the mesh with the following rule :

where h_e is the length of the edge e, steps λ are specified by method SetMeshSizeVariableOrder, and c_e is a coefficient controlled by method SetCoefficientVariableOrder. When orders have been attributed to the edges, we then attribute an order to each element of the mesh. If MEAN_EDGE_ORDER algorithm has been selected, the order for each element will be equal to

If MAX_EDGE_ORDER algorithm has been selected, the order for each element will be equal to

The orders for the faces are attributed with the following rule :

If dg_formulation is set to DISCONTINUOUS or HDG, the order of faces will then be modified to be the maximal value of orders of neighboring elements, so that quadrature formulas on faces of the mesh are always accurate enough. This is important for Discontinuous Galerkin formulation where boundary integrals defined on internal faces are present.

Example :

Mesh<Dimension3> mesh;
mesh.Read("toto.mesh");

MeshNumbering<Dimension3> mesh_num(mesh);

// defining the values for h (in step)
Vector<double> step(10);
step.Fill(0);

// setting intervals for each order
// if h < 0.05 => first order
step(2) = 0.05;
// if 0.05 <= h < 0.15 => second order
step(3) = 0.15;
// if 0.15 <= h < 0.3 => third order
step(4) = 0.3;
// etc
mesh_num.SetMeshSizeVariableOrder(step);

// type of variable order
mesh_num.SetVariableOrder(mesh_num.MEAN_EDGE_ORDER);

// then computation of order for each edge, face, element
// choose between CONTINUOUS, DISCONTINUOUS or HDG for the parameter
mesh_num.ComputeVariableOrder(ElementReference_Base::DISCONTINUOUS);

// and numbering (assuming that mesh_num.number_map is already filled)
mesh_num.NumberMesh();

Location :

GetOrderQuadrature

Syntax

int GetOrderQuadrature(int i) const

void GetOrderQuadrature(TinyVector<IVect, 4>& order) const

This method returns the order of quadrature formula for a face of the mesh. It is usually set as the maximum order of the two adjoining elements so that boundary integrals are exactly evaluated.

Example :

Mesh<Dimension3> mesh;
mesh.Read("toto.mesh");

MeshNumbering<Dimension3> mesh_num(mesh);

Vector<double> step(10);
step.Fill(0);

// setting intervals for each order
// if h < 0.05 => first order
step(2) = 0.05;
// if 0.05 <= h < 0.15 => second order
step(3) = 0.15;
// if 0.15 <= h < 0.3 => third order
step(4) = 0.3;
// etc
mesh_num.SetMeshSizeVariableOrder(step);

// type of variable order
mesh_num.SetVariableOrder(mesh_num.MEAN_EDGE_ORDER);

// then computation of order for each edge, face, element
mesh_num.ComputeVariableOrder(false);

// printing orders of quadrature ?
for (int i = 0; i < mesh.GetNbBoundary(); i++)
  cout << "Order of quadrature for face " << i << " : " << mesh.GetOrderQuadrature(i) << endl;

// if you want to know all the orders present in the mesh
TinyVector<IVect, 4> order_used;
mesh_num.GetOrderQuadrature(order_used);
cout << "Orders of quadrature present :  " << order_used << endl;

Location :

SetOrderQuadrature

Syntax

void SetOrderQuadrature(int i, int r)

This method sets the order of quadrature for a face of the mesh.

Example :

Mesh<Dimension3> mesh;
mesh.Read("toto.mesh");

MeshNumbering<Dimension3> mesh_num(mesh);

// attributing orders to each element
for (int i = 0; i < mesh.GetNbElt(); i++)
  {
    int r = 3;
    if (i%2 == 1)
      r = 4;
   
    mesh_num.SetOrderElement(i, r);
  }

// and quadrature on faces
for (int i = 0; i < mesh.GetNbBoundary(); i++)
  {
    int r = 1;
    for (int k = 0; k < mesh.Boundary(i).GetNbElements(); k++)
      {
        int ne = mesh.Boundary(i).numElement(k);
        r = max(r, mesh.GetOrderElement(ne));
      }

    mesh_num.SetOrderQuadrature(i, r);
  }

Location :

GetNbDofElement

Syntax

int GetNbDofElement(int i, Face<Dimension3> edge)

int GetNbDofElement(int i, Volume elt)

This method is used by NumberMesh to know the expected number of degrees of freedom for an element (or a face). If the mesh is already numbered, you should call GetNbLocalDof if you want to know the number of degrees of freedom for an element of the mesh.

Example :

Mesh<Dimension3> mesh;
mesh.Read("toto.mesh");

MeshNumbering<Dimension3> mesh_num(mesh);
int order = 3;
mesh_num.SetOrder(order);

// using classical nodal numbering scheme (one dof per vertex, r dofs per edge, etc)
mesh_num.number_map.SetOrder(mesh, order);

// for specific finite element classes you can use ConstructNumberMap :
HexahedronHcurlFirstFamily fe_hcurl;
fe_hcurl.ConstructFiniteElement(order);
fe_hcurl.ConstructNumberMap(mesh_num.number_map, false);

// the mesh is numbered
mesh_num.NumberMesh();

// number of dofs on a face of the mesh :
int num_face = 42;
int nb_dof_face = mesh_num.GetNbDofElement(num_face, mesh.Boundary(num_face));

// number of dofs on an element
int num_elt = 31;
int nb_dof_elt = mesh_num.GetNbDofElement(num_elt, mesh.Element(num_elt));

// for this last case, GetNbLocalDof is fastest :
nb_dof_elt = mesh_num.GetNbLocalDof(num_elt);

Location :

GetBoundaryRotation

Syntax

int GetBoundaryRotation(int f, int e1, int e2, int pos1, int& pos2, int& rot) const

When a face f is shared by two elements e1 and e2, and we know that the local position of edge f is pos, this method finds the local position on the face for the second element (pos2), and the difference of orientation of the face between the two elements (rot). When the face is located on a periodic boundary, it returns the face number of the corresponding boundary.

Example :

Mesh<Dimension3> mesh;
mesh.Read("toto.mesh");

MeshNumbering<Dimension2> mesh_num(mesh);

int num_face = 10;
int num_elem1 = mesh.Boundary(num_face).numElement(0);
int num_elem2 = mesh.Boundary(num_face).numElement(1);
int pos1 = mesh.Element(num_elem1).GetPositionBoundary(num_face);
int pos2, rot;
mesh_num.GetBoundaryRotation(num_edge, num_elem1, num_elem2, pos1, pos2, rot);

Location :

CheckMeshNumber

Syntax

void CheckMeshNumber()

The mesh numbering is checked (mainly offsets for edges and faces).

Example :

Mesh<Dimension3> mesh;
mesh.Read("toto.mesh");

MeshNumbering<Dimension2> mesh_num(mesh);

mesh_num.SetOrder(4);
mesh_num.number_map.SetOrder(mesh, 4);

mesh_num.NumberMesh();

// checking that the mesh numbering is corrrect
mesh_num.CheckMeshNumber();

Location :

ReconstructOffsetDofs

Syntax

void ReconstructOffsetDofs()

This method reconstructs the arrays OffsetDofFaceNumber, OffsetDofEdgeNumber, OffsetDofElementNumber, OffsetDofVertexNumber. On a regular use, this method does not need to be called, since NumberMesh will call it automatically. However, if you modified dof numbers manually, it may be needed to call this method.

Example :

// assuming that you constructed a mesh numbering
MeshNumbering<Dimension3> mesh_num(mesh);
mesh_num.NumberMesh();

// you modify dofs manually
mesh_num.Element(1).SetNumberDof(10, 51);
// etc

// you need to reconstruct offset arrays
mesh_num.ReconstructOffsetDofs();

Location :

ConstructTetrahedralNumbering

Syntax

void ConstructTetrahedralNumbering(int r, Array3D<int>& NumNodes, Matrix<int>& CoordinateNodes)

For a standard nodal tetrahedral finite element, this method gives you local numbers of the tetrahedron as they should be ordered :

Dofs on vertices of the element
Dofs on edges of the element
Dofs on faces of the element
Dofs inside the element

NumNodes and CoordinatesNodes allows you to switch from a 3-index notation (i₁, i₂, i₃) to a 1-index notation i, as shown in the example below :

Example :

int r = 4;
Array3D<int> NumNodes; Matrix<int> CoordinateNodes;
MeshNumbering<Dimension3>::ConstructTetrahedralNumbering(r, NumNodes, CoordinateNodes);

// you may want to loop over x-coordinate, y-coordinate and z-coordinate
for (int i1 = 0; i1 <= r; i1++)
   for (int i2 = 0; i2 <= r-i1; i2++)
      for (int i3 = 0; i3 <= r-i1-i2; i3++)
        {
          // then retrieve the number associated with position (i1, i2, i3)
          int node = NumNodes(i1, i2, i3);
        }

// you may want to loop over nodes
for (int i = 0; i < (r+1)*(r+2)*(r+3)/6; i++)
  {
    // and retrieve x-coordinate, y-coordinate, z-coordinate of this node
    int i1 = CoordinateNodes(i, 0);
    int i2 = CoordinateNodes(i, 1);
    int i3 = CoordinateNodes(i, 2);
  }

Location :

ConstructPyramidalNumbering

Syntax

void ConstructPyramidalNumbering(int r, Array3D<int>& NumNodes, Matrix<int>& CoordinateNodes)

For a standard nodal pyramidal finite element, this method gives you local numbers of the pyramid as they should be ordered :

Dofs on vertices of the element
Dofs on edges of the element
Dofs on faces of the element
Dofs inside the element

NumNodes and CoordinatesNodes allows you to switch from a 3-index notation (i₁, i₂, i₃) to a 1-index notation i, as shown in the example below :

Example :

int r = 4;
Array3D<int> NumNodes; Matrix<int> CoordinateNodes;
MeshNumbering<Dimension3>::ConstructPyramidalNumbering(r, NumNodes, CoordinateNodes);

// you may want to loop over x-coordinate, y-coordinate and z-coordinate
for (int i1 = 0; i1 <= r; i1++)
   for (int i2 = 0; i2 <= r; i2++)
      for (int i3 = 0; i3 <= r-max(i1, i2); i3++)
        {
          // then retrieve the number associated with position (i1, i2, i3)
          int node = NumNodes(i1, i2, i3);
        }

// you may want to loop over nodes
for (int i = 0; i < (r+1)*(r+2)*(2*r+3)/6; i++)
  {
    // and retrieve x-coordinate, y-coordinate, z-coordinate of this node
    int i1 = CoordinateNodes(i, 0);
    int i2 = CoordinateNodes(i, 1);
    int i3 = CoordinateNodes(i, 2);
  }

Location :

ConstructPrismaticNumbering

Syntax

void ConstructPrismaticNumbering(int r, Array3D<int>& NumNodes, Matrix<int>& CoordinateNodes)

For a standard nodal prismatic finite element, this method gives you local numbers of the prism as they should be ordered :

Dofs on vertices of the element
Dofs on edges of the element
Dofs on faces of the element
Dofs inside the element

NumNodes and CoordinatesNodes allows you to switch from a 3-index notation (i₁, i₂, i₃) to a 1-index notation i, as shown in the example below :

Example :

int r = 4;
Array3D<int> NumNodes; Matrix<int> CoordinateNodes;
MeshNumbering<Dimension3>::ConstructPrismaticNumbering(r, NumNodes, CoordinateNodes);

// you may want to loop over x-coordinate, y-coordinate and z-coordinate
for (int i1 = 0; i1 <= r; i1++)
   for (int i2 = 0; i2 <= r-i1; i2++)
      for (int i3 = 0; i3 <= r; i3++)
        {
          // then retrieve the number associated with position (i1, i2, i3)
          int node = NumNodes(i1, i2, i3);
        }

// you may want to loop over nodes
for (int i = 0; i < (r+1)*(r+2)*(r+1)/2; i++)
  {
    // and retrieve x-coordinate, y-coordinate, z-coordinate of this node
    int i1 = CoordinateNodes(i, 0);
    int i2 = CoordinateNodes(i, 1);
    int i3 = CoordinateNodes(i, 2);
  }

Location :

ConstructHexahedralNumbering

Syntax

void ConstructHexahedralNumbering(int r, Array3D<int>& NumNodes, Matrix<int>& CoordinateNodes)

For a standard nodal hexahedral finite element, this method gives you local numbers of the prism as they should be ordered :

Dofs on vertices of the element
Dofs on edges of the element
Dofs on faces of the element
Dofs inside the element

NumNodes and CoordinatesNodes allows you to switch from a 3-index notation (i₁, i₂, i₃) to a 1-index notation i, as shown in the example below :

Example :

int r = 4;
Array3D<int> NumNodes; Matrix<int> CoordinateNodes;
MeshNumbering<Dimension3>::ConstructHexahedralNumbering(r, NumNodes, CoordinateNodes);

// you may want to loop over x-coordinate, y-coordinate and z-coordinate
for (int i1 = 0; i1 <= r; i1++)
   for (int i2 = 0; i2 <= r; i2++)
      for (int i3 = 0; i3 <= r; i3++)
        {
          // then retrieve the number associated with position (i1, i2, i3)
          int node = NumNodes(i1, i2, i3);
        }

// you may want to loop over nodes
for (int i = 0; i < (r+1)*(r+1)*(r+1); i++)
  {
    // and retrieve x-coordinate, y-coordinate, z-coordinate of this node
    int i1 = CoordinateNodes(i, 0);
    int i2 = CoordinateNodes(i, 1);
    int i3 = CoordinateNodes(i, 2);
  }

Location :

GetRotationTriangularFace

Syntax

void GetRotationTriangularFace(const Matrix<int>& NumNodes, Matrix<int>& RotationNodes)

void GetRotationTriangularFace(const VectR2& Points, Matrix<int>& RotationNodes)

This method computes the nodal numbers on a triangular face after rotation/symmetry of this face. The six different transformations are given in the explanation of the method GetRotationFaceDof. In the first syntax, the nodal numbers are computed from the tensorial numbering (i1, i2). In the second syntax, the nodal numbers are computed from the position of the points on the unit triangle. Of course, we assume that these points are symmetric, such that the set of points remains unchanged when the triangle is symmetrized and/or rotated, only the numbering changes.

Example :

// we define points on the unit triangle
VectR2 points(6);
points(0).Init(0, 0); points(1).Init(1, 0); points(2).Init(0, 1);
points(3).Init(0.5, 0); points(4).Init(0, 0.5); points(5).Init(0.5, 0.5);

// we want to know the numbering of these points after rotation and/or symmetry of the triangle
// for example the point 1 becomes the point 2 with a symmetry
Matrix<int> FaceRot;
MeshNumbering<Dimension3>::GetRotationTriangularFace(points, FaceRot);

IVect col; GetCol(FaceRot, 1, col); 
cout << "New numbers of points after rotation 1 = " << col << endl;

IVect col; GetCol(FaceRot, 2, col); 
cout << "New numbers of points after rotation 2 = " << col << endl;

Location :

GetRotationQuadrilateralFace

Syntax

void GetRotationQuadrilateralFace(const Matrix<int>& NumNodes, Matrix<int>& RotationNodes)

void GetRotationQuadrilateralFace(const VectR2& Points, Matrix<int>& RotationNodes)

This method computes the nodal numbers on a quadrangular face after rotation/symmetry of this face. The eight different transformations are given in the explanation of the method GetRotationFaceDof. In the first syntax, the nodal numbers are computed from the tensorial numbering (i1, i2). In the second syntax, the nodal numbers are computed from the position of the points on the unit square. Of course, we assume that these points are symmetric/invariant by rotation, such that the set of points remains unchanged when the quadrangle is symmetrized and/or rotated, only the numbering changes.

Example :

// we define points on the unit square
VectR2 points(9);
points(0).Init(0, 0); points(1).Init(1, 0); points(2).Init(0, 1); points(3).Init(1, 1);
points(4).Init(0.5, 0); points(5).Init(0, 0.5); points(6).Init(0.5, 0.5); points(7).Init(1.0, 0.5); points(8).Init(0.5, 1.0);

// we want to know the numbering of these points after rotation and/or symmetry of the quadrangle
Matrix<int> FaceRot;
MeshNumbering<Dimension3>::GetRotationQuadrilateralFace(points, FaceRot);

IVect col; GetCol(FaceRot, 1, col); 
cout << "New numbers of points after rotation 1 = " << col << endl;

IVect col; GetCol(FaceRot, 2, col); 
cout << "New numbers of points after rotation 2 = " << col << endl;

Location :

GetReferenceQuadrature

Syntax

const VectR2& GetReferenceQuadrature(int type, int order)

This method returns the quadrature points to use for the unit triangle or unit square.

Parameters

type: type of element (0: triangle, 1: quadrangle)
order: order of approximation

Example :

// assuming that you constructed a mesh numbering
MeshNumbering<Dimension3> mesh_num(mesh);
mesh_num.NumberMesh();

// you can retrieve the quadrature points for the unit triangle
int order = 3; // order present in the mesh
VectR2 pts_tri = mesh_num.GetReferenceQuadrature(0, order);

// and unit square
VectR2 points = mesh_num.GetReferenceQuadrature(1, order);

Location :

SetOrderElement

Syntax

void SetOrderElement(int i, int r)

This method sets the order of approximation for an element of the mesh. If the mesh was previously specified with a constant order, it will be switched to a variable order, so that you can manually attribute an order to each element of the mesh.

Example :

Mesh<Dimension3> mesh;
mesh.Read("toto.mesh");

MeshNumbering<Dimension3> mesh_num(mesh);

// attributing orders to each element
for (int i = 0; i < mesh.GetNbElt(); i++)
  {
    int r = 3;
    if (i%2 == 1)
      r = 4;
   
    mesh_num.SetOrderElement(i, r);
  }

// and on edges
for (int i = 0; i < mesh.GetNbEdges(); i++)
  {
    int r = 1;
    for (int k = 0; k < mesh.GetEdge(i).GetNbElements(); k++)
      {
        int ne = mesh.Boundary(i).numElement(k);
        r = max(r, mesh.GetOrderElement(ne));
      }
   
    mesh_num.SetOrderEdge(i, r);
  }

// and on faces
for (int i = 0; i < mesh.GetNbBoundary(); i++)
  {
    int r = 1;
    for (int k = 0; k < mesh.Boundary(i).GetNbElements(); k++)
      {
        int ne = mesh.Boundary(i).numElement(k);
        r = max(r, mesh.GetOrderElement(ne));
      }
   
    mesh_num.SetOrderFace(i, r);
  }

// setting the number of dofs for the orders computed
mesh_num.number_map.SetOrder(mesh, 3);
mesh_num.number_map.SetOrder(mesh, 4);

// and numbering
mesh_num.NumberMesh();

// the orders are written on a mesh
mesh.WriteOrder("order.mesh", mesh_num);

Location :

TreatPeriodicCondition

Syntax

void TreatPeriodicCondition()

This method finds periodic dofs, it is called in method NumberMesh, so you should not call that method in regular use.

Example :

Mesh<Dimension3> mesh;

// reading the mesh
mesh.Read("exemple.mesh");

MeshNumbering<Dimension3> mesh_num(mesh);

// if you want to treat periodic condition apart
mesh_num.treat_periodic_condition_during_number = false;
mesh_num.NumberMesh();

// then you compute the periodic dofs
mesh_num.TreatPeriodicCondition();

Location :

GetRotationFace

Syntax

int GetRotationFace(int way1, int way2, int nv)

This method will return 0 if way1 and way2 are equal (faces with same orientation), and a rotation number if the orientation differ (see GetRotationFaceDof for the different numbers).

Parameters

way1: orientation of first edge
way2: orientation of second edge
nv: number of vertices (unused)

Example :

MeshNumbering<Dimension3> mesh_num(mesh);
for (int i = 0; i < mesh.GetNbBoundary(); i++)
  if (mesh.Boundary(i).GetNbElements() == 2)
    {
      int n1 = mesh.Boundary(i).numElement(0);
      int n2 = mesh.Boundary(i).numElement(1);
      int pos1 = mesh.Element(n1).GetPositionBoundary(i);
      int pos2 = mesh.Element(n2).GetPositionBoundary(i);
      int way1 = mesh.Element(n1).GetOrientationBoundary(pos1);
      int way2 = mesh.Element(n2).GetOrientationBoundary(pos2);
      int rot = mesh_num.GetRotationFace(way1, way2, mesh.Boundary(i).GetNbVertices());
    }

Location :

GetOppositeOrientationFace

Syntax

int GetOppositeRotationFace(int rot, Face<Dimension3>& f)

This method will return the reciprocal rotation of the rotation rot. It gives the rotation number that transforms f2 to f1, knowing that f1 is transformed into f2 with rotation rot.

Example :

MeshNumbering<Dimension3> mesh_num(mesh);
for (int i = 0; i < mesh.GetNbBoundary(); i++)
  if (mesh.Boundary(i).GetNbElements() == 2)
    {
      int n1 = mesh.Boundary(i).numElement(0);
      int n2 = mesh.Boundary(i).numElement(1);
      int pos1 = mesh.Element(n1).GetPositionBoundary(i);
      int pos2 = mesh.Element(n2).GetPositionBoundary(i);
      int way1 = mesh.Element(n1).GetOrientationBoundary(pos1);
      int way2 = mesh.Element(n2).GetOrientationBoundary(pos2);
      int rot = mesh.GetRotationFace(way1, way2, mesh.Boundary(i).GetNbVertices());
      // opposite orientation
      int rot2 = mesh_num.GetOppositeOrientationFace(rot, mesh.Boundary(i));
    }

Location :

GetLocalVertexBoundary, GetVertexNumberOfFace

Syntax

int GetLocalVertexBoundary(int type, int num_loc, int num_loc_vertex)

int GetVertexNumberOfFace(int type, int num_loc, int num_loc_vertex)

These two methods are identic and return the vertex number (in the reference element) of a vertex of a face.

Parameters

type: type of element (0: tetra, 1: pyramid, 2: prism, 3: hexa)
num_loc: local face number
num_loc_vertex: local number of the vertex in the face (0, 1, 2 or 3)

Example :

  // for example, you want to know the first vertex of the third face of the unit cube
  int num = MeshNumbering<Dimension3>::GetLocalVertexBoundary(3, 2, 0);

Location :

GetEdgeNumberOfFace

Syntax

int GetEdgeNumberOfFace(int type, int num_loc, int num_edge_loc)

This method returns the edge number (in the reference element) of an edge of a face.

Parameters

type: type of element (0: tetra, 1: pyramid, 2: prism, 3: hexa)
num_loc: local face number
num_edge_loc: local number of the edge in the face (0, 1, 2 or 3)

Example :

  // for example, you want to know the first edge of the third face of the unit cube
  int num = MeshNumbering<Dimension3>::GetEdgeNumberOfFace(3, 2, 0);

Location :