The dataset viewer is not available because its heuristics could not detect any supported data files. You can try uploading some data files, or configuring the data files location manually.
2D Centrifugal Pump Ultra-Fine MRF Simulation Dataset (pump_dataset.nc)
This repository hosts a high-fidelity dataset of 2,337 operational steady-state finite-element simulations capturing the hydrodynamic state of an industrial 2D centrifugal pump across extensive operating sweeps of rotational speed and volumetric flow rate. Originally solved using high-resolution numerical formulations in COMSOL Multiphysics 6.0 with a Multiple Reference Frame (MRF) approach, the dataset is structured as a CF-compliant, hierarchical NetCDF-4 / HDF5 store (xarray.DataTree).
1. Physical Context & Parametric Variation
Governing Physics
The fluid motion is governed by the steady, incompressible Navier-Stokes equations formulated in a Multiple Reference Frame (MRF). In the rotating rotor frame attached to the blades ($\boldsymbol{\omega} = \omega \hat{\mathbf{z}}$), the momentum and continuity equations incorporate Coriolis and centrifugal body accelerations:
where:
- $\mathbf{u} = (u, v)$ is the absolute fluid velocity vector in the Cartesian lab frame.
- $\mathbf{u}_r = \mathbf{u} - \boldsymbol{\omega} \times \mathbf{r}$ is the relative fluid velocity vector with respect to the rotating reference frame.
- $2 \boldsymbol{\omega} \times \mathbf{u}$ accounts for the Coriolis acceleration.
- $p$ is the static gauge pressure.
- $\rho$ and $\mu$ denote the fluid density and dynamic viscosity.
What Changes from Simulation to Simulation?
The geometry (6,286-node volute casing, 644-node rotor blades, inlet, and outlet) and fluid physical properties (water continuum) are held constant across all simulations.
The two exogenous driving parameters that change from simulation to simulation are:
- Volumetric Flow Rate ($Q_{\text{in}}$): Imposed at the inlet boundary ($Q_{\text{in}} \in [0.25, 14.0]\text{ m}^3/\text{h}$).
- Rotational Speed ($\text{rot_rpm}$): Impeller angular velocity ($\omega \in [500, 3000]\text{ RPM}$).
Each of the 2,337 operational points represents a distinct steady-state operating point across the pump's head-flow ($H\text{--}Q$) characteristic curve:
- Wide operational envelope spanning low-flow recirculating stall, design-point maximum efficiency, and high-flow cavitation-prone conditions.
- Hydrodynamic blade loading: Local surface pressure distribution, total boundary traction $(T_x, T_y)$, and resultant hydrodynamic torque.
- Multi-domain coupling: Captures flow interaction between rotating impeller channels and stationary volute casing.
This dataset provides an ideal benchmark for:
- Neural Operators & Scientific Machine Learning: DeepONet, Fourier Neural Operators (FNO), and MeshGraphNets.
- Physics-Informed Neural Networks (PINNs): Testing Navier-Stokes residual compliance across parametric regimes.
- Non-Intrusive Reduced-Order Modeling (NIROM): POD-RBF, Autoencoder-based ROMs, and dynamic system identification.
- Turbomachinery Digital Twins: Real-time head prediction and online state estimation.
2. NetCDF-4 Hierarchical Data Structure
The dataset (pump_dataset.nc) is organized hierarchically where each operational simulation step is stored in an independent group /{run_name} (e.g. /run_001 through /run_2337):
pump_dataset.nc
βββ Global Attributes: title="Pump 2D Ultra Fine MRF Study", source="COMSOL Multiphysics 6.0", conventions="CF-1.8"
β
βββ /{run_name} [e.g. /run_001, ..., /run_2337]
β Attributes: step_index, Q_in, rot_rpm
β
βββ Experiment-Level Variables (0D Scalar Operating Parameters):
β βββ volumetric flow [mΒ³/h] Imposed inlet volumetric flow rate (Q_in)
β βββ rotational speed [rpm] Impeller rotational speed (rot_rpm)
β
βββ /pump [Main Volute Domain: 6,286 nodes]
β Dimensions: (node: 6286, spatial: 2)
β Coordinates:
β βββ coordinates (node, spatial) [m] Absolute (x, y) Cartesian mesh coordinates
β βββ spatial ['x', 'y']
β Data Variables:
β βββ velocity (node, spatial) [m/s] 2D Cartesian velocity vector (u, v)
β βββ pressure (node) [Pa] Static gauge pressure field
β
βββ /blades [Rotor Blade Interface: 644 nodes]
β Dimensions: (node: 644, spatial: 2)
β Coordinates:
β βββ coordinates (node, spatial) [m] Absolute (x, y) Cartesian mesh coordinates
β βββ spatial ['x', 'y']
β Data Variables:
β βββ velocity (node, spatial) [m/s] 2D Cartesian velocity vector (u, v)
β βββ total traction (node, spatial) [N/mΒ²] 2D boundary stress/traction vector (Tx, Ty)
β βββ rotation angle (node) [rad] Impeller rotation orientation (rot1.alpha)
β βββ pressure (node) [Pa] Static gauge pressure field
β
βββ /inlet [Inflow Boundary: 16 nodes]
β Dimensions: (node: 16, spatial: 2)
β Coordinates: coordinates (node, spatial), spatial ['x', 'y']
β Data Variables:
β βββ velocity (node, spatial) [m/s] 2D inlet velocity vector (u, v)
β βββ pressure (node) [Pa] Static pressure field
β
βββ /outlet [Discharge Boundary: 17 nodes]
Dimensions: (node: 17, spatial: 2)
Coordinates: coordinates (node, spatial), spatial ['x', 'y']
Data Variables:
βββ velocity (node, spatial) [m/s] 2D outlet discharge velocity vector (u, v)
βββ pressure (node) [Pa] Static pressure field
3. Discretization & Variable Breakdown
A. Experiment Level: Operational Parameters (No Mesh Dimension)
Stored directly at /{run_name}/, describing global scalar operating boundary conditions:
| Variable Name | Dimensions | Type | Units | Description |
|---|---|---|---|---|
volumetric flow |
() (Scalar) |
Data Variable | mΒ³/h | Inflow volumetric flux $Q_{\text{in}}$ driving the pump. |
rotational speed |
() (Scalar) |
Data Variable | rpm | Impeller rotational angular speed $\text{rot_rpm}$. |
B. Geometry Level: Domain Decomposition & Mesh Fields
The computational domain is partitioned into 4 distinct physical subdomains with independent spatial mesh discretizations:
| Subdomain Group | Mesh Node Count | Domain Description | Primary Field Variables |
|---|---|---|---|
/{run_name}/pump |
6,286 | Volute casing & main fluid continuum | velocity (node, spatial), pressure (node) |
/{run_name}/blades |
644 | Impeller blade surfaces & MRF boundary | velocity (node, spatial), total traction (node, spatial), rotation angle (node), pressure (node) |
/{run_name}/inlet |
16 | Upstream suction boundary | velocity (node, spatial), pressure (node) |
/{run_name}/outlet |
17 | Downstream discharge boundary | velocity (node, spatial), pressure (node) |
Variable Specifications:
coordinates(node, spatial): Cartesian $(x, y)$ coordinates in meters [m], with coordinate dimensionspatial = ['x', 'y'].velocity(node, spatial): 2D velocity vector $(u, v)$ in [m/s].pressure(node): Continuum static gauge pressure in Pascals [Pa].total traction(node, spatial): Hydrodynamic boundary stress vector $(T_x, T_y)$ exerted on the impeller blades in $[\text{N/m}^2]$ (derived fromspf.T_stressxandspf.T_stressy).rotation angle(node): Instantaneous rotor orientation angle $\alpha$ in radians [rad] (derived fromrot1.alpha).
4. How to Use the Dataset in Python
NetCDF-4 files on Hugging Face are stored as binary Git LFS files. You can stream or download them directly into xarray using huggingface_hub and h5netcdf.
Installation
pip install huggingface_hub xarray h5netcdf numpy matplotlib
Loading and Inspecting an Operational Point
import os
os.environ["HDF5_USE_FILE_LOCKING"] = "FALSE"
from huggingface_hub import hf_hub_download
import xarray as xr
# 1. Download NetCDF file from Hugging Face Hub cache
file_path = hf_hub_download(
repo_id="MaximilianKannapinn/pump_2d_ultrafine_mrf",
filename="pump_dataset.nc",
repo_type="dataset",
)
# 2. Open an individual operational simulation step
run_name = "run_001"
# Open root experiment (operating parameters)
ds_root = xr.open_dataset(file_path, group=f"/{run_name}", engine="h5netcdf")
print(f"Flow rate: {float(ds_root['volumetric flow']):.2f} m^3/h")
print(f"Rotational speed: {float(ds_root['rotational speed']):.0f} RPM")
# Open main pump volute domain
ds_pump = xr.open_dataset(file_path, group=f"/{run_name}/pump", engine="h5netcdf")
print("Pump mesh nodes:", ds_pump.sizes["node"]) # 6286
print("Pump velocity shape:", ds_pump["velocity"].shape) # (6286, 2)
print("Pump pressure shape:", ds_pump["pressure"].shape) # (6286,)
# Open rotating blades domain
ds_blades = xr.open_dataset(file_path, group=f"/{run_name}/blades", engine="h5netcdf")
print("Blade nodes:", ds_blades.sizes["node"]) # 644
print("Blade total traction shape:", ds_blades["total traction"].shape) # (644, 2)
Visualizing Pump Pressure Field & Blade Traction Vectors
import matplotlib.pyplot as plt
# Extract mesh coordinates
pump_coords = ds_pump.coords["coordinates"].values # (6286, 2)
blade_coords = ds_blades.coords["coordinates"].values # (644, 2)
# Extract physical fields
pump_pressure = ds_pump["pressure"].values # (6286,)
blade_traction = ds_blades["total traction"].values # (644, 2)
fig, ax = plt.subplots(figsize=(10, 8))
# 1. Scatter/contour plot of static pressure across volute casing
sc = ax.scatter(
pump_coords[:, 0],
pump_coords[:, 1],
c=pump_pressure / 1000.0, # kPa
cmap="turbo",
s=8,
alpha=0.85,
label="Volute Pressure [kPa]"
)
cbar = plt.colorbar(sc, ax=ax, shrink=0.8)
cbar.set_label("Static Pressure [kPa]", fontsize=12)
# 2. Quiver plot of boundary traction vectors along impeller blades
subsample = slice(None, None, 4)
ax.quiver(
blade_coords[subsample, 0],
blade_coords[subsample, 1],
blade_traction[subsample, 0],
blade_traction[subsample, 1],
color="black",
scale=5e6,
width=0.003,
label="Blade Surface Traction [N/mΒ²]"
)
ax.set_aspect("equal")
ax.set_xlabel("x [m]", fontsize=12)
ax.set_ylabel("y [m]", fontsize=12)
ax.set_title(
f"Centrifugal Pump MRF Simulation: {run_name} (Q = {float(ds_root['volumetric flow']):.1f} mΒ³/h, n = {float(ds_root['rotational speed']):.0f} RPM)",
fontsize=13
)
ax.grid(True, linestyle="--", alpha=0.3)
ax.legend(loc="upper left")
plt.tight_layout()
plt.show()
- Downloads last month
- 29