| --- |
| 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 |
