fastcomputing/first_beam3d_test_single_split

Beam3D Elastic Dynamics Dataset

Dataset Details

Dataset Description

This dataset contains synthetic 3D beam simulations generated with a finite element solver based on deal.II.

Each sample represents one dynamic simulation of a 3D elastic beam. The simulations include randomized geometry, material properties, damping parameters, and loading conditions.

The dataset is intended for scientific machine learning tasks involving elastic dynamics, including surrogate modeling, graph neural networks, neural operators, reduced-order modeling, and spatio-temporal prediction.

The dataset is organized into three Hugging Face configurations:

Configuration	Content
geometry	Mesh connectivity, graph connectivity, and static node-level information
snapshot	Time-dependent physical fields stored component-wise
metadata	Simulation-level scalar parameters

• Curated by: FAST Computing
• Shared by: FAST Computing
• Language(s): English
• License: Other

---

Uses

Direct Use

This dataset can be used for:

• training surrogate models for 3D elastic dynamics;
• training graph neural networks on finite element meshes;
• training neural operators or sequence models for displacement and velocity prediction;
• learning the response of elastic beams under different loading conditions;
• testing reduced-order modeling pipelines;
• benchmarking scientific machine learning methods on structured simulation data.

The dataset is especially suited for methods that use mesh information, graph connectivity, node-level physical quantities, and simulation metadata.

Out-of-Scope Use

This dataset should not be used as a validated engineering benchmark for safety-critical structural design.

The simulations are synthetic and depend on the numerical assumptions, mesh resolution, material model, and loading conditions used during generation. Any engineering use requires independent verification.

---

Dataset Structure

The dataset has three configurations:

from datasets import load_dataset

repo_id = "fastcomputing/first_beam3d_test_single_split"

geometry = load_dataset(repo_id, name="geometry", split="total")
snapshots = load_dataset(repo_id, name="snapshot", split="total")
metadata = load_dataset(repo_id, name="metadata", split="total")

Each configuration contains one row per simulation sample.

---

Configuration: geometry

The geometry configuration stores mesh-related quantities and static node-level information.

Each row corresponds to one simulation sample.

Field	Meaning	Expected shape	Type
sample_id	Simulation identifier	scalar	int32
points_x	Node coordinates in x direction	(N, )	float32
points_y	Node coordinates in y direction	(N, )	float32
points_z	Node coordinates in z direction	(N, )	float32
cells	Hexahedral cell connectivity	(C, 8)	int32
edge_index	Directed graph edges extracted from hexahedral cells	(2, E)	int32
constraint_mask_x	Mask identifying constrained displacement components in x	(N, )	int32
constraint_mask_y	Mask identifying constrained displacement components in y	(N, )	int32
constraint_mask_z	Mask identifying constrained displacement components in z	(N, )	int32
constraint_value_x	Prescribed displacement values for constrained components x	(N, )	float32
constraint_value_y	Prescribed displacement values for constrained components y	(N, )	float32
constraint_value_z	Prescribed displacement values for constrained components z	(N, )	float32
boundary_id	Geometric boundary label associated with each node	(N,)	int32
node_type	Semantic node classification	(N,)	int32

Where:

N = number of mesh nodes
C = number of hexahedral cells
E = number of directed graph edges

points

points stores the node coordinates:

points_x[i] = [x_i]
points_y[i] = [y_i]
points_z[i] = [z_i]

Shape:

(N, )

cells

cells stores the hexahedral finite element connectivity.

Each row contains the 8 node indices of one hexahedral cell:

cells[c] = [n0, n1, n2, n3, n4, n5, n6, n7]

Shape:

(C, 8)

This is not the raw VTK flat cell array.

edge_index

edge_index stores graph connectivity derived from the hexahedral cells.

For each hexahedral cell, the 12 standard hexahedron edges are extracted. Both directions are stored for each edge, so the graph is directed:

edge_index[:, e] = [source_node, target_node]

Shape:

(2, E)

The local hexahedral edges used to build the graph are:

(0, 1), (1, 2), (2, 3), (3, 0),
(4, 5), (5, 6), (6, 7), (7, 4),
(0, 4), (1, 5), (2, 6), (3, 7)

For each edge (i, j), both (i, j) and (j, i) are added. Duplicate edges are removed.

constraint_mask

constraint_mask_x identifies which displacement components in x are constrained.

Shape:

(N, )

Examples:

[1] -> fixed in x node
[0] -> free node

constraint_value

constraint_value_x stores the prescribed displacement in x value for constrained components.

Shape:

(N, )

For a homogeneous fixed boundary condition:

constraint_value_x[i] = [0]

The constraint_mask tells whether a component is constrained.
The constraint_value tells the imposed value.

boundary_id

boundary_id identifies the geometric boundary region associated with each node.

Shape:

(N,)

It answers:

Which mesh boundary does this node belong to?

Example:

boundary_id = 1 -> left beam end
boundary_id = 2 -> right beam end
boundary_id = 3 -> loaded surface

The exact meaning depends on the mesh labeling used during data generation.

node_type

node_type gives the semantic role of the node in the simulation.

Shape:

(N,)

Current convention:

0 = internal node
1 = Dirichlet boundary node
2 = Neumann boundary node
3 = boundary node without explicitly assigned boundary condition

In short:

boundary_id tells where the node is.
node_type tells what role the node has.

---

Configuration: snapshot

The snapshot configuration stores time-dependent fields.

Each row corresponds to one simulation sample and contains the full temporal evolution of the saved physical quantities.

The dynamic vector fields are stored component-wise. Acceleration is not stored in the current Hugging Face dataset.

Field	Meaning	Expected shape	Type
sample_id	Simulation identifier	scalar	int32
time	Saved output times	(T,)	float32
displacement_x	x-component of nodal displacement	(T, N)	float32
displacement_y	y-component of nodal displacement	(T, N)	float32
displacement_z	z-component of nodal displacement	(T, N)	float32
velocity_x	x-component of nodal velocity	(T, N)	float32
velocity_y	y-component of nodal velocity	(T, N)	float32
velocity_z	z-component of nodal velocity	(T, N)	float32
body_force_x	x-component of nodal body force	(T, N)	float32
body_force_y	y-component of nodal body force	(T, N)	float32
body_force_z	z-component of nodal body force	(T, N)	float32
traction_x	x-component of nodal surface traction	(T, N)	float32
traction_y	y-component of nodal surface traction	(T, N)	float32
traction_z	z-component of nodal surface traction	(T, N)	float32

Where:

T = number of saved output times
N = number of mesh nodes

Examples:

displacement_x[k][i] = x-displacement of node i at time step k
displacement_y[k][i] = y-displacement of node i at time step k
velocity_y[k][i]     = y-velocity of node i at time step k
traction_y[k][i]     = y-component of the surface traction at node i and time step k

To reconstruct a full vector field:

import numpy as np

u = np.stack(
    [
        dyn["displacement_x"],
        dyn["displacement_y"],
        dyn["displacement_z"],
    ],
    axis=-1,
)

print(u.shape)
# (T, N, 3)

The same convention can be used for velocity, body force, and traction.

---

Configuration: metadata

The metadata configuration stores scalar simulation parameters and bookkeeping information.

Each row corresponds to one simulation sample.

Execution and file information

Field	Meaning
sample_id	Simulation identifier
valid	Whether the simulation sample is valid
sample_name	Sample folder name
sample_dir	Sample directory
geo_path	Path to the .geo geometry file
mesh_path	Path to the mesh file
result_dir	Directory containing solver outputs
mpi_np	Number of MPI processes used
solver_executable	Solver executable path or name
gmsh_executable	Gmsh executable path or name
solution_file_type	Type of solution file used, for example .pvtu
n_solution_files	Number of solution files found
first_solution_file	First solution file
last_solution_file	Last solution file

Material parameters

Field	Meaning
E	Young's modulus
nu	Poisson's ratio
lambda	First Lamé parameter
mu	Second Lamé parameter
rho	Density
c_damp	Damping coefficient

Loading parameters

Field	Meaning
F0	Nominal force amplitude
traction_type	Type of applied surface traction
spatial_profile	Spatial profile of the applied traction
traction_amplitude_y_nominal_uniform	Nominal uniform traction amplitude in the y direction
frequency_hz	Loading frequency, if applicable
phase	Loading phase, if applicable
load_start_time	Start time of the applied load
load_end_time	End time of the applied load
load_center_x	Load center coordinate in x
load_center_y	Load center coordinate in y
load_center_z	Load center coordinate in z
load_sigma_x	Load width in x for Gaussian profiles
load_sigma_y	Load width in y for Gaussian profiles
load_sigma_z	Load width in z for Gaussian profiles
load_center_x_rel	Relative load center coordinate in x
load_center_z_rel	Relative load center coordinate in z
load_sigma_x_rel	Relative Gaussian width in x
load_sigma_z_rel	Relative Gaussian width in z
moving_direction	Direction of motion for moving loads
load_velocity	Physical velocity of the moving load
load_velocity_rel	Relative velocity of the moving load
impact_time	Central time of the impact or pulse load
impact_duration	Duration of the impact or pulse load

Some parameters may be unused depending on the selected traction_type. They are still stored to keep a fixed schema across all samples.

Geometry and mesh parameters

Field	Meaning
L	Beam length
H	Beam height
B	Beam width
A	Cross-sectional area
I	Second moment of area
nx	Nominal number of mesh divisions in x
ny	Nominal number of mesh divisions in y
nz	Nominal number of mesh divisions in z
lc	Nominal mesh size

Boundary, time, and storage information

Field	Meaning
dirichlet_boundary_ids	Boundary IDs with Dirichlet conditions
neumann_boundary_ids	Boundary IDs with Neumann conditions
dt	Time step size
t_end	Final simulation time
output_dt	Output time interval
n_nodes	Number of nodes read from the output mesh
n_cells	Number of cells read from the output mesh
n_edges	Number of directed graph edges
n_saved_times	Number of saved output times
snapshot_storage_format	Storage format used for snapshot fields

---

Dataset Creation

Curation Rationale

The dataset was created to provide simulation data for machine learning models that learn the dynamic response of 3D elastic structures.

The goal is to expose models to different combinations of geometry, material properties, damping, and loading conditions, while keeping a consistent data structure across samples.

Source Data

The data are fully synthetic. They are generated by numerical finite element simulations of 3D elastic beams.

Data Collection and Processing

For each simulation:

1. A set of input parameters is sampled.
2. A 3D beam mesh is generated or loaded.
3. The linear elastodynamic problem is solved with deal.II.
4. The mesh and physical fields are exported to .pvtu or .vtu files.
5. The exported simulation data are converted into Hugging Face datasets.

The governing equation is the linear elastodynamic equation:

  c * du/dt - div(sigma(u)) = f

where:

Symbol	Meaning
u(x,t)	Displacement field
du/dt	Velocity field
rho	Material density
c	Damping coefficient
f(x,t)	Body force
sigma(u)	Linear elastic stress tensor

The material is linear, isotropic, and elastic.

The stress tensor is:

sigma(u) = lambda * tr(epsilon(u)) * I + 2 * mu * epsilon(u)

with:

epsilon(u) = 0.5 * (grad(u) + grad(u)^T)

The Lamé parameters lambda and mu are computed from Young's modulus E and Poisson's ratio nu.

Continuous parameters are sampled using Latin Hypercube Sampling in a normalized space [0, 1]^d. Each sampled value is then mapped to its physical range using either a uniform or log-uniform transformation.

Who are the source data producers?

The source data are produced automatically by the simulation pipeline. No human-generated text, personal data, or user-generated content is included.

---

Personal and Sensitive Information

This dataset does not contain personal, sensitive, or private information.

All samples are generated synthetically from numerical simulations.

---

Bias, Risks, and Limitations

The dataset is limited by the numerical model and simulation setup used to generate it.

Main limitations include:

• the material model is linear elastic and isotropic;
• the results depend on the mesh resolution;
• the loading profiles are limited to the implemented traction models;
• the data are synthetic and may not represent experimental noise or real structural uncertainty;
• the dataset should not be treated as a certified engineering benchmark;
• acceleration may be computed by the solver but is not stored in the current Hugging Face dataset.

Recommendations

Users should verify the assumptions of the dataset before using it for engineering or scientific conclusions.

For machine learning research, users should consider:

• checking the distribution of geometry, material, and loading parameters;
• normalizing physical quantities before training;
• validating models on held-out simulations;
• avoiding extrapolation far outside the sampled parameter ranges;
• verifying mesh consistency when using graph-based models.

---

Loading Profiles

Possible values of traction_type include:

traction_type	Meaning
uniform	Uniform surface traction
gaussian_step	Spatial Gaussian load active over a time window
gaussian_harmonic	Spatial Gaussian load with harmonic time dependence
gaussian_pulse	Spatial Gaussian load with pulse-like time dependence
moving_gaussian	Gaussian load moving along a prescribed direction

Possible values of spatial_profile include:

spatial_profile	Meaning
uniform	No spatial localization
x	Gaussian localization along x only
xz	Gaussian localization along x and z

A negative sigma value may be used to disable localization in one direction. For example:

load_sigma_z < 0

means that the load is uniform along the z direction.

---

Minimal Usage Example

from datasets import load_dataset
import numpy as np

repo_id = "fastcomputing/first_beam3d_test_single_split"

geometry = load_dataset(repo_id, name="geometry", split="total")
snapshot = load_dataset(repo_id, name="snapshot", split="total")
metadata = load_dataset(repo_id, name="metadata", split="total")

sample_idx = 0

geom = geometry[sample_idx]
dyn = snapshot[sample_idx]
meta = metadata[sample_idx]

points_x = np.asarray(geom["points_x"], dtype=np.float32)
points_y = np.asarray(geom["points_y"], dtype=np.float32)
points_z = np.asarray(geom["points_z"], dtype=np.float32)
cells = np.asarray(geom["cells"], dtype=np.int64)
edge_index = np.asarray(geom["edge_index"], dtype=np.int64)

u = np.stack(
    [
        np.asarray(dyn["displacement_x"], dtype=np.float32),
        np.asarray(dyn["displacement_y"], dtype=np.float32),
        np.asarray(dyn["displacement_z"], dtype=np.float32),
    ],
    axis=-1,
)

x = np.stack(
    [
        np.asarray(dyn["points_x"], dtype=np.float32),
        np.asarray(dyn["points_y"], dtype=np.float32),
        np.asarray(dyn["points_z"], dtype=np.float32),
    ],
    axis=-1,
)

print("points:", points.shape)        # (N, 3)
print("cells:", cells.shape)          # (C, 8)
print("edge_index:", edge_index.shape) # (2, E)
print("u:", u.shape)                  # (T, N, 3)
print("metadata keys:", meta.keys())

---

Dataset Card Authors

FAST Computing System theme TOS Privacy About Careers Models