cfMesh short introduction

This document contains pieces of advice for using the automatic mesh generation tool cfMesh.
Answers to frequently asked questions are given and the settings explained using the example
(tutorial) provided by the Faculty of Mechanical Engineering and Naval Architecture, University of
Zagreb. It is recommended to read and study the cfMesh User Guide for any additional information.

What is cfMesh?
cfMesh is an automatic mesh generation tool compatible with all recent versions of
OpenFOAM and foam-extend. It supports various 3D and 2D workflows, built by using
components from the main library. These components can be combined to achieve various
meshing workflows.

What are the meshing workflows?

Meshing workflows start the meshing process by creating a mesh template from the input
geometry and the user-specified settings. The template is later on adjusted to match the input
geometry. The process of fitting the template to the input geometry is designed to be tolerant
to poor quality input data, which does not need to be watertight. The available workflows
differ by the type of cells generated in the template: Cartesian, 2D Cartesian and Tetrahedral.
Meshing workflows implemented in cfMesh are based on the inside-out meshing, and the
meshing process starts by generating the so-called mesh template based on the user specified
cell size. However, if the cell size is locally larger than the geometry feature size it may
result with gaps in the geometry being filled by the mesh. On the contrary, the mesh in thin
parts of the geometry can be lost if the specified cell size is larger than the local feature size.

What is Cartesian workflow?

Cartesian workflow generates 3D meshes consisting of predominantly hexahedral cells with
polyhedra in the transition regions between the cells of different size. That's why transition
areas sometimes look ugly. It is started by typing cartesianMesh in a shell window. By
default, it generates one boundary layer, which can be further refined on user request.

What is 2D Cartesian workflow?

It generates 2D meshes and is started by typing cartesian2DMesh in the console. By default
it generates one boundary layer which can be further refined.

What is Tetrahedral workflow?

Tetrahedral workflow generates meshes consisting of tetrahedral cells and is started by
typing tetMesh in a console. By default, it does not generate any boundary layers, and they
can be added and refined on user request.

Which format of input geometry does cfMesh require?

cfMesh requires geometries in the form of a surface triangulation. The file formats
suggested for meshing are: fms, ftr, and stl. These formats support definition of patches,
while other formats do not support definition of patches in the input geometry and all faces

in the boundary of the resulting volume mesh end up in a single patch. In addition, the
geometry can be imported in all formats supported by the surfaceConvert utility, which
comes with OpenFOAM. cfMesh also provides additional utilities for conversion of surface
mesh into fms and from fms to other formats (list of useful utilities is below). The preferred
format for cfMesh is fms, designed to hold all relevant information for setting up a meshing
job. It stores patches, subsets, and feature edges in a single file. In addition, it is the only
format, which can store all geometric entities into a single file, and the users are strongly
encouraged to use it.

What are the dictionaries required for running cfMesh?

The meshing process is steered by the settings provided in a meshDict dictionary located in
the system directory of the case. For parallel meshing using MPI, a decomposeParDict
located in the system directory of a case is required, and the number of nodes used for the
parallel run must match the numberOfSubdomains entry in decomposeParDict. Other entries
in decomposeParDict are not required. The resulting volume mesh is written in the
polyMesh directory inside the constant directory.

What are the mandatory settings in meshDict dictionary?

surfaceFile - points to a geometry file. The path to the geometry file is relative to the path of
the case directory.
maxCellSize - represents the default cell size used for the meshing job. It is the maximum cell size
generated in the domain.
What are the refinement settings defined in meshDict dictionary?
boundaryCellSize - used for refinement of cells at the boundary. It is a global option and the
requested cell size is applied everywhere at the boundary.
boundaryCellSizeRefinementThickness - specifies the distance from the boundary at which the
boundaryCellSize is still applied.
minCellSize - global option which activates automatic refinement of the mesh template. This option
performs refinement in regions where the cells are larger than the estimated feature size. The scalar
value provided with this setting, specifies the smallest cell size allowed by this procedure.
localRefinement - allows for local refinement regions at the boundary. It is a dictionary of
dictionaries and each dictionary inside the main localRefinement dictionary is named by a patch or
facet subset in the geometry that is used for refinement:
cellSize - for controlling requested cell size.
additionalRefinementLevels - defines the desired number of refinements relative to
the maximum cell size.
refinementThickness - specifies the thickness of the refinement zone.
objectRefinement - for specifying refinement zones inside the volume. The supported objects
that can be used for refinement are: lines, spheres, boxes, and truncated cones.
Each dictionary inside the objectRefinement dictionary represents the name of the
object used for refinement.
refinementThickness - used to specify the thickness of the refinement zone away
from the object.
surfaceMeshRefinement - for using surface meshes as refinement zones in the mesh.

Each refinement zone is a sub-dictionary inside the surfaceMeshRefinement

dictionary. Surface mesh used for the refinement zone is provided with the
surfaceFile keyword.
Requested cell size for an entity is controlled by the cellSize keyword and a
scalar value, or by specifying additionalRefinementLevels keyword and the
desired number of refinements relative to the maximum cell size.
It is possible to control the thickness of the refinement zone via
refinementThickness keyword.
Is it possible to keep/remove cells?
By default, all meshing workflows keep only cells in the template which are completely inside the
geometry.
keepCellsIntersectingBoundary - global option which ensures that all cells in the template which are
intersected by the boundary remain part of the template. The keyword must be followed by either 1
(active) or 0 (inactive).
Activation of this option can cause locally connected mesh over a gap, and the problem can be
remedied by the checkForGluedMesh option which also must be followed by either 1 (active) or 0
(inactive).
keepCellsIntersectingPatches - option which preserves cells in the template in the regions specified
by the user - each dictionary inside is named by patch or facet subset. This option is not active when
the keepCellsIntersectingBoundaryoption is switched on.
removeCellsIntersectingPatches - option which removes cells from the template in the regions
specified by the user - each dictionary inside is named by a patch or a facet subset. The option is
active when thekeepCellsIntersectingBoundary option is switched on.
What are the possibilities of manipulating the boundary layer?
Boundary layers in cfMesh are extruded from the boundary faces of the volume mesh towards the
interior, and cannot be extruded prior to the meshing process.
Boundary layer thickness is controlled by the cell size specified at the boundary and the mesher
tends to produce layers of similar thickness to the cell size.
Layers can span over multiple patches if they share concave edges or corners with valence greater
than three.
All boundary layer settings are provided inside a boundaryLayers dictionary:
nLayers - specifies the number of layers which will be generated in the mesh. In case it is not
specified the meshing workflow generates the default number of layers, which is either one or zero.
thicknessRatio - ratio between the thickness of the two successive layer. The ratio must be larger
than 1. The default value is 1.
maxFirstLayerThickness - ensures that the thickness of the first boundary layer never
exceeds the specified value.
patchBoundaryLayers - dictionary which is used for specifying local properties of boundary
layers for individual patches.
It is possible to specify nLayers, thicknessRatio and maxFirstLayerThickness for
each patch individually within a dictionary with the name equal to the patch name.
allowDiscontinuity - ensures that the number of layers required for a patch shall not
spread to other patches in the same layer.
What are the utilities included in cfMesh?

The list of utilities is given in the table:

Command
copySurfaceParts
extrudeEdgesInto2DSurface

FLMAToSurface
FMSToSurface
FMSToVTK
FPMAToMesh
importSurfaceAsSubset

improveSymmetryPlanes

mergeSurfacePatches
meshToFPMAposition
patchesToSubsets
preparePar

removeSurfaceFacets
subsetToPatch

surfaceFeatureEdges

surfaceGenerateBoundingBox
surfaceToFMS

Description
It copies surface facets in a specified facet subset into a new
surface mesh.
This utility extrudes edges written as feature edges in the
geometry into a ribbon of triangles required for 2D mesh
generation. Generated triangles are stored in a single patch.
It converts geometry from AVL's flma format into the format
readable by cfMesh. Cell selections defined in the input file are
transferred as facet subsets.
The utility converts the data in a fms file into several files which
can be imported into ParaView.
Converts fms file into ParaViews vtm file, containing all data
available in an fms file.
Is a utility for importing volume meshes from AVL's fpma format.
Selections defined on the input mesh are transferred as subsets.
The utility matches the triangles of the surface mesh used for
meshing with the other other surface, and create a facet subset in
the original surface.
OpenFOAM is very sensitive to the position of points in the
symmetry plane. This utility calculates the regression plane for all
vertices belonging to a symmetry plane, and ensures that all
vertices lie in a plane.
The utility allow the user to specify the patches in the surface
mesh which shall be merged together.
This utility converts the mesh into the AVL's fpma format.
It converts patches in the geometry into facet subsets.
It creates processor directories required for MPI parallelisation.
The number of processor directories is dependent on the
numberOfSubdmains specified indecomposeParDict.
It is a utility for removing facets from the surface mesh. The
facets that shall be removed are given by a patch name or a facet
subset.
It creates a patch in the surface mesh consisting of facets in the
given facet subset.
It is used for generating feature edges in the geometry. In case the
output is a fms file, generated edges are stored as feature edges.
Otherwise it generates patches bounded by the selected feature
edges.
It generates a box around the geometry. It does not resolve selfintersections in case the box intersects with the rest of the
geometry.
A converter from common surface triangulation formats into fms.

Ship tutorial
meshDict overview:

1. The geometry is specified: surfaceFile geom.stl;

2. Maximal cell size that can appear in the domain is specified: maxCellSize 3;
3. There is a refinement region around the hull of the ship defined:
localRefinement
{
hull
{
cellSize 0.02;
}
}
4. There are two refinement boxes defined:
objectRefinements
{
waterSurfaceOuter
{
cellSize 0.2;
type box;
centre (0 0 0);
lengthX 100;
lengthY 10;
lengthZ 0.1;
}
waterSurfaceInner
{
cellSize 0.02;
type box;
centre (0 0 0);
lengthX 15;
lengthY 8;
lengthZ 0.012;
}
}
5. The boundary layer settings are prescribed for specific patches:
boundaryLayers
{
patchBoundaryLayers
{
hull
{
nLayers 5;
thicknessRatio 1.2;
maxFirstLayerThickness 0.0005;
allowDiscontinuity 0;
}
}
}
6. It is possible to rename and/or specify the type of patches in renameBoundary dictionary:
renameBoundary

{
newPatchNames
{
hull
{
newName hull;
type wall;
}
inlet
{
newName inlet;
type patch;
}
outlet
{
newName outlet;
type patch;
}
top
{
newName top;
type patch;
}
bottom
{
newName bottom;
type patch;
}
farfield
{
newName farfield;
type patch;
}
symmetry
{
newName symmetry;
type symmetry;
}
}
}

Pieces of advice found useful by previous beginners:

If there is an STL geometry, a bounding box can be made by using surfaceGenerateBoundingBox

and specifying names of input and output surface files, and then offset from the surface in x-neg, xpos, y-neg, y-pos, z-neg, z-pos directions.
It is suggested to define the mesh in the following order:
1. localRefinement - local refinement regions at the boundary. The refinement is defined for desired
patches by specifying cellSize or additionalRefinementLevels relative to the maximum cell size
(maxCellSize).
2. objectRefinements - refinement zones inside the volume (lines, spheres, boxes, cones). It is a
dictionaryobjectRefinement in which the names and properties of refinement objects are defined.
Useful feature for refining certain zones of your domain (eg. around the geometry).
3. boundaryLayers - boundary layers are extruded from the boundary faces of the volume mesh
towards the interior and CANNOT be extruded PRIOR to the meshing process (sometimes this
causes your boundary layers to disappear). For more details look into the User Guide.
Defining the mesh in this order will probably produce the best looking cells. If the mesh still looks
nasty, try changing refinement settings until it looks better.