Python classes for easier creation of OpenFOAM's blockMesh dictionaries.

Warning! This project is currently under development and is not yet very user-friendly. It still lacks some important features and probably features a lot of bugs. However, you're welcome to suggest features, improvements, and point out bugs.

Note: version 1.0.0 introduces backwards-incompatible changes in API. Use latest 0.0.1 commit for your old scripts. However, you might want to give the new version a try...

blockMesh is a very powerful mesher but the amount of manual labour it requires to make even the simplest meshes makes it mostly useless. Even attempts to simplify or parametrize blockMeshDicts with #calc or even the dreadful m4 quickly become unmanageable and cryptic.

classy_blocks' aim is to minimize the amount of meticulous work by providing a more intuitive workflow, off-the-shelf parts and some automatic helpers for building and optimization of block-structured hexahedral meshes. Still it is not an automatic mesher and therefore some kinds of geometry are more suited than others.

• Turbomachinery (impellers, propellers)
• Microfluidics
• Flow around buildings
• Heat transfer (PCB models, heatsinks)
• Airfoils (2D)
• Solids (heat transfer, mechanical stresses)

• Simpler rotational geometry (immersed rotors, mixers)
• Pipes/channels
• Tanks/plenums/containers
• External aerodynamics of blunt bodies
• Modeling thin geometry (seals, labyrinths)
• Parametric studies
• Background meshes for snappy (cylindrical, custom)
• 2D and axisymmetric cases
• Overset meshes

• External aerodynamics of vehicles (too complex to mesh manually, without refinement generates too many cells)
• Complex geometry in general
• One-off simulations (use automatic meshers)

• If you just need the classy_blocks, install them with: pip install git+https://github.com/damogranlabs/classy_blocks.git
• If you want to run examples, follow instructions in Examples
• If you want to contribute, follow instructions in CONTRIBUTING.md

As opposed to blockMesh, where the user is expected to manually enter pre-calculated vertices, edges, blocks and whatnot, classy_blocks tries to mimic procedural modeling of modern 3D CAD programs. Here, a Python script contains steps that describe geometry of blocks, their cell count, grading, patches and so on. At the end, the procedure is translated directly to blockMeshDict and no manual editing of the latter should be required.

Unchecked items are not implemented yet but are on a TODO list

• Manual definition of a Block with Vertices, Edges and Faces
• Operations (Loft, Extrude, Revolve)
  • Loft
  • Extrude
  • Revolve
  • Wedge (a shortcut to Revolve for 2D axisymmetric cases)
• Predefined Shapes
  • Box (shortcut to Block aligned with coordinate system)
  • Elbow (bent pipe of various diameters/cross-sections)
  • Cone Frustum (truncated cone)
  • Cylinder
  • Ring (annulus)
  • Hemisphere
  • Elbow wall (thickened shell of an Elbow)¹
  • Frustum wall¹
  • Hemisphere wall¹
• Predefined parametric Objects
  • T-joint (round pipes)
  • X-joint
  • N-joint (multiple pipes)
  • Box with hole (radial)
  • Box with hole (cartesian)
• Other building tools
  • Use existing Operation's Face to generate a new Operation
  • Chain Shape's start/end surface to generate a new Shape
  • Expand Shape's outer surface to generate a new Shape (Cylinder/Annulus > Annulus)
  • Contract Shape's inner surface into a new Shape (Annulus > Cylinder/Annulus)
  • Join two Operations by extending their Edges
  • Offset Operation's faces to form new ones¹

After blocks have been placed, it is possible to create new geometry based on placed blocks or to modify them.

• Move Vertex/Edge/Face
• Delete a Block created by a Shape or Object
• Project Vertex/Edge/Face
• Optimize Vertex positions

• Simple definition of all supported kinds of edges with a dedicated class (Arc/Origin/Angle/Spline/PolyLine/Project)
• Automatic calculation of cell count and grading by specifying any of a number of parameters (cell-to-cell expansion ratio, start cell width, end cell width, total expansion ratio)
• Edge grading (separate specification for each edge)
• Automatic propagation of grading and cell count from a single block to all connected blocks as required by blockMesh
• Projections of vertices, edges and block faces to geometry (triangulated and searchable surfaces)
• Face merging as described by blockMesh user guide. Breaks the pure-hexahedral-mesh rule but can often save the day for trickier geometries. Automatic duplication of points on merged block faces
• Auto grading for Low-Re meshes: boundary layer with specified cell-to-cell expansion, transition with 2:1 expansion, and specified 'bulk' cell size

How to run:

• Install classy_blocks as described in (# How To Use It)
• cd to directory of the chosen example
• Run python <example.py>; that will write blockMeshDict to examples/case
• Run blockMesh on the case
• Open examples/case/case.foam in paraview to view the result

For instance:

cd examples/chaining
python tank.py
blockMesh -case ../case

A simple Cylinder:

inlet = cb.Cylinder([x_start, 0, 0], [x_end, 0, 0], [0, 0, radius])
inlet.chop_radial(count=n_cells_radial, end_size=boundary_layer_thickness)
inlet.chop_axial(start_size=axial_cell_size, end_size=2*axial_cell_size)
inlet.chop_tangential(count=n_cells_tangential)

inlet.set_start_patch('inlet')
inlet.set_outer_patch('wall')
inlet.set_end_patch('outlet')
mesh.add(inlet)

See examples/shape for use of each shape and examples/complex for a more real-life example usage of shapes.

Analogous to a sketch in 3D CAD software, a Face is a set of 4 vertices and 4 edges. An Operation is a 3D shape obtained by swiping a Face into 3rd dimension by a specified rule; an example of Revolve:

# a quadrangle with one curved side
base = cb.Face(
    [ # quad vertices
        [0, 0, 0],
        [1, 0, 0],
        [1, 1, 0],
        [0, 1, 0]
    ],
    [ # edges: None specifies straight edge
        cb.Arc([0.5, -0.2, 0]),
        None,
        None,
        None
  ]
)

revolve = cb.Revolve(
    base, # face to revolve
    f.deg2rad(45), # revolve angle
    [0, -1, 0], # axis
    [-2, 0, 0]  # origin
)

revolve.chop(0, count=15) # first edge
revolve.chop(1, count=15) # second edge
revolve.chop(2, start_size=0.05) # revolve direction
mesh.add(revolve)

See examples/operations for an example of each operation.

Any geometry that snappyHexMesh understands is also supported by blockMesh. That includes searchable surfaces such as spheres and cylinders and triangulated surfaces.

Projecting a block side to a geometry is straightforward; edges, however, can be projected to a single geometry (will 'snap' to the closest point) or to an intersection of two surfaces, which will define it exactly.

Geometry is specified as a simple dictionary of strings and is thrown in blockMeshDict exactly as provided by the user.

geometry = {
    'terrain': [
        'type triSurfaceMesh',
        'name terrain',
        'file "terrain.stl"',
    ],
    'left_wall': [
        'type       searchablePlane',
        'planeType  pointAndNormal',
        'point      (-1 0 0)',
        'normal     (1  0  0)',
    ]
}

box = cb.Box([-1., -1., -1.], [1., 1., 1.])
box.project_side('bottom', 'terrain')
box.project_edge(0, 1, 'terrain')
box.project_edge(3, 0, ['terrain', 'left_wall'])

Simply provide names of patches to be merged and call mesh.merge_patches(<master>, <slave>). classy_blocks will take care of point duplication and whatnot.

box = cb.Box([-0.5, -0.5, 0], [0.5, 0.5, 1])
for i in range(3):
    box.chop(i, count=25)
box.set_patch('top', 'box_top')
mesh.add(box)

cylinder = cb.Cylinder(
    [0, 0, 1],
    [0, 0, 2],
    [0.25, 0, 1]
)
cylinder.chop_axial(count=10)
cylinder.chop_radial(count=10)
cylinder.chop_tangential(count=20)

cylinder.set_bottom_patch('cylinder_bottom')
mesh.add(cylinder)

mesh.merge_patches('box_top', 'cylinder_bottom')

Useful for Shapes, mostly for piping and rotational geometry; An existing Shape's start or end sketch can be reused as a starting sketch for a new Shape, as long as they are compatible. For instance, an Elbow can be chained to a Cylinder just like joining pipes in plumbing.

Moreover, most shapes* can be expanded to form a wall version of the same shape. For instance, expanding a Cylinder creates an ExtrudedRing.

See examples/chaining for an example of each operation.

By default, a debug.vtk file is created where each block represents a hexahedral cell. By showing block_ids with a proper color scale the blocking can be visualized. This is useful when blockMesh fails with errors reporting invalid/inside-out blocks but VTK will happily show anything.

These are some screenshots of parametric models, built with classy_blocks.

Rectangular ducts (Extrude and Revolve Operations)

3D pipes with twists and turns (chained Elbow and Cylinder Shapes)

A simple tank with rounded edges

A flywheel in a case. VTK Blocking output for debug is shown in the middle

Venturi tube

2D mesh for studying Karman Vortex Street

Helmholtz nozzle, a resonator with sharp edges. See this sketch.

Edges and faces, projected to an STL surface

Mesh for studying flow around a sphere, with projected edges and faces

A parametric, Low-Re mesh of a real-life impeller (not included in examples)

Package (python) dependencies can be found in pyproject.toml file. Other dependencies that must be installed:

• python3.7 and higher
• OpenFoam: .org or .com version is supported, foam-extend's blockMesh doesn't support multigrading but is otherwise also compatible.

There's no official documentation yet so here are some tips for easier navigation through source.

1. User writes a script that defines operations/shapes/objects, their edges, projections, cell counts, whatever is needed.
2. All the stuff is added to mesh.
3. Mesh converts user entered data into vertices, blocks, edges and whatnot.
4. The mesh can be written at that point; or,
5. Modification of placed geometry, either by manually moving vertices or by utilizing some sort of optimization algorithm.
6. Output of optimized/modified mesh.

• Unchecked list items from Features
• Usability
  • Frustum with any profile, not just arc
• Manual modification, automatic optimization
• Examples
  • Ramjet engine
• Technical stuff:
  • Skew transform
  • Debugging: connection between block and Shapes, naming
  • More tests
  • Documentation
  • spline/polyLine edge: automatic point sorting