DaRUS (University of Stuttgart)
Not a member yet
2037 research outputs found
Sort by
Replication Data for: Robustly optimal dynamics for active matter reservoir computing (Gaimann and Klopotek, 2025)
No full text
This repository contains raw and post-processed replication data for the publication "Robustly optimal dynamics for active matter reservoir computing" (Gaimann and Klopotek, 2025).
The datasets contain physical observables recorded during non-equilibrium simulations of active matter systems (swarms) driven by an external force. These simulations serve as information processors in a reservoir computing setup.
We provide replication data for all figures and supplementary videos shown in our publication:
speed-controller
speed-controller, with an integration time step of 2e-3
speed-controller, with a maximum correlation delay time of 75 integration time steps
speed-controller, without external driving (undriven)
speed-controller, with a single agent
speed-controller, with two agents
speed-controller, with 500 agents (overdamped phenomenology)
speed-controller, with initial transient (burn-in phase)
speed-controller, with 12 integration time steps predicted ahead
speed-controller, with 50 integration time steps predicted ahead
speed-controller, with 100 integration time steps predicted ahead
speed-controller, with Hénon-Heiles driving protocol
speed-controller, with Hénon-Heiles driving protocol, Lyapunov time-adjusted prediction (638 integration time steps), and maximum correlation delay time of 75 integration time steps
speed-controller, with Rössler driving protocol
speed-controller, with Rössler driving protocol, Lyapunov time-adjusted prediction (150 integration time steps), and maximum correlation delay time of 75 integration time steps
speed-controller, with Chua driving protocol
speed-controller, with Chua driving protocol, Lyapunov time-adjusted prediction (18 integration time steps), and maximum correlation delay time of 75 integration time steps
speed-controller, with Lorenz-96 driving protocol
speed-controller, with Lorenz-96 driving protocol, Lyapunov time-adjusted prediction (17 integration time steps), and maximum correlation delay time of 75 integration time steps
speed-controller, with a larger correlation recording delay time of 500 integration time steps
damping analysis, with non-interacting agents
damping analysis, with interacting agents
damping analysis, with non-interacting agents and an integration time step of 2e-3
damping analysis, with interacting agents and an integration time step of 2e-3
alignment force, with speed-controller settings of Lymburn et al. (2021)
alignment force, with overdamped speed-controller settings
homing force strength vs. speed-controller strength, with speed-controller settings of Lymburn et al. (2021)
homing force strength vs. speed-controller strength, with overdamped speed-controller settings
homing force strength vs. speed-controller target agent speed
number of agents vs. Gaussian white noise strength, with speed-controller settings of Lymburn et al. (2021)
number of agents vs. Gaussian white noise strength, with overdamped speed-controller settings
reproduction of the dynamical regimes analyzed in Lymburn et al. (2021) (Fig. 7)
reproduction of the (driven) alignment strength vs. repulsion strength parameter scans in Lymburn et al. (2021) (Fig. 6B, Fig. 8A)
reproduction of the undriven alignment strength vs. repulsion strength parameter scan in Lymburn et al. (2021) (Fig. 6A)
The Lorenz-63 driving protocol was generated on the fly during the simulation. We also provide the raw chaotic time series used as benchmark driving protocols:
Hénon-Heiles
Rössler
Chua
Lorenz-96
Each dataset typically contains 400 parameter combinations. Each parameter combination contains four files:
config.yaml: controlled variables
simulation_output_train.h5: physical simulation observables in first (training) run
simulation_output_test.h5: physical simulation observables in second (testing) run
reservoir_computer_output.h5: observables related to reservoir computing and time series prediction
The second run has a different chaotic driving protocol, using the same underlying dynamical system (chaotic attractor) but different initial conditions.
Only the first file is generated if the dataset contains a simulation without an external driving force (undriven). By default, for all driven simulations, physical observables are only recorded for the test run for a full reservoir computing train/test cycle. Each simulation typically consists of 1,000.00 time units (50,000 integration time steps of 0.02 time units by default). A burn-in phase of 20.0 simulation time units (1,000 integration time steps of 0.02 time units by default) takes place at the beginning of each simulation, which is not recorded by default (only recorded in the "speed-controller, with initial transient" dataset). Controlled variables are stored as HDF5 attributes. At each step, we predict by default 25 integration time steps ahead (=0.45283 L63-Lyapunov times). For Lyapunov times adjusted attractor predictions, we predict n integration time steps ahead that equal 0.45283 Lyapunov times of the corresponding attractor.
The simulation output files contain:
agent_observables: positions, velocities, total forces, velocity fluctuations for all agents; for the first 20.0 simulation time units
frame_observables: driver position (external driving trajectory / input time series), center of mass (taking periodic boundary conditions into account), agent-averaged observables, scalar polarity, scalar rotation; for the full simulation
histograms: binned agent observables and derived quantities; for the full simulation
radially_binned: radial distribution function (agent count), connected velocity correlation, cumulative velocity correlation
time_lags: auto-correlations of agent observables and derived quantities, two-time correlations of agent observables and derived quantities
reference_frame_steps: reference frames (measured in integration steps) for the recording of delay-based quantities in time_lags
The reservoir computer output files contain:
linear_regression_model: the weights of the linear model (readout layer)
observer_kernel_params: placement positions and widths of the Gaussian observation kernels
predictions_train: n-steps-ahead prediction using the trained linear model, on training data
predictions_test: n-steps-ahead prediction using the trained linear model, on testing data
Aggregates of physical observables across all parameter combinations in a single dataset are stored as CSV files for convenience, the relevant observable is indicated by the file name. Files that carry the "time_avg" tag are averaged over all simulation time steps, for the "ensemble_avg" averaged over all seeds (only one seed is used here), and for the "array_avg" averaged over all recorded entries (typically samples at different time steps). We provide the following aggregated observables that were processed to generate figures in our associated publication:
lymburn_correlation_coefficient: Correlation coefficient, predictive performance
agent_avg_msd_at_lyapunov_time_step=55: Agent-averaged mean squared displacement at the Lyapunov integration time step of the Lorenz-63 attractor (after 55 integration time steps of 0.02 each)
first_local_min.array_avg.h5?connected_velocity_correlation: First local minimum of the connected velocity correlation function, averaged over all recorded samples
mean_speed: Agent-averaged speed
scalar_polarity: Scalar polarity
scalar_rotation: Scalar rotation
attanasi_susceptibility: Dynamical susceptibility
The supplementary videos generated using this raw data are published as: Gaimann, M. U., & Klopotek, M. (2025). Supplementary Videos for: Robustly optimal dynamics for active matter reservoir computing (Gaimann and Klopotek, 2025). DaRUS. doi:10.18419/DARUS-4619.
Changelog
V2
Added raw random uniform driver trajectory files confined to a circle with radius 4.0, with different change intervals (used to compute the short-term memory capacity)
Added datasets for the computation of the short-term memory capacity for parameter combinations of the speed-controller parameter scan, with different driving protocols (Lorenz-63, random uniform with different change intervals). These datasets provide the full recorded Gaussian kernel observations of the simulation runs; datasets labeled with "memory-capacity" contain observables related to the memory capacity.
Added datasets of a simple Echo State Network (ESN) comparison, following the recipe in Hinaut and Trouvain (2021) (https://inria.hal.science/hal-03203318v2)
Added a dataset for the undriven active matter simulation of the homing-speed-controller-strength dataset with parameter combination K_h=483 and K_sc=0.0207 (highly condensed droplet case)
Updated datasets used for figures in the main text with aggregates of more performance metrics (NMSE, NRMSE, sMAPE, Pearson correlation coefficient of the y coordinate computed according to Lymburn et al. (2021))
</p
The 11th SPE Comparative Solution Project: Submitted Data
No full text
Data submitted to the 11th Society of Petroleum Engineers Comparative Solution Project. Contains the sparse and dense data files of 77 results submitted by 18 participating groups for three cases SPE11A-C. Each zip file contains one such result, where the name speX_NAMEY.zip indicates Result Y for Case SPE11X of Participant NAME.
Unpacking a result file yields one sparse data file speX_time_series.csv, several dense data files speX_spatial_map_TIME.csv, and, optionally, performance data files. A sparse data file contains the evolution of several scalar quantities over time, while a dense data file contains the spatial distribution of several scalar quantities at a particular reporting time step. For more information, see the related publication.
The results can be processed by the scripts provided in the repository github.com/Simulation-Benchmarks/11thSPE-CSP. From the repository's website, access to a Jupyter Hub is enabled that allows to run the scripts on the full dataset.
</p
Surrogate model for: "Numerical Investigation of Preferential Flow Paths in Enzymatically Induced Calcite Precipitation supported by Bayesian Model Analysis"
No full textEvaluations and scripts for replication of "Numerical Investigation of Preferential Flow Paths in Enzymatically Induced Calcite Precipitation supported by Bayesian Model Analysis".
This includes model evaluations, visualization, surrogate training and evaluation and Bayesian model analysis
Data for: Free-energy perturbation in the exchange-correlation space accelerated by machine learning: Application to silica polymorphs
No full textData for the Publication Free-energy perturbation in the exchange-correlation space accelerated by machine learning: Application to silica polymorphs
This data set contains:
Data for/from the direct upsampling for the rung 1–3 functionals:
The effective harmonic potentials
The final moment-tensor potentials (for each phase and functional)
The training sets for the moment-tensor potentials (VASP OUTCARs)
Tables of the thermodynamic properties for each phase and functional
Input data for the functional evaluation procedure developed in the associated paper
</ul
Replication Data for: Dynamic breathing behaviour of the titanium- based metal–organic framework NTU-9 upon adsorption of water and organic solvents
No full textAll primary data files of the journal article mentioned can be found here. The data is structured by analysis technique. All files are tagged with the corresponding material. The characterization and catalysis data are recorded experimentally
Replication Data for: Modelling the collision kernel of fractal nanoparticle agglomerates in homogeneous isotropic turbulence
No full textThis data set contains the software and the simulation setups to reproduce the results shown in the related journal paper. The respective 'README.md' files provide further documentation on the utilised solvers and the performed simulation cases
Replication Data for: Super-resolution reconstruction of scalar fields from the pyrolysis of pulverised biomass using deep learning
No full text
README
body { font-family: system-ui, -apple-system, Segoe UI, Roboto, Helvetica, Arial, sans-serif; line-height: 1.5; padding: 1rem; max-width: 900px; margin: auto; }
code { font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, "Liberation Mono", monospace; }
pre { background: #f6f8fa; padding: 0.75rem; overflow: auto; border-radius: 6px; }
table { border-collapse: collapse; margin: 1rem 0; width: 100%; }
th, td { border: 1px solid #ddd; padding: 0.5rem; text-align: left; }
thead th { background: #fafbfc; }
h1, h2, h3, h4, h5, h6 { line-height: 1.25; }
Repository for publication: A. Shamooni et al., Super-resolution reconstruction of scalar fields from the pyrolysis of pulverised biomass using deep learning, Proc. Combust. Inst. (2025)
Containing
torch_code
The main Pytorch source code used for training/testing is provided in torch_code.tar.gz file.
torch_code_tradGAN
To compare with traditional GAN, we use the code in torch_code_tradGAN with similar particle-laden datasets. The source code is torch_code_tradGAN.tar.gz file.
datasets
The training/validation/testing datasets have been provided in lmdb format which is ready to use in the code. The datasets in datasets.tar.gz contain:
Training dataset:
data_train_OF-mass_kinematics_mk0x_1x_2x_FHIT_particle_128_Re52-2D_20736_lmdb.lmdb
Test dataset:
data_valid_inSample_OF-mass_kinematics_mk0x_1x_2x_FHIT_particle_128_Re52-2D_3456_lmdb.lmdb
Note that the samples from 9 DNS cases are collected in order (each case 2304 samples for training and 384 samples for testing) which can be recognized using the provided metadata file in each folder.
Out of distribution test datasets:
Out of distribution test dataset (used in Fig 10 of the paper):
data_valid_inSample_OF-mass_kinematics_mk3x_FHIT_particle_128_Re52-2D_nonUniform_1024_lmdb.lmdb |
We have two separate OOD DNS cases and from each we select 512 samples.
experiments
The main trained models are provided in experiments.tar.gz file. Each experiment contains the log file of the training, the last training state (for restart) and the model wights used in the publication.
Trained model using the main dataset (used in Figs 2-10 of the paper):
h_oldOrder_mk_700-11-c_PFT_Inp4TrZk_outTrZ_RRDBNetCBAM-4Prt_DcondPrtWav_f128g64b16_BS16x4_LrG45D5_DS-mk012-20k_LStandLog
To compare with traditional GAN, we use the code in torch_code_tradGAN with similar particle-laden datasets as above. The training consists of one pre-training step and two separate fine-tuning. One fine-tuning with the loss weights from the litreature and one fine-tuning with tuned loss weights. The final results are in experiments/trad_GAN/experiments/
Pre-trained traditional GAN model (used in Figs 8-9 of the paper):
train_RRDB_SRx4_particle_PSNR
Fine-tuned traditional GAN model with loss weights from lit. (used in Figs 8-9 of the paper)
train_ESRGAN_SRx4_particle_Nista_oneBlock
Fine-tuned traditional GAN model with optimized loss weights (used in Figs 8-9 of the paper)
train_ESRGAN_SRx4_particle_oneBlock_betaA
inference_notebooks
The inference_notebooks folder contains example notebooks to do inference. The folder contains "torch_code_inference" and "torch_code_tradGAN_inference". The "torch_code_inference" is the inference of main trained model. The "torch_code_tradGAN_inference" is the inference for traditional GAN approach.
Move the inference folders in each of these folders into the corresponding torch_code roots. Also create softlinks of datasets and experiments in the main torch_code roots. Note that in each notebook you must double check the required paths to make sure they are set correctly.
How to
Build the environment
To build the environment required for the training and inference you need Anaconda. Go to the torch_code folder and
conda env create -f environment.yml
Then create ipython kernel for post processing,
conda activate torch_22_2025_Shamooni_PCI
python -m ipykernel install --user --name ipyk_torch_22_2025_Shamooni_PCI --display-name "ipython kernel for post processing of PCI2025"
Perform training
It is suggested to create softlinks to the dataset folder directly in the torch_code folder:
cd torch_code
ln -s <path to the dataset folder> datasets
You can also simply move the datasets and inference forlders in the torch_code folder beside the cfd_sr folder and other files.
In general, we prefer to have a root structure as below:
root files and directories:
cfd_sr
datasets
experiments
inference
options
__init__.py
test.py
train.py
version.py
Then activate the conda environment
conda activate torch_22_2025_Shamooni_PCI
An example script to run on single node with 2 GPUs:
torchrun --standalone --nnodes=1 --nproc_per_node=2 train.py -opt options/train/condSRGAN/use_h_mk_700-011_PFT.yml --launcher pytorch
Make sure that the paths to datasets "dataroot_gt" and "meta_info_file" for both training and validation data in option files are set correctly.
</html
Dataset for geof3D: 3D SPARQL Geometry Functions, Test Artefacts, Queries, and Evaluation Results
No full textThis dataset accompanies the paper “geof3D: SPARQL Geometrical Functions for Co-Designing Buildings” and contains all resources required to reproduce the experiments, evaluations, and use cases presented in the work. It includes the full set of SPARQL extension functions used for 3D geometric operations, a collection of 3D geometries in Well-Known Text format used as input data, the SPARQL queries applied in the Low-Carbon Residential Lighthouse co-design use case, and the evaluation results generated from performance and correctness testing. Together, these components provide complete support for reproducing the workflows, validation steps, and analytical results described in the publication, enabling further research in semantic spatial computation and multi-disciplinary co-design
BlaVeS: Bladder Vessel Segmentation
No full text
The Bladder Vessel Segmentation (BlaVeS) dataset is the first publicly available dataset
for blood vessel segmentation in urinary bladder endoscopy images. It provides hand-labeled pixel-wise
annotations of prominent blood vessels to support bladder navigation, tumor monitoring, and biopsy site localization.
The dataset is designed to aid in developing deep learning models for improving orientation and navigation
during cystoscopic procedures.
A total of 50 representative images were selected from four clinical cystoscopic video
recordings (8 minutes in total). Each image has a 512×512 pixel resolution and is stored in PNG format.
Dataset Structure
pretraining/ (For initial model training)
training/ (Labeled images for training segmentation models)
training_augmented/ (Extended training set with augmented samples)
testing/
images/ (Input cystoscopic images)
input_image_1.png
input_image_2.png
...
groundtruth/ (Pixel-wise blood vessel masks)
mask_1.png
mask_2.png
...
</ul
Coupled mass-spring-damper system for nonlinear system identification - actuated with random static inputs - synthetically generated
No full textOverview
This dataset contains input-output data of a coupled mass-spring-damper system with a nonlinear force profile. The data was generated with statesim [1], a python package for simulating linear and nonlinear ODEs, for the system coupled-msd. The configuration .json files for the corresponding datasets (in-distribution and out-of-distribution) can be found in the respective folders. After creating the dataset, the files are stored in the raw folder. Then, they are split into subsets for training, testing, and validation and can be found in the processed folder; details about the splitting are found in the config.json file.
The dataset can be used to test system identification algorithms and methods that aim to identify nonlinear dynamics from input-output measurements. The training dataset is used to optimize the model parameters, the validation set for hyperparameter optimization, and the test set only for the final evaluation.
In [2], the authors use the same underlying dynamics to create their dataset.
Input generation
Input trajectories are piecewise constant trajectories.
Noise
Gaussian white noise of approximately 30dB is added at the output.
Statistics
The input and output size is one.
In-distribution data: 1,500,000 data points
Training: 120 trajectories of length 7500
Validation: 20 trajectories of length 7500
Test: 60 trajectories of length 7500
Out-of-distribution data: 10 times 3000 data points
10 different datasets were only used for testing. Each dataset contains 50 trajectories of length 6000.
References
Frank, D. statesim [Computer software]. https://github.com/Dany-L/statesim
Revay, M., Wang, R., & Manchester, I. R. (2020). A convex parameterization of robust recurrent neural networks. IEEE Control Systems Letters, 5(4), 1363-1368.
</ol