--- dataset_info: - config_name: geometry features: - name: sample_id dtype: int32 - name: points_x list: float32 - name: points_y list: float32 - name: points_z list: float32 - name: cells list: list: int32 - name: edge_index list: list: int32 - name: constraint_mask_x list: int32 - name: constraint_mask_y list: int32 - name: constraint_mask_z list: int32 - name: constraint_value_x list: float32 - name: constraint_value_y list: float32 - name: constraint_value_z list: float32 - name: boundary_id list: int32 - name: node_type list: int32 splits: - name: total num_bytes: 8280604 num_examples: 3 download_size: 8191127 dataset_size: 8280604 - config_name: metadata features: - name: sample_id dtype: int32 - name: valid dtype: bool - name: sample_name dtype: string - name: sample_dir dtype: string - name: geo_path dtype: string - name: mesh_path dtype: string - name: result_dir dtype: string - name: mpi_np dtype: int32 - name: solver_executable dtype: string - name: gmsh_executable dtype: string - name: solution_file_type dtype: string - name: n_solution_files dtype: int32 - name: first_solution_file dtype: string - name: last_solution_file dtype: string - name: E dtype: float64 - name: nu dtype: float64 - name: lambda dtype: float64 - name: mu dtype: float64 - name: rho dtype: float64 - name: c_damp dtype: float64 - name: F0 dtype: float64 - name: traction_type dtype: string - name: spatial_profile dtype: string - name: traction_amplitude_y_nominal_uniform dtype: float64 - name: frequency_hz dtype: float64 - name: phase dtype: float64 - name: load_start_time dtype: float64 - name: load_end_time dtype: float64 - name: load_center_x dtype: float64 - name: load_center_y dtype: float64 - name: load_center_z dtype: float64 - name: load_sigma_x dtype: float64 - name: load_sigma_y dtype: float64 - name: load_sigma_z dtype: float64 - name: load_center_x_rel dtype: float64 - name: load_center_z_rel dtype: float64 - name: load_sigma_x_rel dtype: float64 - name: load_sigma_z_rel dtype: float64 - name: moving_direction dtype: int32 - name: load_velocity dtype: float64 - name: load_velocity_rel dtype: float64 - name: impact_time dtype: float64 - name: impact_duration dtype: float64 - name: L dtype: float64 - name: H dtype: float64 - name: B dtype: float64 - name: A dtype: float64 - name: I dtype: float64 - name: nx dtype: int32 - name: ny dtype: int32 - name: nz dtype: int32 - name: lc dtype: float64 - name: dirichlet_boundary_ids list: int32 - name: neumann_boundary_ids list: int32 - name: dt dtype: float64 - name: t_end dtype: float64 - name: output_dt dtype: float64 - name: n_nodes dtype: int32 - name: n_cells dtype: int32 - name: n_edges dtype: int32 - name: n_saved_times dtype: int32 - name: snapshot_storage_format dtype: string splits: - name: total num_bytes: 2437 num_examples: 3 download_size: 86195 dataset_size: 2437 - config_name: snapshot features: - name: sample_id dtype: int32 - name: displacement_x list: list: float32 - name: displacement_y list: list: float32 - name: displacement_z list: list: float32 - name: velocity_x list: list: float32 - name: velocity_y list: list: float32 - name: velocity_z list: list: float32 - name: body_force_x list: list: float32 - name: body_force_y list: list: float32 - name: body_force_z list: list: float32 - name: traction_x list: list: float32 - name: traction_y list: list: float32 - name: traction_z list: list: float32 splits: - name: total num_bytes: 3305606460 num_examples: 3 download_size: 3305745573 dataset_size: 3305606460 configs: - config_name: geometry data_files: - split: total path: geometry/total-* - config_name: metadata data_files: - split: total path: metadata/total-* - config_name: snapshot data_files: - split: total path: snapshot/total-* license: other language: - en tags: - deal - neural_operators - graph-neural-networks pretty_name: Beam3D Elastic Dynamics Dataset --- # 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: ```python 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: ```text N = number of mesh nodes C = number of hexahedral cells E = number of directed graph edges ``` ### `points` `points` stores the node coordinates: ```text points_x[i] = [x_i] points_y[i] = [y_i] points_z[i] = [z_i] ``` Shape: ```text (N, ) ``` ### `cells` `cells` stores the hexahedral finite element connectivity. Each row contains the 8 node indices of one hexahedral cell: ```text cells[c] = [n0, n1, n2, n3, n4, n5, n6, n7] ``` Shape: ```text (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: ```text edge_index[:, e] = [source_node, target_node] ``` Shape: ```text (2, E) ``` The local hexahedral edges used to build the graph are: ```text (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: ```text (N, ) ``` Examples: ```text [1] -> fixed in x node [0] -> free node ``` ### `constraint_value` `constraint_value_x` stores the prescribed displacement in x value for constrained components. Shape: ```text (N, ) ``` For a homogeneous fixed boundary condition: ```text 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: ```text (N,) ``` It answers: ```text Which mesh boundary does this node belong to? ``` Example: ```text 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: ```text (N,) ``` Current convention: ```text 0 = internal node 1 = Dirichlet boundary node 2 = Neumann boundary node 3 = boundary node without explicitly assigned boundary condition ``` In short: ```text 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: ```text T = number of saved output times N = number of mesh nodes ``` Examples: ```text 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: ```python 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: ```text 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: ```text sigma(u) = lambda * tr(epsilon(u)) * I + 2 * mu * epsilon(u) ``` with: ```text 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: ```text load_sigma_z < 0 ``` means that the load is uniform along the z direction. --- ## Minimal Usage Example ```python 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