Mesh Elements versus Finite Elements: these two notions are different and should not be misunderstood. A mesh is made of geometric cells, the mesh elements. A finite element is a physical entity, which is supported by a mesh element. In Metafor, this is a two-steps method: first, the mesh is created, then the finite elements are applied to the mesh (this second step is done once the integration is started and programmed in the InteractionSet).

Automatic meshers create nodes and mesh cells from the geometry. Metafor meshers are quite basic but still useful to mesh simple geometries, to avoid using external software.

Basic meshing of Curves can be done with the following command:

 SimpleMesher1D(curve).execute(ne, d=1.0, gencells=False)

with

curve	[Curve]	the curve to be meshed
ne	[int]	number of segments
d	[float]	distribution (ratio between the length of the last and first segments)
gencells	[bool]	generate mesh cells (e.g. for 1D springs)

Likewise, meshing at a higher degree (second or third):

 HighDegreeSimpleMesher1D(curveset(number), degree).execute(ne, d, cells)

Note : The d parameter is used to create segments d times smaller at the beginning of the curve than at its end. Therefore, the curve orientation matters.

The density mesher is used to mesh a line while specifying the length of the desired segment as a function of the curvilinear abscissa. This is done in two steps:

First, a function “mesh element length” is defined, with the reduced curvilinear abscissa as argument ($s\in[0,1]$).

def ellength(s):
    return 0.1+(s-0.5)*(s-0.5)
ellength = PythonOneParameterFunction(ellength)

Second, the density mesher is created on curve #1.

mesher = DensityMesher1D(curveset(1), ellength)
mesher.setDeltaI(0.001)      # internal integration parameter
mesher.execute(False)

The parameter False, passed to execute, is used to generate only nodes, and not segments. This is important to be consistent with 2D meshing and for defo-defo contact.

The way to create a grid of $n$ intervals on a curve starts with specifying the distribution of points on this curve. This is done by specifying the distribution of the curve parameter ${u(\xi) \; 0 \leq \xi \leq n+1}$ in the parametric domain, corresponding to the points of the curve ${\boldsymbol{x}(u) \; 0 \leq u \leq 1}$ in the physical domain. The final task is to specify ${u(\xi) \; 0 \leq \xi \leq n+1}$ such as ${\boldsymbol{x}(u(\xi)) \; 0 \leq \xi \leq n+1}$ is a good parametrization of the curve $\boldsymbol{x}(u)$.

Finding the function $u(\xi)$ is equivalent to finding the function $\xi(u)$. With the definition $\rho(u) = \frac{d\xi}{du}$, it leads to:

$$ \xi(u) = \int_0^u \rho(w) dw. $$

In the hydrid case, the construction of the grid points density function $\rho(u)$ requires more complex physical considerations. Several approaches exist:

• A uniform distribution of the arc length, where grid points are separated by equal distances in the physical domain. In this case, the grid points density function must be proportional to the arc length change rate: $$\rho(u) \propto \left\| \frac{d\boldsymbol{x}}{du} \right\| $$
• A uniform distribution of the arc length weighted by the curvature, where grid points are concentrated in areas with greater curvature. In this case, the grid points density function is written as: $$\rho(u) \propto \kappa(u) \left\| \frac{d\boldsymbol{x}}{du} \right\| $$ where $\kappa(u)$ is the curvature of the curve $\boldsymbol{x}$, in $u$.
• An attraction of the grid towards an attraction point $u^{*}$ in the parametric domain (which corresponds to the point $\boldsymbol{x}^{*} = \boldsymbol{x}(u^{*})$ in the physical domain). A usual possibility is $u^{*}=0$ or $u^{*}=1$, when a very small scale is desired at one end of the curve. Alternatively, $0< u^* < 1$ will focus the refining near a point inside the curve.
  For these cases, a proper choice for $\rho(u)$ is :
  $$ \rho_{u^{*}} (u) \propto \frac{1}{\sqrt{(k (u-u^{*}))^2 +1} } $$ where $k$ is an attraction factor which determines the intensity of the attraction towards $u^{*}$.

In practice, it is likely that the user wishes for an hybrid grid points density function, so a linear combination of several functions described above. These functions $\rho_i(u)$ can be combined, each one being normalized such as $\int_0^1 \rho_i(u) \, du = \xi(1)-\xi(0) = m$. Introducing the positive constants $\lambda_i$ such as $\sum_i \lambda_i=1$, the normalized hybrid density function $\rho(u)$ is defined as: $$\rho(u) = \sum_i \lambda_i \rho_i(u)$$ This hybrid density function migrates the grid points towards every area where a function $\rho_i(u)$ requires refining. Using this concept, it is possible to allocate grid points based on hybrid criteria of arc length, curvature and attraction towards a set of distinct points ${u_i^*}$.

Finally, supplying:

• the weights $\lambda_s$ and $\lambda_{\kappa}$,
• the points $\{u_i^* \; | \; 0 \leq u_i^* \leq 1, \; 1 \leq i \leq p\}$,
• the weights $\{\lambda_i, \; 1 \leq i \leq p\}$,
• the attraction factors $\{k_i, \; 1 \leq i \leq p\}$

where $\lambda_s+\lambda_{\kappa}+\sum_{i=1}^p \lambda_i =1$, a distribution of $n+1$ points $u_0, u_1, \ldots, u_{n+1}$ is generated, where these points are simultaneously:

• of a higher density close to the attraction points $\{u_i^*\}$,
• positioned in areas where the curvature is large,
• positioned to avoid large differences on the arc length.

In Metafor, the mesher HybridDensityMesher1D is interfaced as:

Mesher = HybridDensityMesher1D(curveset(number),p)                              
Mesher.execute(n,lambdaS,lambdaK,cells)

To concentrate some mesh elements towards an attraction point, the follwoing command can be used before the .execute() operation:

Mesher.pushAttractorPt(uJ)
Mesher.pushWeight(lambdaJ)
Mesher.pushStrength(kJ)

Generating cells is only useful if you plan to define 1D elements (such as springs) in your model.

To manually create a 1D cell based on two mesh points,

mesh.define(no, CELL_LINE, grp, no1, no2)

The CellLineMesher is used to generate a series of 1D cells linking two sets of mesh points.

The CellLineMesher is a mesher which, based on two meshed geometric entities, generates objects of CELL_LINE type. Every mesh point of the first entity will be linked by a CELL_LINE to every MeshPoint of the second entity.

The interaction generated on these CELL_LINE will be defined by the first geometric entity passed to the CellLineMesher.

Example:

Generation of CELL_LINE on two sets of mesh points (coming from a Bacon import for example)

mesher = CellLineMesher(groupset(no1), groupset(no2)) 
mesher.execute()
...
app = FieldApplicator(no)
app.push(groupset(no1))   # Definition of the element on the first 
                          # ''CellLineMesher'' entity