Datasets:
Languages:
English
Size:
10K - 100K
| 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** | | |
| |-------------------------------|------------------------------| | |
| |  |  | | |
| ```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** | | |
| |-------------------------------|------------------------------| | |
| |  |  | | |
| ```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** | | |
| |-------------------------------|------------------------------| | |
| |  | ) | | |
| ```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** | | |
| |-------------------------------|------------------------------| | |
| |  |  | | |
| ### 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. | |