metadata

pretty_name: Wind Tunnel 20K Dataset
size_categories:
  - 10K<n<100K
task_categories:
  - feature-extraction
  - graph-ml
  - image-to-3d
language:
  - en
tags:
  - simulation
  - openfoam
  - physics
  - windtunnel
  - inductiva
  - machine learning
  - synthetic

Wind Tunnel 20K Dataset

The Wind Tunnel Dataset contains 19,812 OpenFOAM simulations of 1,000 unique automobile-like objects placed in a virtual wind tunnel. Each object is simulated under 20 distinct conditions: 4 random wind speeds ranging from 10 to 50 m/s, and 5 rotation angles (0°, 180° and 3 random angles). The meshes for these automobile-like objects were generated using the Instant Mesh model on images sourced from the Stanford Cars Dataset. To ensure stable and reliable results, each simulation runs for 300 iterations. The entire dataset of 20,000 simulations is organized into three subsets: 70% for training, 20% for validation, and 10% for testing.

The data generation process itself was orchestrated using the Inductiva API, which allowed us to run hundreds of OpenFOAM simulations in parallel on the cloud.

Motivation

Recently, there has been great interest in developing ML methods to accelerate CFD simulations. Research has shown that for well defined CFD simulation scenarios (e.g. a virtual wind tunnel), it is possible to train an ML model capable of “predicting” the end result of the simulation orders of magnitude faster than existing classical simulation methods, while maintaining comparable accuracy levels.

However, the ML/CFD communities still lack training data for their research. We identified two main reasons for that.

First, there is a fundamental lack of datasets containing 3D meshes over which we can run CDF simulation. In fact existing 3D object datasets have many limitations: they are either small in size, closed source, or have low quality meshes. The absence of such input data has been a fundamental blocker for any attempt to generate large-scale training data in any realistic CFD scenario, which will naturally involve 3D meshes.

Second, even if you had all the 3D meshes you needed, it is still not trivial to orchestrate the thousands CFD simulations that are required to generate a large and diverse enough dataset for training ML-based CFD methods. For creating such a dataset one has to be able to define an initial simulation scenario (e.g. the windtunnel scenario), and run enough variations of the simulation, with different meshes, different wind speeds, etc to cover a wide enough range of data points to train a generalizable and robust ML model. Now, using most CFD software, running one simulation alone may be difficult enough. Orchestrating thousands of them and managing all the resulting data is a challenge in itself.

While both of these problems are difficult to solve in general, we decided to focus on one common CFD scenario: a virtual wind tunnel for (static) automobiles and produce a large dataset of CFD simulation run using the popular simulation package OpenFOAM.

Next, we will explain how we tackled the data and the simulation orchestration issues.

Generating a large quantity of Automobile-like 3D Meshes

Due to the lack of publicly available 3D meshes of automobile objects, we decided to use recent advances in image-to-mesh models to generate meshes from images of automobiles that are freely available.

More specifically, we used the InstantMesh model, which is open-source (Apache-2.0) and is currently state-of-the-art in image-to-mesh generation. The automobile-like meshes were generated by running the InstatMesh image-to-mesh model on 1k images from the publicly available (Apache-2.0) Stanford Cars Dataset consisting of 16,185 images of automobiles.

Naturally, running the image-to-mesh model leads to meshes that may have certain defects, such as irregular surfaces, asymmetry issues, holes and disconnected components. Therefore, after running the image-to-mesh model, we run a custom post-processing step where we try to improve the meshes quality. We used PCA to align the mesh with the main axis and we removed disconnected components.

The resulting set of meshes still have little defects, such as presence of "spikes" or "cavities" in supposedly flat areas, unexpected holes, asymmetry issues, among others. We consider these defects as valuable features of the dataset, since from the point of view of the learning problem, they bring certain challenges to ML models that we believe will make overfitting harder and will generally contribute to obtaining more robust and generalizable models.

Orchestrating 20k simulations on the cloud (just using Python)

For solving the challenge of orchestrating 20k OpenFOAM simulations, we resorted to the Inductiva API. The Inductiva platform exposes a simple Python API for running simulation workflows on the cloud. Inductiva makes available several popular open-source simulation packages, including OpenFOAM. Here is an example of how to run an OpenFOAM simulation using Inductiva (point to the doc that Paulo is preparing).

Using the Inductiva API, it becomes easy to parametrise specific simulation scenarios and run variations of a base case by programatically changing the input parameters and starting conditions of the simulation. Additionally, users can build custom Python classes that wrap parameterized simulation scenarios, allowing them to have a simple Python interface to running simulations without the need to directly interface with the low level simulation packages. We leveraged Inductiva API to create a Python class for the Wind Tunnel scenario, which we then used to run 20k simulations over a range of input parameters.

For more information on how to transform complex simulation workflows in simple Python classes check this blog post.

How did we generate the dataset?

Generate Input Meshes: First, input meshes are generated using the InstantMesh model with images from the Stanford Cars Dataset. Post-processing is then applied to these input meshes.
Run OpenFOAM Simulations: The Inductiva API is utilized to run OpenFOAM simulations on the input meshes at various wind speeds and object angles. This process produces an output mesh named openfoam_mesh.obj, which contains all relevant simulation information.
Post-process OpenFOAM Output: The OpenFOAM output is post-processed to generate streamlines and pressure map meshes.

The code used to generate the meshes and postprocess them is available on github: https://github.com/inductiva/datasets-generation.

Dataset Structure

data
├── train
│   ├── <SIMULATION_ID>
│   │   ├── input_mesh.obj
│   │   ├── openfoam_mesh.obj
│   │   ├── pressure_field_mesh.vtk
│   │   ├── simulation_metadata.json
│   │   └── streamlines_mesh.ply
│   └── ...
├── validation
│   └── ...
└── test
    └── ...

Dataset Files

Each simulation in the Wind Tunnel Dataset is accompanied by several key files that provide both the input and the output data of the simulations. Here’s a breakdown of the files included in each simulation:

input_mesh.obj: OBJ file with the input mesh.
openfoam_mesh.obj: OBJ file with the OpenFOAM mesh.
pressure_field_mesh.vtk: VTK file with the pressure field data.
streamlines_mesh.ply: PLY file with the streamlines.
metadata.json: JSON with metadata about the input parameters and about some output results such as the force coefficients (obtained via simulation) and the path of the output files.

input_mesh.obj

The input mesh was generated using the Instant Mesh model from images in the Stanford Cars Dataset. This mesh serves as the input for the subsequent OpenFOAM simulation.

Details on the mesh generation process can be found here.

Input Mesh	Points Histogram

import pyvista as pv

# Load the mesh
mesh_path = "input_mesh.obj"
mesh = pv.read(mesh_path)

# Get the vertices (points)
vertices = mesh.points

# Get the faces (connections)
# The faces array contains the number of vertices per face followed by the vertex indices.
# For example: [3, v1, v2, v3, 3, v4, v5, v6, ...] where 3 means a triangle.
faces = mesh.faces

openfoam_mesh.obj

This mesh was generated as a result of the OpenFOAM simulation. The number of points is reduced compared to the input_mesh.obj, due to mesh refinement and processing steps applied by OpenFOAM during the simulation.

Open Foam Mesh	Points Histogram

import pyvista as pv

# Load the mesh
mesh_path = "openfoam_mesh.obj"
mesh = pv.read(mesh_path)

# Get the vertices (points)
vertices = mesh.points

# Get the faces (connections)
# The faces array contains the number of vertices per face followed by the vertex indices.
# For example: [3, v1, v2, v3, 3, v4, v5, v6, ...] where 3 means a triangle.
faces = mesh.faces

pressure_field_mesh.vtk

Pressure values were extracted from the openfoam_mesh.obj and then interpolated onto the input_mesh.obj using the closest point strategy. This approach allowed us to project the pressure values onto a higher-resolution mesh. As shown in the histogram, the distribution of points matches that of the input_mesh.obj.

More details can be found here here.

Pressure Field Mesh	Points Histogram
	)

import pyvista as pv

mesh_path = "pressure_field_mesh.vtk"
mesh = pv.read(mesh_path)

# The vertices array contains the coordinates of each point in the mesh.
vertices = mesh.points

# The faces array contains the number of vertices per face followed by the vertex indices.
# For example: [3, v1, v2, v3, 3, v4, v5, v6, ...] where 3 means a triangle.
faces = mesh.faces

# Get the pressure data (scalar named "p")
# This retrieves the pressure values associated with each vertex in the mesh.
pressure_data = mesh.point_data["p"]

streamlines_mesh.ply

Streamlines were generated from the openfoam_mesh.obj, providing a visual representation of the flow characteristics within the simulation. The streamlines help illustrate how the air flows around the object.

More information can be found here.

Streamlines Mesh	Points Histogram

metadata.json

This file contains metadata related to the simulation, including input parameters such as wind_speed, rotate_angle, num_iterations, and resolution. Additionally, it includes output parameters like drag_coefficient, moment_coefficient, lift_coefficient, front_lift_coefficient, and rear_lift_coefficient. The file also specifies the locations of the generated output meshes.

  {
    "id": "1w63au1gpxgyn9kun5q9r7eqa",
    "object_file": "object_24.obj",
    "wind_speed": 35,
    "rotate_angle": 332,
    "num_iterations": 300,
    "resolution": 5,
    "drag_coefficient": 0.8322182,
    "moment_coefficient": 0.3425206,
    "lift_coefficient": 0.1824983,
    "front_lift_coefficient": 0.4337698,
    "rear_lift_coefficient": -0.2512715,
    "input_mesh_path": "data/train/1w63au1gpxgyn9kun5q9r7eqa/input_mesh.obj",
    "openfoam_mesh_path": "data/train/1w63au1gpxgyn9kun5q9r7eqa/openfoam_mesh.obj",
    "pressure_field_mesh_path": "data/train/1w63au1gpxgyn9kun5q9r7eqa/pressure_field_mesh.vtk",
    "streamlines_mesh_path": "data/train/1w63au1gpxgyn9kun5q9r7eqa/streamlines_mesh.ply"
}

Dataset Statistics

The dataset comprises 19,812 valid samples out of a total of 20,000 simulations, with 188 submissions failing due to numerical errors in OpenFOAM. The complete dataset requires about 300 GB of storage.

Downloading the Dataset:

To download the dataset you have to install the Datasets package by HuggingFace:

pip install datasets

1. Using snapshot_download()

import huggingface_hub

dataset_name = "inductiva/windtunnel-20k"

# Download the entire dataset
huggingface_hub.snapshot_download(repo_id=dataset_name, repo_type="dataset")

# Download to a specific local directory
huggingface_hub.snapshot_download(
    repo_id=dataset_name, repo_type="dataset", local_dir="local_folder"
)

# Download only the simulation metadata across all simulations
huggingface_hub.snapshot_download(
    repo_id=dataset_name,
    repo_type="dataset",
    local_dir="local_folder",
    allow_patterns=["*/*/*/simulation_metadata.json"]
)

2. Using load_dataset()

import datasets

# Load the dataset (streaming is supported)
dataset = datasets.load_dataset("inductiva/windtunnel-20k", streaming=False)

# Display dataset information
print(dataset)

# Access a sample from the training set
sample = dataset["train"][0]
print("Sample from training set:", sample)

OpenFoam Parameters

We used Inductiva Template Manager to parameterize the OpenFoam configuration files.

Below are snippets from some of the templates used in the wind tunnel simulations.

initialConditions.jinja

flowVelocity         ({{ wind_speed }} 0 0);

blockMeshDict.jinja

vertices
(
    ({{ x_min }} {{ y_min }} {{ z_min }})
    ({{ x_max }} {{ y_min }} {{ z_min }})
    ({{ x_max }} {{ y_max }} {{ z_min }})
    ({{ x_min }} {{ y_max }} {{ z_min }})
    ({{ x_min }} {{ y_min }} {{ z_max }})
    ({{ x_max }} {{ y_min }} {{ z_max }})
    ({{ x_max }} {{ y_max }} {{ z_max }})
    ({{ x_min }} {{ y_max }} {{ z_max }})
);

controlDict.jinja

endTime         {{ num_iterations }};

forceCoeffs.jinja

magUInf         {{ wind_speed }};
lRef            {{ length }};        // Wheelbase length
Aref            {{ area }};        // Estimated

snappyHexMeshDict.jinja

geometry
{
    object
    {
        type triSurfaceMesh;
        file "object.obj";
    }

    refinementBox
    {
        type searchableBox;
        min ({{ x_min }} {{ y_min }} {{ z_min }});
        max ({{ x_max }} {{ y_max }} {{ z_max }});
    }
};

features
(
    {
        file "object.eMesh";
        level {{ resolution + 1  }};
    }
);


refinementSurfaces
{
    object
    {
        // Surface-wise min and max refinement level
        level ({{ resolution }} {{ resolution + 1 }});
    }
}

refinementRegions
{
    refinementBox
    {
        mode inside;
        levels ((1E15 {{ resolution - 1 }}));
    }
}

locationInMesh ({{ x_min }} {{ y_min }} {{ z_min }});

You can find the full OpenFoam configuration on github: https://github.com/inductiva/wind-tunnel/tree/main/windtunnel/templates

What's next?

If you have any issues using this dataset, feel free to reach out to us at support@intuctiva.ai.

If you detect any clearly problematic mesh, please let us know so we can correct that issue for the next version of the Windtunnel-20k dataset.

To learn more about how we created this dataset—or how you can generate synthetic datasets for Physics-AI models—visit Inductiva.AI or check out our blog post on transforming complex simulation workflows into easy-to-use Python classes.