Documentation.

Application overview

The RobustMesh010 application environment provides the main commands used to access documentation, version information, account login and license status. These controls are separate from the scientific meshing workflow.

Shell commands

Login

Use login to sign in with the email address and password associated with your RobustMesh Alpha account.

RobustMesh010> login
Email: user@example.com
Password: [hidden]

Once connected, the session is stored locally so you do not need to sign in again every time RobustMesh010 starts.

License status

Use license to check the license associated with the currently connected account, including its current status and expiry information when available.

RobustMesh010> license

If no user is connected, RobustMesh010 reports that no license is currently loaded.

Logout

Use logout to disconnect the current user and remove the local session. A new login will be required to start another authenticated session.

RobustMesh010> logout

Version

Use version to display information about the installed RobustMesh version.

RobustMesh010> version

Documentation

Use doc to access the RobustMesh documentation directly from the application.

RobustMesh010> doc

Exit RobustMesh010

Use exit or Ctrl+C to leave the RobustMesh010 environment.

RobustMesh010> exit

generateMesh2D

Use generateMesh2D to run the meshing pipeline. The three options are optional. Without -p, RobustMesh reads the default path system/robustMeshDict. Without -o, it searches the computer for the most recent installed OpenFOAM version.

Usage

generateMesh2D [--interactive] [--path <system/robustMeshDict>] [--openfoam <name>]

Options

All three options below are optional.

generateMesh2D overview

generateMesh2D builds a 2D OpenFOAM-ready mesh from three user-controlled input groups. Geometry defines the contours, fluid_boundaries_parameters controls boundary-level meshing behaviour, and robustMeshDict controls the global meshing pipeline and export.

Quick start

For a standard case, place the three input groups in the recommended locations, start the RobustMesh environment from the case directory, then run generateMesh2D.

$ cd /path/to/myCase
$ RobustMesh010
RobustMesh010> generateMesh2D

The default command reads system/robustMeshDict. Use interactive mode when you want to inspect intermediate states, rerun individual stages or export temporary meshes for ParaView and checkMesh.

RobustMesh010> generateMesh2D --interactive

Recommended case layout

myCase/
├── 0/                                  # Solver boundary conditions
├── constant/
│   ├── geometry/                       # RobustMesh geometry inputs
│   │   ├── boundaries.dat
│   │   └── body.dat
│   ├── fluid_boundaries_parameters     # Boundary-level meshing controls
│   └── polyMesh/                       # Generated OpenFOAM mesh
└── system/
    ├── robustMeshDict                  # Global RobustMesh configuration
    ├── controlDict                     # Used by checkMesh / OpenFOAM
    ├── fvSchemes                       # Used by checkMesh / OpenFOAM
    └── fvSolution                      # Used by checkMesh / OpenFOAM

Paths inside robustMeshDict are interpreted relative to the directory containing that dictionary. controlDict, fvSchemes and fvSolution are not mesh-generation inputs; they are only required when the interactive workflow launches checkMesh.

Meshing pipeline

The same pipeline is used in automatic and interactive mode. Interactive mode exposes the intermediate states without changing the underlying meshing stages.

Geometry files

Each .dat file contains exactly one closed 2D contour. Each useful line contains two finite coordinates:

x y

Clockwise outer-boundary example

-2.2  5.0
10.0  5.0
10.0 -5.0
-2.2 -5.0

Domain boundary and fluid orientation

The order of the points tells RobustMesh which side of a contour contains the fluid. When writing a .dat file by hand, list the points in the order you would trace the contour with a pen: clockwise for an outer domain, and counter-clockwise for a solid object inside it.

The geometry directory must contain at least one clockwise contour. Without one, RobustMesh has no domain to fill and stops before generating the mesh. Several clockwise contours are allowed when the outer domain contains multiple disjoint parts.

fluid_boundaries_parameters

fluid_boundaries_parameters assigns CFD meaning to each contour, selected points and selected segment ranges. The file must define the two global default blocks shown below; it cannot be loaded without them.

Top-level structure

segment_defaults { ... }   // required
point_defaults   { ... }   // required; all three fields must be set
geometry_files   { ... }   // optional
point_junctions  { ... }   // optional

A geometry omitted from geometry_files inherits the global segment_defaults and point_defaults blocks.

segment_defaults

This block defines the CFD and meshing parameters applied to segments. The global block is required, but values may be completed or replaced at geometry and segment level.

A segment with patch_type patch always forces resample false and prismatic_layer_extract false, regardless of the configured values. Use patch for far-field, inlet or outlet segments that need no mesh control. Use wall whenever resampling or prismatic layers are required.

point_defaults

The global point_defaults block is mandatory and must set all three fields:

point_defaults
{
    min_angle_corner   30;
    min_angle_concave  45;
    min_angle_fan      180;
}

Values are expressed in degrees. Use -1 to disable a test. Otherwise, min_angle_corner and min_angle_concave must be in [0, 180], while min_angle_fan must be in [0, 360]. RobustMesh compares each vertex's local turning angle with these thresholds to mark it as a corner, concave point or fan. These flags determine whether the resampler pins the point or allows it to move. A fan flag is automatically cleared unless both adjacent segments use patch_type wall.

segments_overrides

Segment overrides belong to a geometry and target inclusive edge-index ranges in the original .dat point order, before resampling.

geometry_files
{
    airfoil
    {
        segment_defaults { ... }
        segments_overrides
        {
            (0 0)   { patch_name airfoilLeadingEdge; }
            (12 20) { prismatic_layer_extract false; }
        }
    }
}

• Edge k runs from points[k] to points[(k + 1) % n].
• (i0 i1) includes both endpoints; (i0) is shorthand for (i0 i0).
• Any segment_defaults field may be set inside an override. Other fields continue to inherit their effective values.
• If ranges overlap, the first range declared in the file wins for the shared edge. Overlap is not reported as an error.
• Out-of-range indices are accepted while parsing and simply match no edge.

point_overrides

Point overrides are available only inside a geometry and use indices from that geometry's original .dat file.

geometry_files
{
    airfoil
    {
        point_overrides
        {
            0 { corner true; }
            5 { keep_in_resample true; concave false; }
        }
    }
}

The fields corner, concave and fan replace angle-based detection for that point. keep_in_resample pins it as a resampling anchor even when no shape flag is active. corner false cannot be combined with concave true or fan true, and a point cannot have both concave true and fan true.

point_junctions

The optional global point_junctions block controls the shape flags created where two different source geometries intersect or touch and are boolean-unioned.

point_junctions
{
    (left middle) { corner true; }
}

Each key is an unordered pair of geometry names. Use it to override angle-based classification at the point where edges from the merged geometries meet.

Precedence

Each field is resolved independently, from highest to lowest priority:

1. A matching segments_overrides range or point_overrides entry.
2. The geometry's own segment_defaults or point_defaults.
3. The global top-level segment_defaults or point_defaults.

Complete example

segment_defaults
{
    patch_type                  wall;
    resample                    false;
    prismatic_layer_extract     false;
}

point_defaults
{
    min_angle_corner   30;
    min_angle_concave  45;
    min_angle_fan      180;
}

geometry_files
{
    airfoil
    {
        segment_defaults
        {
            patch_name                  airfoilWall;
            resample                    true;
            s_min                       0.0002;
            s_max                       0.005;
            dtheta_max                  15.0;
            prismatic_layer_extract     true;
            n_layer                     25;
            thickness_first_layer       0.00001;
            expansion_ratio             1.12;
        }
    }

    boundaries
    {
        segment_defaults { patch_type patch; }
        segments_overrides
        {
            (0 0) { patch_name inlet; }
            (1 1) { patch_name outlet; }
        }
    }
}

In this example, boundaries.dat must be clockwise and airfoil.dat counter-clockwise. The parameter file does not assign those roles; the orientation of each geometry does.

robustMeshDict

The main dictionary defines the input paths, near-wall extraction controls, central triangle mesh sizing and OpenFOAM export settings. It contains six top-level sections. general is optional; the other five sections, including resample, are required.

general
{
    verbose         true;
}

create_fluid_boundaries
{
    verbose                             true;
    path_folder_geometry                "../constant/geometry";
    path_fluid_boundaries_parameters    "../constant/fluid_boundaries_parameters";
}

resample
{
    verbose         true;
}

extract_prismatic_layer
{
    verbose                     true;
    n_ortho_layer               5;
    patch_junction_angle        10.0;
    gap_factor                  1.0;
}

core_mesh_generation
{
    verbose             true;
    core_mesh_type      triangle;

    triangle_core
    {
        verbose         true;
        edge_size_max   0.7;
        growth_ratio    1.2;

        size_zones
        {
            near_wake
            {
                edge_size_max   0.05;
                polygon
                (
                    (0.5 -0.5)
                    (6.0 -0.5)
                    (6.0  0.5)
                    (0.5  0.5)
                );
            }
        }
    }
}

export_to_openfoam_2d
{
    verbose             true;
    path_of_polyMesh    "../constant";
    z_length            1.0;
    scale               1.0;
    front_patch_name    front;
    back_patch_name     back;
}

general

This optional section accepts only verbose, a Boolean that defaults to true. Other sections inherit general.verbose when their own value is omitted. If general is absent, the fallback is true.

create_fluid_boundaries

This section accepts exactly three parameters. All three are optional because each has a default or inherited value.

resample

The resample section is required in robustMeshDict, but all of its parameters are optional.

extract_prismatic_layer

The extract_prismatic_layer section is required in robustMeshDict. The n_ortho_layer parameter is required; all other parameters are optional.

core_mesh_generation

The core_mesh_generation section is required in robustMeshDict, but all of its parameters are optional.

triangle_core

size_zones

size_zones may be empty and may contain multiple zones with different names. Every entry inside size_zones is a user-defined zone name containing exactly the following parameters.

export_to_openfoam_2d

The export_to_openfoam_2d section is required in robustMeshDict, but all of its parameters are optional.

Interactive mode

Controls

In interactive mode, use CC to run a comprehensive mesh check with:

checkMesh -allGeometry -allTopol

Recomputing a step invalidates that step and all states that depend on it. After a configuration change, rerun from the modified stage before producing the final export.

Validation

ParaView inspection

Check contour placement, requested near-wall layers, leading/trailing-edge resolution, narrow gaps, mesh-size progression and coverage of refinement zones.

checkMesh

Interactive checkMesh requires a detected OpenFOAM environment, the checkMesh executable, and system/controlDict, system/fvSchemes and system/fvSolution in the case.

$ checkMesh -case /path/to/myCase

Before running a solver, verify the exported patch names and types, map them to the boundary conditions in 0/, confirm units after scale, and confirm the 2D front/back setup.