🤖 AI

ChannelFlow-Tools: A Configuration-Driven Pipeline for Generating Machine-Learning-Ready Datasets of 3D Obstructed Channel Flows

This paper introduces ChannelFlow-Tools, an open-source, configuration-driven pipeline that generates reproducible, machine-learning-ready datasets of 3D obstructed channel flows by integrating procedural geometry generation, signed-distance-field voxelization, and lattice-Boltzmann simulations, thereby enabling the training of robust, geometry-aware CFD surrogate models.

Original authors: Shubham Kavane, Lukas Schröder, Kajol Kulkarni, Fernando Gonzalez, Harald Koestler

Published 2026-08-19

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Shubham Kavane, Lukas Schröder, Kajol Kulkarni, Fernando Gonzalez, Harald Koestler

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Computational fluid dynamics is the science of using powerful computers to predict how liquids and gases move. For decades, engineers have relied on these simulations to design everything from aircraft wings to car bodies, but the calculations are often so heavy and slow that they cannot be run in real time. To speed things up, scientists have recently begun training artificial intelligence models to act as shortcuts. These "surrogate" models learn from thousands of past simulations to guess the outcome of a new situation almost instantly. However, for these AI shortcuts to be trustworthy, they must be trained on data that is perfectly accurate and generated in a consistent way. If the training data contains hidden errors or inconsistencies, the AI will learn the wrong lessons, and its predictions will fail when applied to real-world problems. The challenge has been finding a way to generate vast amounts of high-quality fluid data where every single variable is controlled, recorded, and verified.

A team of researchers at Friedrich-Alexander-Universität Erlangen-Nürnberg and CERFACS has built a solution to this problem called ChannelFlow-Tools. It is a fully automated system designed to create a massive library of three-dimensional fluid flow scenarios, specifically focusing on how air or water moves through a channel when blocked by various obstacles. Imagine a long, rectangular tunnel where the flow is interrupted by objects like spheres, cubes, cylinders, cones, rings, or wedges. The researchers wanted to know if they could generate thousands of these scenarios, simulate the fluid moving around them, and package the results into a format that artificial intelligence can easily read, all while ensuring that every step of the process was mathematically identical every time it was run.

The system works like a highly precise assembly line. First, it procedurally generates the shapes of the obstacles. Instead of manually designing each object, the software uses a set of rules to create random variations of the six basic shapes, ensuring they fit perfectly inside the channel without touching the walls or each other. It then converts these 3D shapes into a digital map called a signed distance field. This map tells the computer exactly how far every point in the space is from the nearest solid surface, which is crucial for the AI to understand the geometry. Next, the system runs a fluid simulation using a method called the lattice Boltzmann approach, which breaks the fluid down into tiny grid cells to calculate how it flows around the obstacles. Finally, it packages the shape, the distance map, and the resulting flow patterns into a single, organized file.

What makes this work distinct is not just that it creates data, but that it verifies every single step with extreme rigor. The researchers did not simply trust the computer to do its job; they audited the entire process. They checked that the 3D shapes were mathematically sound and free of tiny errors that could break the simulation. They confirmed that the digital distance maps accurately represented the shapes, even for complex arrangements with multiple objects. They validated the fluid solver by comparing its results against known, standard benchmarks for flow around a sphere, ensuring the physics were correct. Most importantly, they proved that the system is reproducible. If you give the system the exact same starting instructions and a random seed number, it will produce the exact same 3D shapes and simulation results down to the last bit of data. This level of consistency is rare in scientific computing and is essential for training reliable AI models.

The team released a dataset containing 450 complete simulations, covering a wide range of flow speeds and obstacle configurations. To prove that this data was actually useful, they trained three different types of artificial intelligence models on a portion of the dataset. These models were tasked with learning how to predict the flow pattern around an obstacle just by looking at its shape and the speed of the flow. The results showed that the models could successfully learn the relationship between the shape and the flow. When tested on shapes they had never seen before, or on flow speeds outside the range they were trained on, the models did not crash or produce nonsense; instead, they showed a predictable and understandable drop in accuracy, which is exactly what one would expect from a physical system. This behavior confirmed that the models were learning real physical principles rather than just memorizing patterns.

The study demonstrates that it is possible to build a shared, auditable infrastructure for generating fluid dynamics data that is ready for machine learning. By providing a pipeline that is open, configurable, and rigorously checked, the researchers have given the scientific community a tool to test how well AI models generalize to new situations. The work does not claim to have solved the problem of fluid prediction, nor does it present a single best AI model. Instead, it provides the clean, controlled, and verified data necessary to study how these models learn and where they might fail. This foundation allows other scientists to run controlled experiments, varying one factor at a time to understand the limits of AI in fluid dynamics, moving the field closer to reliable, real-time prediction tools for engineering and design.

Technical Summary: ChannelFlow-Tools

Problem Statement

Data-driven surrogate models are increasingly utilized in computational fluid dynamics (CFD) to accelerate flow predictions. However, the reliability of these models depends heavily on the quality, coverage, and physical consistency of their training data. A critical gap exists in the ability to perform controlled, single-factor studies (e.g., varying geometry while holding parameters fixed) because many existing open datasets are distributed as fixed corpora. In these fixed datasets, the underlying generation workflows are often unavailable, unverified, or not configurable, making it difficult to regenerate, adapt, or extend the data to match specific research requirements. Furthermore, existing resources often lack independent verification of the geometry representation (specifically Signed Distance Fields, or SDFs) and the alignment between geometric inputs and flow outputs.

Methodology

The authors introduce ChannelFlow-Tools, an open-source, configuration-driven pipeline designed to generate machine-learning-ready datasets for three-dimensional obstructed channel flows. The pipeline integrates four distinct stages, all driven by a single Hydra/OmegaConf configuration tree and a random seed to ensure reproducibility:

Procedural Obstacle Geometry Generation:
- Utilizes the CadQuery library (built on OpenCASCADE) to generate 3D obstacle geometries.
- Supports six primitive shape families: sphere, cuboid, cylinder, cone, torus, and wedge.
- Parameters include geometric dimensions, orientation, and placement coordinates.
- Employs two sampling modes: random uniform sampling and stratified Sobol sampling to ensure broad coverage of the design space.
- Enforces feasibility checks (wall clearance, inlet/outlet distance, minimum volume, and inter-object clearance) before exporting obstacles as STL meshes.
Signed-Distance-Field (SDF) Generation:
- Converts the generated STL meshes into voxelized SDFs on a Cartesian grid.
- The SDF ( $\phi$ ) encodes the obstacle geometry as a scalar field where $\phi < 0$ represents the solid interior, $\phi > 0$ the fluid, and $\phi = 0$ the boundary.
- Outputs are generated at user-defined resolutions, specifically targeting $128 \times 64 \times 64$ and $256 \times 128 \times 128$ grids for the released corpus.
Lattice-Boltzmann (LBM) Simulation:
- Uses the open-source WALBERLA framework with a D3Q27 velocity stencil and a cumulant collision operator.
- Simulates flow over the generated STL obstacles in a domain of $1024 \times 512 \times 512$ lattice units.
- Runs for 20 flow-through times, with the first 15 used for warm-up and the final 5 used to accumulate time-averaged velocity fields.
- Supports Reynolds numbers ( $Re_c$ ) ranging from approximately 100 to 15,000.
ML-Ready Tensor Packaging:
- Resamples the native LBM output and the SDF onto a common Cartesian grid.
- Packages the co-registered geometry field, SDF, and time-averaged velocity components ( $v_x, v_y, v_z$ ) into single HDF5 files.
- Ensures that every artifact is traceable back to the original configuration and random seed.

Key Contributions

The paper outlines four primary contributions:

Pipeline: A complete, configuration-driven workflow that produces co-registered, ML-ready tensors from procedural geometry through SDF construction and LBM simulation.
Stage-wise Verification and Auditing: Independent validation of the geometry, SDF, and solver stages, including a per-scene data-integrity audit of the final packaged tensors.
Reproducible Release: An audited corpus of obstructed channel flows released with configurations, seeds, and metadata. The geometry-generation stage is verified for byte-identical reproducibility via SHA-256 hashing.
Usability Demonstration: Evaluation of three surrogate baselines (3D U-Net, FNO, and U-FNO) trained on a sample dataset of 450 simulations to demonstrate direct downstream usability and characterize generalization challenges.

Results and Validation

The pipeline and dataset were rigorously validated across multiple levels:

Geometry Integrity: A mesh-integrity audit of 10,060 scenes confirmed positive volume and domain containment. While minor tessellation artifacts occurred at parametric singularities (e.g., sphere poles), they did not prevent downstream processing.
Reproducibility: Byte-identical regeneration of STL meshes and metadata was verified for both Sobol and pseudo-random sampling modes using SHA-256 hashing.
SDF Accuracy:
- Analytical Validation: Convergence studies against analytical SDFs (sphere, cylinder, cuboid) showed $L_2$ error convergence rates consistent with grid refinement, limited only by the underlying STL tessellation.
- Corpus Audit: A subset of 350 scenes showed sub-voxel mean surface distance accuracy ( $MSD/\Delta x \leq 1.0$ ) for single-object families and acceptable accuracy for multi-object scenes.
Solver Validation:
- Canonical Benchmarks: The solver reproduced wake statistics, vortex shedding frequencies, and drag coefficients for a sphere at $Re_s=1000$ consistent with experimental data (Choi and Park) and literature (Roos and Willmarth).
- Per-Scene Audit: All 450 released simulations passed checks for completeness, mass conservation (median imbalance 0.28%), statistical convergence, and geometry-flow registration.
Surrogate Performance:
- Learning Curves: All three models (U-Net, FNO, U-FNO) showed decreasing error as training set size increased, indicating a learnable signal.
- Generalization: Models exhibited physically interpretable degradation when tested on out-of-distribution (OOD) shape families and Reynolds numbers, rather than uncontrolled failure. U-FNO generally outperformed the other architectures.

Significance and Claims

The authors position ChannelFlow-Tools not as a claim of state-of-the-art surrogate performance, but as shared, auditable infrastructure for the controlled benchmarking of geometry-aware CFD surrogates.

The paper emphasizes that the primary value lies in the ability to:

Generate controlled datasets where specific factors (geometry, Reynolds number, resolution) can be varied in isolation.
Independently verify the fidelity of the geometry representation (SDF) and the physical consistency of the flow data.
Reproduce and extend datasets using configuration files and seeds, addressing the "black box" nature of many existing CFD datasets.

The authors modestly claim that the pipeline provides a resource for investigating generalization challenges and studying the reliability of surrogate models under distribution shifts, rather than solving the generalization problem itself. The released data serves as a foundation for future research into geometry-aware modeling, with the pipeline itself designed to be extensible to more complex geometries and higher Reynolds numbers.