UrbanFlow-3K: A Dataset of 3,000 Lattice-Boltzmann Simulations of Random Building Layouts

This paper introduces UrbanFlow-3K, a comprehensive open-source dataset comprising 3,000 two-dimensional lattice-Boltzmann simulations of urban flow around randomized building layouts, designed to facilitate the development, benchmarking, and transfer learning of machine learning models for predicting urban flow fields.

The Gist

Imagine you are trying to teach a robot how to fly a drone through a busy city without crashing, or how to design a building so the wind doesn't knock over pedestrians. To do this, you need to understand how air moves around skyscrapers.

Traditionally, scientists have used super-computers to simulate this wind. Think of these simulations like high-definition, 3D movies of the wind. They are incredibly accurate, but they take a long time to render (run) and cost a fortune in electricity. If you want to test 3,000 different city layouts, it would take years and a massive budget.

This paper introduces UrbanFlow-3K, a new "training manual" for Artificial Intelligence (AI) to solve this problem. Here is the breakdown in simple terms:

1. The Problem: Too Expensive to Train

Scientists want to use AI (Machine Learning) to predict wind patterns instantly, like a weather app. But to teach an AI, you need a huge library of examples.

• The Issue: Real 3D wind simulations are like shooting a blockbuster movie. You can't make 3,000 of them just to practice.
• The Gap: There were almost no free, open "practice books" (datasets) for AI to learn the basics of wind around buildings, especially in a simplified 2D format.

2. The Solution: A Massive "2D Sketchbook"

The authors created a dataset of 3,000 wind simulations.

• The Analogy: Instead of trying to paint a 3D masterpiece immediately, they created 3,000 detailed 2D sketches.
• The Content: Each sketch shows wind flowing around a random arrangement of 3 to 6 "buildings" (which are just rectangles in this case).
• The Variety: The buildings are different sizes, placed in random spots, and rotated at different angles. This creates a chaotic mix of wind tunnels, dead zones, and swirling eddies, just like a real city.
• The Physics: They ran these simulations at three different "wind speeds" (Reynolds numbers) to ensure the AI learns how wind behaves in different conditions.

3. How They Made It: The "Lego" Approach

To generate these 3,000 sketches, they used a method called Lattice-Boltzmann.

• The Metaphor: Imagine the air is made of millions of tiny, invisible Lego bricks. The computer tracks how these bricks bounce off each other and the buildings.
• The Grid: They built a digital mesh (a grid) around the buildings. Where the wind gets tricky (near the walls), the grid gets very fine (small Lego bricks). In open spaces, the grid is coarser (big Lego bricks) to save time.
• The Result: They ran these on a supercomputer in Germany, generating a massive library of data that captures how wind creates "wakes" (the turbulent air behind a building) and "jets" (wind speeding up between buildings).

4. Why This Matters: The "Training Wheels" Strategy

This is the most important part. Why give the AI 2D sketches instead of 3D movies?

• The Analogy: Think of learning to ride a bike. You don't start on a mountain trail (3D complex city). You start on a flat, empty parking lot with training wheels (2D simple city).
• The Benefit: Because these 2D simulations are cheap and fast, the researchers could generate 3,000 examples. This is enough to teach the AI the fundamental rules of wind physics.
• Transfer Learning: Once the AI masters the 2D "training wheels," it can be "fine-tuned" on a few expensive 3D simulations. It's much easier to teach a student who already knows the basics than one who knows nothing.

5. What's Inside the Box?

The paper isn't just the numbers; it's a complete toolkit:

• The Data: 3,000 files containing wind speed and direction.
• The Tools: They provided "scripts" (digital recipes) that automatically convert this raw data into formats that AI models (like Convolutional Neural Networks or Graph Neural Networks) can easily eat.
• Validation: They double-checked their work. They simulated a single building and compared their results to known scientific facts to prove their "sketches" were accurate.

Summary

UrbanFlow-3K is a massive, free library of 2D wind simulations designed to be the "training wheels" for AI. It allows researchers to teach machines how wind behaves around buildings quickly and cheaply, so that later, those machines can be upgraded to handle the complex, real-world 3D cities of the future. It bridges the gap between expensive physics simulations and fast, smart AI predictions.

Technical Summary

1. Problem Statement

The analysis of urban flow fields is critical for applications such as pedestrian safety, pollutant dispersion, and building energy efficiency. While Computational Fluid Dynamics (CFD) provides high-fidelity data, its prohibitive computational cost limits its use in real-time decision-making and large-scale parametric studies. Machine Learning (ML) models offer a promising solution as fast surrogate models, but their development is hindered by a scarcity of open-source, diverse training datasets.

Specifically, while some 3D datasets exist, there is a significant gap in publicly available 2D urban flow datasets. 2D datasets are essential for the early development, debugging, and systematic benchmarking of ML architectures before scaling to computationally expensive 3D simulations. Existing 2D datasets lack the geometric diversity and sample size required for robust ML training.

2. Methodology

A. Simulation Framework

• Solver: The dataset was generated using the Lattice-Boltzmann Method (LBM) implemented in the m-AIA (multiphysics Aerodynamisches Institut Aachen) simulation framework.
• Grid Generation: Unstructured hierarchical Cartesian grids (octree-based) were generated using the m-AIA framework. The grid employs local refinement around buildings to capture near-wall gradients and wake structures efficiently.
• Hardware: Simulations were executed on the JURECA-DC supercomputer (Forschungszentrum Jülich), utilizing NVIDIA A100 GPUs.
• Boundary Conditions:
  • Inlet: Uniform reference velocity ($U_{ref}$).
  • Outlet: Constant reference density/pressure.
  • Top/Bottom: Slip-flow conditions.
  • Buildings: No-slip condition via an interpolated bounce-back scheme.

B. Dataset Generation & Geometric Diversity

The dataset consists of 3,000 unique simulations divided into three Reynolds number groups ($Re = 3,000, 4,000, 5,000$), with 1,000 samples each.

• Geometry: Each layout contains 3 to 6 non-overlapping buildings.
• Randomization:
  • Size: Building edge lengths ($d$) are uniformly sampled between $1d_{ref}$ and $2d_{ref}$.
  • Position: Centers are randomized within a predefined Region of Interest (ROI).
  • Rotation: The entire ensemble is rotated by a random angle $\alpha \in (0^\circ, 90^\circ)$.
• Domain: The computational domain is $45d_{ref} \times 30d_{ref}$. The characteristic length $d_{ref}$ is the minimum building edge length.

C. Data Processing for ML

To facilitate ML training, the raw simulation data (hierarchical grids) is processed into two formats:

1. Uniform Grid (for CNNs): A uniformly refined Cartesian grid covering the ROI ($9d_{ref} \times 7d_{ref}$) is generated. Flow variables are resampled from the original grid to this uniform grid using nearest-neighbor assignment to avoid interpolation artifacts.
2. Graph Representation (for GNNs): The uniform grid cells are treated as nodes in a graph. Adjacency lists and edge attributes (relative positions) are generated to support Graph Neural Networks.

• Output: Time-averaged velocity fields ($u, v$) and fluid density are provided. The time-averaging period covers the final $0.5 \times 10^6$ time steps of a $2.5 \times 10^6$ step simulation.

3. Key Contributions

1. UrbanFlow-3K Dataset: A comprehensive, open-source dataset of 3,000 2D urban flow simulations with high geometric diversity (randomized building counts, sizes, positions, and rotations).
2. Bridging the 2D/3D Gap: Provides a scalable testbed for early-stage ML model development and debugging, addressing the lack of 2D urban flow data.
3. Transfer Learning Support: Designed to support transfer learning strategies where models are pre-trained on this large 2D dataset and fine-tuned on smaller, expensive 3D datasets.
4. ML-Ready Preprocessing: Includes Python scripts (gen_CNN.ipynb and gen_GNN.ipynb) to automatically transform raw CFD data into formats compatible with Convolutional Neural Networks (CNNs) and Graph Neural Networks (GNNs).
5. Validation: Rigorous grid refinement studies and validation against literature (drag coefficients and Strouhal numbers) ensure the physical fidelity of the data.

4. Results & Validation

• Grid Convergence: A grid refinement study (Coarse, Medium, Fine) was conducted on both single-cylinder and multi-building cases.
  • The Medium grid was selected as the optimal balance between accuracy and cost.
  • Relative error in drag coefficient ($C_d$) between Medium and Fine grids was 3.4%.
  • Velocity profile errors between Medium and Fine grids were < 4%, indicating quantitative convergence.
• Physical Consistency:
  • Drag Coefficient: The simulated $C_d$ for a single square cylinder at $Re=500$ was 1.85, with a 5.3% relative error compared to reference data (1.89).
  • Strouhal Number: The calculated Strouhal number ($St = 0.14$) falls within the expected literature range ($0.13 - 0.18$) for 2D flow around a square cylinder.
• Flow Phenomena: The dataset successfully captures complex flow features including:
  • Wake formation and recirculation zones.
  • Flow acceleration (jets) between buildings.
  • Shielding effects and flow deflection.
  • Sensitivity to building density: Denser layouts lead to stronger jet acceleration and merged wakes, while sparse layouts result in isolated wakes.
• Reynolds Number Sensitivity: Increasing $Re$ from 5,000 to 6,000 showed no significant structural changes in wake regions, confirming that the $Re \in \{3000, 4000, 5000\}$ range is sufficient to capture the relevant physics for this dataset.

5. Significance

The UrbanFlow-3K dataset represents a critical resource for the data-driven fluid engineering community. By providing a large-scale, diverse, and physically validated 2D dataset, it enables:

• Rapid Prototyping: Researchers can develop and debug ML architectures without the computational overhead of 3D CFD.
• Systematic Benchmarking: The consistent simulation setup allows for fair comparison of different ML models and training strategies.
• Transfer Learning: It establishes a foundation for "pre-training" models on 2D data, which can then be adapted to 3D urban environments, potentially reducing the data requirements for high-fidelity 3D models.
• Future Expansion: The authors note that this 2D dataset serves as a precursor to a larger 3D dataset (using the urbanFlowGen library), creating a complementary ecosystem for urban flow prediction.

The dataset is publicly available via Harvard Dataverse (DOI: 10.7910/DVN/J2DRQO), accompanied by the necessary data-handling scripts.