# Metafor

ULiege - Aerospace & Mechanical Engineering

### Site Tools

doc:user:geometry:mesh:1d

This is an old revision of the document!

﻿

# 1D Meshers

## MeshedPoints

### Simple mesher - SimpleMesher1D

Automatic meshers create mesh elements from the geometry. Metafor meshers are quite basic but still useful to mesh simple geometries, to avoid using external softwares.

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).

Meshing lines is done with the command:

 SimpleMesher1D(curveset(number)).execute(ne, d, cells)
 number number of the line to be meshed ne number of segments d distribution (ratio between the length of the last and first segments) - [default=1.0] cells Boolean which governs whether 1D meshed elements should be generated [default=False]

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

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

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

### Density mesher - DensityMesher1D

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.

#### HybridDensityMesher1D

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)
 number number of the curve to be meshed p number of attraction points - [default=0] n number of segments lambdaS weight of the uniform arc length distribution criterion - [default=1.0] lambdaK weight of the uniform arc length distribution weighted by the curvature criterion - [default=0.0] cells generated mesh elements in addition to nodes [default=False]

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)
 uJ value of the $u$ parameter corresponding to the attraction point lambdaJ weight associated to the attraction point kJ attraction factor

## 1D Mesh elements

### 1D mesh elements : manually

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

mesh.define(no, CELL_LINE, grp, no1, no2)
 no number of the 1D mesh element grp entity which will contain the mesh element (for example a Group) no1 number of the first mesh point no2 number of the second mesh point

### 1D mesh elements : CellLineMesher

The CellLineMesher can also generate a 1D mesh element based on two sets of mesh points.

The CellLineMesher is a mesher which, based on two meshed geometric entities, generates objects of CELL_LINE type in the topology. Every MeshPoint 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