README.md

---
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
---

<p align="center">
  <img src="https://huggingface.co/datasets/inductiva/windtunnel/resolve/main/example.png", width="500px">
</p>


# Wind Tunnel Dataset: 20,000 OpenFOAM Simulations
The **Wind Tunnel Dataset** contains **19,812 OpenFOAM simulations** of **1,000 unique automobile-like objects** placed in a virtual wind tunnel measuring **20 meters long, 10 meters wide, and 8 meters high.**

Each object was tested under **20 different conditions**: 4 random wind speeds ranging from **10 to 50 m/s**, and 5 rotation angles (**0°**, **180°** and **3 random angles**).

The object meshes were generated using [Instant Mesh](https://github.com/TencentARC/InstantMesh) based on images sourced from the [Stanford Cars Dataset](https://www.kaggle.com/datasets/jessicali9530/stanford-cars-dataset). To make sure the results are stable and reliable, each simulation runs for **300 iterations**.

The entire dataset 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](https://inductiva.ai/), 
which allowed us to run hundreds of OpenFOAM simulations in parallel on the cloud.


## Motivation: Addressing the Data Gap in CFD
Recently, there’s been a lot of interest in using **machine learning (ML)** to speed up **CFD simulations**. Research has shown that for well-defined scenarios—like a virtual wind tunnel—you can train an ML model to “predict” the results of a simulation **much faster** than traditional methods, while still keeping the accuracy close to what you’d expect from classical simulations.

That said, the **ML/CFD communities** are still lacking enough **training data** for their research. We’ve identified two main reasons for this.

First, there’s a shortage of datasets with **high-quality 3D meshes** needed for running CFD simulations. Existing 3D object datasets have a lot of limitations: they’re either too small, closed-source, or have low-quality meshes. Without this input data, it’s been really hard to generate large-scale training datasets for realistic CFD scenarios, which almost always involve 3D meshes.

Second, even if you had all the 3D meshes you needed, setting up and running thousands of **CFD simulations** to generate a large, diverse dataset isn’t easy. To create a dataset like this, you’d need to define an initial simulation scenario (like the wind tunnel setup) and then run enough variations—different meshes, wind speeds, and so on—to cover a wide range of data points for training a robust **ML model**.

The problem is, running a single CFD simulation can be tricky enough with most software. Orchestrating **thousands of simulations** and handling all the resulting data? That’s a whole new level of challenge.

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**. Using the popular **OpenFOAM** simulation package, we produced a large dataset of CFD simulations.

Next, we’ll explain how we tackled the challenges of generating the data and orchestrating the simulations.

## Generating a Large Quantity of Automobile-like 3D Meshes
Since there aren’t many publicly available 3D meshes of automobiles, we decided to use recent image-to-mesh models to generate meshes from freely available car images.

We specifically used the open-source [InstantMesh](https://github.com/TencentARC/InstantMesh) model (Apache-2.0), which is currently state-of-the-art in **image-to-mesh generation**. We generated the automobile-like meshes by running Instant Mesh on **1,000 images** from the publicly available [Stanford Cars Dataset](https://www.kaggle.com/datasets/jessicali9530/stanford-cars-dataset) (Apache-2.0), which contains 16,185 images of automobiles.

Running the image-to-mesh model naturally results in some defects, like irregular surfaces, asymmetry, holes, and disconnected components. To address these issues, we implemented a custom post-processing step to improve mesh quality. We used **PCA** to align the meshes with the main axes and removed any disconnected components.

The resulting set of meshes still contains minor defects, like “spikes” or “cavities” in flat areas, unexpected holes, and asymmetry issues. However, we see these imperfections as valuable features of the dataset. From a machine learning perspective, they bring challenges that can help prevent overfitting and contribute to building more robust and generalizable models.


## Orchestrating 20k Cloud Simulations—Using Just Python
To tackle the challenge of orchestrating **20,000 OpenFOAM simulations**, we resorted to the **Inductiva API**. The Inductiva platform offers a simple Python API for running simulation workflows in the cloud and supports several popular open-source packages, including **OpenFOAM**. Here’s an [example](https://docs.inductiva.ai/en/latest/simulators/OpenFOAM.html) of how to run an OpenFOAM simulation using Inductiva.

With the Inductiva API, it’s easy to parameterize specific simulation scenarios and run variations of a base case by programmatically adjusting the input parameters and starting conditions of the simulation. More details [here](#OpenFoam-Parameters). Additionally, users can create custom Python classes that wrap these parameterized simulations, providing a simple Python interface for running simulations—no need to interact directly with the underlying simulation packages. 

We used the [Inductiva API to create a Python class for the Wind Tunnel scenario](https://github.com/inductiva/wind-tunnel), which allowed us to run **20,000 simulations** across a range of input parameters.

For more on how to transform your complex simulation workflows into easy-to-use Python classes, we wrote a [blog post](https://inductiva.ai/blog/article/transform-complex-simulations) all about it.


## How Did We Generate the Dataset?
1.	**Generate Input Meshes**: We first generated input meshes using the **InstantMesh model** with images from the **Stanford Cars Dataset**, followed by post-processing to improve mesh quality.
2.	**Run OpenFOAM Simulations**: Using the Inductiva API, we ran OpenFOAM simulations on the input meshes under different wind speeds and angles. The result is an output mesh `openfoam_mesh.obj`that contains all the relevant simulation data.
3.	**Post-process OpenFOAM Output**: We post-processed the OpenFOAM output to generate streamlines and pressure map meshes.

The code we used to generate and post-process the meshes is available on [GitHub](https://github.com/inductiva/datasets-generation/tree/main/windtunnel_dataset).



## 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](#input_meshobj)**: OBJ file with the input mesh.
- **[openfoam_mesh.obj](#openfoam_meshobj)**: OBJ file with the OpenFOAM mesh.
- **[pressure_field_mesh.vtk](#pressure_field_meshvtk)**: VTK file with the pressure field data.
- **[streamlines_mesh.ply](#streamlines_meshply)**: PLY file with the streamlines.
- **[metadata.json](#metadatajson)**: 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 we generated using the Instant Mesh model from images in the Stanford Cars Dataset, serves as the starting point for the OpenFOAM simulation.

Details on the mesh generation process can be found [here](#Generating-a-large-quantity-of-Automobile-like-3D-Meshes).

| **Input Mesh**               | **# points of input meshes**           |
|-------------------------------|------------------------------|
| ![Input Mesh](https://huggingface.co/datasets/inductiva/windtunnel/resolve/main/assets/input_mesh.png) | ![Histogram](https://huggingface.co/datasets/inductiva/windtunnel/resolve/main/assets/histogram_of_points_input.png) |

    
```python
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 is the 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.

| **OpenFoam Mesh**               | **# points of OpenFoam meshes**           |
|-------------------------------|------------------------------|
| ![Input Mesh](https://huggingface.co/datasets/inductiva/windtunnel/resolve/main/assets/openfoam_mesh.png) | ![Input Mesh](https://huggingface.co/datasets/inductiva/windtunnel/resolve/main/assets/histogram_of_points_foam.png) |

```python
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 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 the point distribution matches that of the `input_mesh.obj`.

More details can be found here [here](https://github.com/inductiva/wind-tunnel/blob/deab68a018531ff05d0d8ef9d63d8c108800f78f/windtunnel/windtunnel_outputs.py#L111).

| **Pressure Field Mesh**               | **# points of Pressure Field meshes**           |
|-------------------------------|------------------------------|
| ![Input Mesh](https://huggingface.co/datasets/inductiva/windtunnel/resolve/main/assets/pressure_field_mesh.png) | ![Input Mesh](https://huggingface.co/datasets/inductiva/windtunnel/resolve/main/assets/histogram_of_points_input.png)) |


```python
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 visually represent the flow characteristics within the simulation, illustrating how air flows around the object


More information can be found [here](https://github.com/inductiva/wind-tunnel/blob/deab68a018531ff05d0d8ef9d63d8c108800f78f/windtunnel/windtunnel_outputs.py#L70).


| **Streamlines Mesh**               | **# points of streamlines meshes**           |
|-------------------------------|------------------------------|
| ![Input Mesh](https://huggingface.co/datasets/inductiva/windtunnel/resolve/main/assets/streamlines_mesh.png) | ![Input Mesh](https://huggingface.co/datasets/inductiva/windtunnel/resolve/main/assets/histogram_of_points_streamlines.png) |

### 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.
 
  ```json
    {
      "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 includes **19,812 valid samples** out of **20,000 simulations**, with [188 submissions failing](https://huggingface.co/datasets/inductiva/windtunnel/resolve/main/failed_tasks.txt) due to numerical errors in OpenFOAM.

The full dataset requires about **300 GB** of storage, but you can also download smaller portions if needed.


## Downloading the Dataset:

To download the dataset, you’ll need to install the [Datasets package](https://huggingface.co/docs/datasets/en/index) from Hugging Face:

```python
pip install datasets
```

### 1. Using snapshot_download()

```python
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()

```python
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 the [Inductiva Template Manager](https://tutorials.inductiva.ai/intro_to_api/templating.html) to **parameterize** the OpenFoam configuration files.

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


initialConditions.jinja
```jinja
flowVelocity         ({{ wind_speed }} 0 0);
```



controlDict.jinja
```jinja
endTime         {{ num_iterations }};
```

forceCoeffs.jinja
```jinja
magUInf         {{ wind_speed }};
lRef            {{ length }};        // Wheelbase length
Aref            {{ area }};        // Estimated
```

snappyHexMeshDict.jinja
```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](https://github.com/inductiva/wind-tunnel/tree/main/windtunnel/templates)


## What's Next?
If you encounter any issues with this dataset, feel free to reach out at [support@intuctiva.ai](support@intuctiva.ai).

If you spot any problematic meshes, let us know so we can fix them in 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—check out our well-tested [4-step recipe for generating synthetic data](https://inductiva.ai/blog/article/supercharge-your-physics-ml-with-inductivas-cloud-based-simulation-api) or discover how to [transform your own complex simulation workflows into easy-to-use Python classes](https://inductiva.ai/blog/article/transform-complex-simulations).

You may also be interested in reading our blog post, [The 3D Mesh Resolution Threshold - 5k Points is All You Need!](https://inductiva.ai/blog/article/5k-points-is-all-you-need), where we explore just how much you can reduce the level of detail in a 3D object while still maintaining accurate aerodynamic results in a virtual wind tunnel built with OpenFOAM.