# Creating a mesh

Set the Feel++ environment with local repository
``````import feelpp
import sys
app = feelpp.Environment(["myapp"],config=feelpp.localRepository(""))``````

## 1. Load a mesh from a `geo` or `msh` file

`feelpp.mesh(dim=2, geo=1, realdim=2, worldComm=None)` : create a mesh. The mesh is of topological dimension `dim`, in real dimension `realdim` with geometric order `geo`. The mesh is configured with a `WorldComm` which provides the parallel process layout.

Keyword arguments:

• `dim` : the topological dimension (default: `2`)

• `geo` : the geometrical order (default: `1`)

• `realdim` : the real dimension (default: `2`)

• `worldComm` : the parallel communicator for the mesh (default: `Environment::worldCommPtr()`)

`feelpp.load(m, path, size) → feelpp._mesh.Mesh_S1DG1R1` : load a mesh from a file

• `m` declared with the function `mesh` above

• `path` (`string`) path to the geometry (with `geo` or `msh` format)

• `size` (`float`) size of the meshed geometry (if it is not meshed yet)

Example
``````geo=feelpp.download( "github:{repo:feelpp,path:feelpp/quickstart/laplacian/cases/feelpp2d/feelpp2d.geo}", worldComm=app.worldCommPtr() )[0]
print("geo file: {}".format(geo))
Results
```[ Starting Feel++ ] application myapp version 0.1 date 2022-Nov-07
. myapp files are stored in /scratch/jupyter/feelppdb/np_1
.. logfiles :/scratch/jupyter/feelppdb/np_1/logs
Output exceeds the size limit. Open the full output data in a text editor
Info    : Meshing 1D...
Info    : [  0%] Meshing curve 1 (Line)
Info    : [ 10%] Meshing curve 2 (Line)
Info    : [ 10%] Meshing curve 3 (Line)
Info    : [ 10%] Meshing curve 4 (Line)
Info    : [ 10%] Meshing curve 5 (Line)
Info    : [ 10%] Meshing curve 6 (Line)
Info    : [ 10%] Meshing curve 7 (Line)
Info    : [ 20%] Meshing curve 8 (Line)
Info    : [ 20%] Meshing curve 9 (Line)
Info    : [ 20%] Meshing curve 10 (Line)
Info    : [ 20%] Meshing curve 11 (Line)
Info    : [ 20%] Meshing curve 12 (Line)
Info    : [ 20%] Meshing curve 13 (Line)
Info    : [ 20%] Meshing curve 14 (Line)
Info    : [ 30%] Meshing curve 15 (Line)
Info    : [ 30%] Meshing curve 16 (Line)
Info    : [ 30%] Meshing curve 17 (Line)
Info    : [ 30%] Meshing curve 18 (Line)
Info    : [ 30%] Meshing curve 19 (Line)
...
Info    : Done meshing 2D (Wall 0.106645s, CPU 0.106853s)
Info    : 2867 nodes 5812 elements
Info    : Writing 'feelpp2d.msh'...
Info    : Done writing 'feelpp2d.msh'```

## 2. Usage

The `mesh` provides the Feel++ data structures in Python: The following methods are to use on the mesh object (`mesh` in the previous example) :

### 2.1. Mesh information :

• `dimension(self) → int` : get topological dimension

• `hAverage(self) → float` : get the average edge length of the mesh

• `hMax(self) → float` : get the maximum edge length of the mesh

• `hMin(self) → float` : get the minimum edge length of the mesh

• `measure(self, parallel: bool = True) → float` : get the measure of the mesh (which is equal to $\int_\Omega 1$)

• `measureBoundary(self) → float` : get the measure of the boundary of the mesh (which is equal to $???$)

• `numGlobalEdges(self) → int` : get the number of edges over the whole mesh, requires communication if the mesh is parallel

• `numGlobalElements(self) → int` : get the number of elements over the whole mesh, requires communication if the mesh is parallel

• `numGlobalFaces(self) → int` : get the number of faces over the whole mesh, requires communication if the mesh is parallel

• `numGlobalPoints(self) → int` : get the number of points over the whole mesh, requires communication if the mesh is parallel

• `realDimension(self) → int` : get real dimension

• `updateMeasures(self) → None` : update the measures of the mesh

Here is an example of how to use the mesh information:

Query the mesh information
``````print("dimention: {}".format(mesh.dimension()))
print("number of elements: {}".format(mesh.numGlobalElements()))
print("number of faces: {}".format(mesh.numGlobalFaces()))
print("hmin: {}".format(mesh.hMin()))
print("havg: {}".format(mesh.hAverage()))
print("hmax: {}".format(mesh.hMax()))
print("measure: {}".format(mesh.measure()))
print("measure of boundary: {}".format(mesh.measureBoundary()))``````
Results
```dimention: 2
number of elements: 5134
number of faces: 8006
hmin: 0.0763352613189128
havg: 0.10274873094289755
hmax: 0.13695416558140516
measure: 20.79999999999997
measure of boundary: 1497.0959239128888```

### 2.2. Test relation between meshes :

• `isParentMeshOf(self: feelpp._mesh.Mesh_S3DG1R3, arg0: feelpp._mesh.Mesh_S3DG1R3) → bool` : is the mesh the parent mesh of another mesh

• `isRelatedTo(self: feelpp._mesh.Mesh_S3DG1R3, arg0: feelpp._mesh.Mesh_S3DG1R3) → bool` : is the mesh related to another mesh

• `isSiblingOf(self: feelpp._mesh.Mesh_S3DG1R3, arg0: feelpp._mesh.Mesh_S3DG1R3) → bool`: is the mesh a sibling of another mesh

• `isSubMeshFrom(self: feelpp._mesh.Mesh_S3DG1R3, arg0: feelpp._mesh.Mesh_S3DG1R3) → bool` : is the mesh a sub mesh of another mesh

### 2.3. Export and load mesh on HDF5 format

• `saveHDF5(self, name: str) → None` : save mesh to H5 file

• `loadHDF5(self, name: str) → None` : load mesh from H5 file

``````mesh.saveHDF5("mesh.h5")

## 3. Ranges

• `elements` : `feelpp.elements(mesh)` : get iterator over the elements of the mesh

• `markedelements` :

1. `feelpp.markedelements(mesh, tag: str)` : get iterator over the marked elements of the mesh

2. `feelpp.markedelements(mesh, marker: str)` : return the range of elements of the mesh with marker

3. `feelpp.markedelements(mesh, markers: List[str])` : return the range of elements of the mesh with markers

• `faces` (???)

• `markedfaces` :

1. `feelpp.markedfaces(mesh, marker: str)` : return the range of facets of the mesh with marker

2. `markedfaces(mesh, markers: List[str])` : return the range of facets of the mesh with marker

• `boundaryfaces` : `feelpp.boundaryfaces(mesh)`: get iterator over the boundary faces of the mesh

A first example with ranges:

``````r = feelpp.elements(mesh)
print("mesh elts:", feelpp.nelements(r))
r = feelpp.boundaryfaces(mesh)
print("mesh boundary faces:", feelpp.nelements(r))``````
Results
```mesh elts: 5134
mesh boundary faces: 610```

A second more interesting example with ranges uses integrate to compute integrals of expressions over the mesh:

Example : compute integrals
``````from feelpp.integrate  import integrate

i1 = integrate(range=feelpp.elements(mesh),expr="sin(x+y):x:y")
i2 = integrate(range=feelpp.boundaryfaces(mesh),expr="x*nx+y*ny+z*nz:x:y:z:nx:ny:nz")
i3 = integrate(range=feelpp.markedelements(mesh, "marker"), expr="1")
print("i1 = {}, i2 = {}, i3 = {}".format(i1,i2,i3))``````
Results
`i1 = [3.24282386], i2 = [149.465], i3 = [0.]`