Results from "Shape Optimization using a Neural Implicit Geometry Representation Framework"

Description

This repository contains the data supporting the publication “Shape Optimization Using a Neural Implicit Geometry Representation Framework.”

Context and methodology

This dataset was created in the context of computational engineering shape optimization. The publication investigates a neural implicit geometry representation framework for gradient-based shape optimization. In this framework, geometries are represented by a neural signed distance function (SDF), whose zero-level set defines the geometry boundary. The neural decoder is controlled by a spatially continuous latent field, which provides local geometric control while keeping the representation differentiable.

The dataset serves two main purposes. First, it provides the primitive-shape SDF training data used to train the neural decoder. These data are used to teach the decoder local surface behavior rather than the global shape of a specific object. Second, it provides the numerical results supporting the reconstruction and optimization studies presented in the publication, including network training histories, reconstruction-error studies, drag-minimization histories, a comparison with free-form deformation (FFD), and an example involving topological changes.

The training data were generated from randomly created primitive-shape scenes consisting of simple objects such as cubes, spheres, and cylinders. For each scene, points were sampled in a normalized three-dimensional domain and additionally near the geometry surfaces. The signed distance value was evaluated analytically for each sample point. The resulting samples were used to train a neural decoder that maps transformed spatial coordinates and interpolated latent vectors to signed distance values.

The numerical optimization results correspond to three-dimensional drag-minimization problems. The proposed neural SDF-based geometry representation is evaluated on different benchmark cases, compared with classical FFD, and used in an experiment demonstrating that the implicit representation can realize topological changes during optimization.

Technical details

The dataset is organized into two main folders:

data/training_data/
data/numerical_results/

The folder data/training_data/ contains the primitive-shape SDF training samples. The file

data/training_data/primitives_2026_02_15_primitive_shapes.json

lists the generated primitive scenes. The corresponding sample files are stored as compressed NumPy files in

data/training_data/2026_02_15_primitive_shapes/

Each .npz file contains the arrays neg and pos. Each row stores one signed-distance sample in the form

x, y, z, sdf

where x, y, and z are spatial coordinates and sdf is the signed distance value. Negative values correspond to points inside the geometry and positive values to points outside.

The folder data/numerical_results/ contains the processed numerical results used for the figures, tables, and comparisons in the publication. It is structured as follows:

data/numerical_results/
├── geometry_reconstruction/
│   ├── network_training/
│   └── reconstruction_test_cases/
└── optimization/
    ├── experiment_1/
    ├── experiment_2/
    └── experiment_3/

The folder geometry_reconstruction/network_training/ contains training-loss histories for neural decoders with different latent dimensions. The files epoch_loss_cl08_clean.csv, epoch_loss_cl16_clean.csv, and epoch_loss_cl32_clean.csv correspond to latent dimensions 8, 16, and 32.

The folder geometry_reconstruction/reconstruction_test_cases/ contains reconstruction-error studies for the flow-channel geometry.

The folder optimization/ contains optimization histories for the numerical examples:

experiment_1/   cube drag-minimization benchmark
experiment_2/   comparison with FFD
experiment_3/   perforated cube with topological changes

All numerical results are stored as CSV files and can be opened with any CSV-capable software. Python with pandas is recommended for processing the tabular data.

The training data are stored as NumPy .npz files and require Python with NumPy for direct use.

To train the neural decoder or reproduce the complete workflow, the accompanying software project is required:

https://doi.org/10.5281/zenodo.20206062

Further details

The training data provide signed-distance samples for primitive-shape scenes and are intended to be used together with the accompanying source code project. They do not contain a standalone training pipeline.

The numerical-results files contain processed histories and error metrics rather than all intermediate simulation files. They are intended to support the plots, tables, and comparisons reported in the publication.