Allow to add data to a System

Author: Luthaf

rascaline-c-api/src/calculator.rs

@@ -393,11 +393,11 @@ pub unsafe extern fn rascal_calculator_compute(
         }
         check_pointers!(calculator, descriptor, systems);
 
-        // Create a Vec<Box<dyn System>> from the passed systems
+        // Create a Vec<System> from the passed systems
         let c_systems = std::slice::from_raw_parts_mut(systems, systems_count);
         let mut systems = Vec::with_capacity(c_systems.len());
         for system in c_systems {
-            systems.push(Box::new(system) as Box<dyn System>);
+            systems.push(System::new(system));
         }
 
         let c_gradients = std::slice::from_raw_parts(options.gradients, options.gradients_count);

rascaline-c-api/src/system.rs

@@ -3,7 +3,7 @@ use std::ffi::CStr;
 
 use rascaline::types::{Vector3D, Matrix3};
 use rascaline::systems::{SimpleSystem, Pair, UnitCell};
-use rascaline::{Error, System};
+use rascaline::{Error, SystemBase};
 
 use crate::RASCAL_SYSTEM_ERROR;
 
@@ -111,7 +111,7 @@ pub struct rascal_system_t {
 unsafe impl Send for rascal_system_t {}
 unsafe impl Sync for rascal_system_t {}
 
-impl<'a> System for &'a mut rascal_system_t {
+impl<'a> SystemBase for &'a mut rascal_system_t {
     fn size(&self) -> Result<usize, Error> {
         let function = self.size.ok_or_else(|| Error::External {
             status: RASCAL_SYSTEM_ERROR,
@@ -424,7 +424,7 @@ pub unsafe extern fn rascal_basic_systems_read(
     catch_unwind(move || {
         check_pointers!(path, systems, count);
         let path = CStr::from_ptr(path).to_str()?;
-        let simple_systems = rascaline::systems::read_from_file(path)?;
+        let simple_systems = rascaline::systems::read_simple_systems_from_file(path)?;
 
         let mut c_systems = Vec::with_capacity(simple_systems.len());
         for system in simple_systems {

rascaline/benches/lode-spherical-expansion.rs

@@ -1,24 +1,16 @@
 #![allow(clippy::needless_return)]
-use rascaline::{Calculator, System, CalculationOptions};
+use rascaline::{Calculator, CalculationOptions};
 
 use criterion::{BenchmarkGroup, Criterion, measurement::WallTime, SamplingMode};
 use criterion::{criterion_group, criterion_main};
 
-fn load_systems(path: &str) -> Vec<Box<dyn System>> {
-    let systems = rascaline::systems::read_from_file(format!("benches/data/{}", path))
-        .expect("failed to read file");
-
-    return systems.into_iter()
-        .map(|s| Box::new(s) as Box<dyn System>)
-        .collect()
-}
-
 fn run_spherical_expansion(mut group: BenchmarkGroup<WallTime>,
     path: &str,
     gradients: bool,
     test_mode: bool,
 ) {
-    let mut systems = load_systems(path);
+    let mut systems = rascaline::systems::read_from_file(format!("benches/data/{}", path))
+        .expect("failed to read file");
 
     if test_mode {
         // Reduce the time/RAM required to test the benchmarks code.

rascaline/benches/soap-power-spectrum.rs

@@ -1,27 +1,18 @@
 #![allow(clippy::needless_return)]
 
-use rascaline::{Calculator, System, CalculationOptions};
+use rascaline::{Calculator, CalculationOptions};
 
 use criterion::{BenchmarkGroup, Criterion, measurement::WallTime, SamplingMode};
 use criterion::{criterion_group, criterion_main};
 
-
-fn load_systems(path: &str) -> Vec<Box<dyn System>> {
-    let systems = rascaline::systems::read_from_file(format!("benches/data/{}", path))
-        .expect("failed to read file");
-
-    return systems.into_iter()
-        .map(|s| Box::new(s) as Box<dyn System>)
-        .collect()
-}
-
 fn run_soap_power_spectrum(
     mut group: BenchmarkGroup<WallTime>,
     path: &str,
     gradients: bool,
     test_mode: bool,
 ) {
-    let mut systems = load_systems(path);
+    let mut systems = rascaline::systems::read_from_file(format!("benches/data/{}", path))
+        .expect("failed to read file");
 
     if test_mode {
         // Reduce the time/RAM required to test the benchmarks code.

rascaline/benches/soap-spherical-expansion.rs

@@ -1,24 +1,16 @@
 #![allow(clippy::needless_return)]
-use rascaline::{Calculator, System, CalculationOptions};
+use rascaline::{Calculator, CalculationOptions};
 
 use criterion::{BenchmarkGroup, Criterion, measurement::WallTime, SamplingMode};
 use criterion::{criterion_group, criterion_main};
 
-fn load_systems(path: &str) -> Vec<Box<dyn System>> {
-    let systems = rascaline::systems::read_from_file(format!("benches/data/{}", path))
-        .expect("failed to read file");
-
-    return systems.into_iter()
-        .map(|s| Box::new(s) as Box<dyn System>)
-        .collect()
-}
-
 fn run_spherical_expansion(mut group: BenchmarkGroup<WallTime>,
     path: &str,
     gradients: bool,
     test_mode: bool,
 ) {
-    let mut systems = load_systems(path);
+    let mut systems = rascaline::systems::read_from_file(format!("benches/data/{}", path))
+        .expect("failed to read file");
 
     if test_mode {
         // Reduce the time/RAM required to test the benchmarks code.

rascaline/examples/compute-soap.rs

@@ -1,14 +1,10 @@
 use metatensor::Labels;
-use rascaline::{Calculator, System, CalculationOptions};
+use rascaline::{Calculator, CalculationOptions};
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     // load the systems from command line argument
     let path = std::env::args().nth(1).expect("expected a command line argument");
-    let systems = rascaline::systems::read_from_file(path)?;
-    // transform systems into a vector of trait objects (`Vec<Box<dyn System>>`)
-    let mut systems = systems.into_iter()
-        .map(|s| Box::new(s) as Box<dyn System>)
-        .collect::<Vec<_>>();
+    let mut systems = rascaline::systems::read_from_file(path)?;
 
     // pass hyper-parameters as JSON
     let parameters = r#"{

rascaline/examples/profiling.rs

@@ -1,5 +1,5 @@
 use metatensor::{TensorMap, Labels};
-use rascaline::{Calculator, System, CalculationOptions};
+use rascaline::{Calculator, CalculationOptions};
 
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     let path = std::env::args().nth(1).expect("expected a command line argument");
@@ -28,10 +28,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 /// Compute SOAP power spectrum, this is the same code as the 'compute-soap'
 /// example
 fn compute_soap(path: &str) -> Result<TensorMap, Box<dyn std::error::Error>> {
-    let systems = rascaline::systems::read_from_file(path)?;
-    let mut systems = systems.into_iter()
-        .map(|s| Box::new(s) as Box<dyn System>)
-        .collect::<Vec<_>>();
+    let mut systems = rascaline::systems::read_from_file(path)?;
 
     let parameters = r#"{
         "cutoff": 5.0,

rascaline/src/calculator.rs

@@ -285,7 +285,7 @@ impl Calculator {
     }
 
     #[time_graph::instrument(name="Calculator::prepare")]
-    fn prepare(&mut self, systems: &mut [Box<dyn System>], options: CalculationOptions) -> Result<TensorMap, Error> {
+    fn prepare(&mut self, systems: &mut [System], options: CalculationOptions) -> Result<TensorMap, Error> {
         let default_keys = self.implementation.keys(systems)?;
         let keys = match options.selected_keys {
             Some(keys) if keys.is_empty() => {
@@ -446,14 +446,14 @@ impl Calculator {
     /// features.
     pub fn compute(
         &mut self,
-        systems: &mut [Box<dyn System>],
+        systems: &mut [System],
         options: CalculationOptions,
     ) -> Result<TensorMap, Error> {
         let mut native_systems;
         let systems = if options.use_native_system {
             native_systems = Vec::with_capacity(systems.len());
             for system in systems {
-                native_systems.push(Box::new(SimpleSystem::try_from(&**system)?) as Box<dyn System>);
+                native_systems.push(System::new(SimpleSystem::try_from(&**system)?) as System);
             }
             &mut native_systems
         } else {

rascaline/src/calculators/atomic_composition.rs

@@ -35,7 +35,7 @@ impl CalculatorBase for AtomicComposition {
         &[]
     }
 
-    fn keys(&self, systems: &mut [Box<dyn System>]) -> Result<Labels, Error> {
+    fn keys(&self, systems: &mut [System]) -> Result<Labels, Error> {
         return CenterSpeciesKeys.keys(systems);
     }
 
@@ -47,7 +47,7 @@ impl CalculatorBase for AtomicComposition {
         return vec!["structure", "center"];
     }
 
-    fn samples(&self, keys: &Labels, systems: &mut [Box<dyn System>]) -> Result<Vec<Labels>, Error> {
+    fn samples(&self, keys: &Labels, systems: &mut [System]) -> Result<Vec<Labels>, Error> {
         assert_eq!(keys.names(), ["species_center"]);
         let mut samples = Vec::new();
         for [species_center_key] in keys.iter_fixed_size() {
@@ -84,7 +84,7 @@ impl CalculatorBase for AtomicComposition {
         &self,
         keys: &Labels,
         _samples: &[Labels],
-        _systems: &mut [Box<dyn System>],
+        _systems: &mut [System],
     ) -> Result<Vec<Labels>, Error> {
         // Positions/cell gradients of the composition are zero everywhere.
         // Therefore, we only return a vector of empty labels (one for each key).
@@ -110,7 +110,7 @@ impl CalculatorBase for AtomicComposition {
 
     fn compute(
         &mut self,
-        systems: &mut [Box<dyn System>],
+        systems: &mut [System],
         descriptor: &mut TensorMap,
     ) -> Result<(), Error> {
         assert_eq!(descriptor.keys().names(), ["species_center"]);

rascaline/src/calculators/dummy_calculator.rs

@@ -43,15 +43,15 @@ impl CalculatorBase for DummyCalculator {
         std::slice::from_ref(&self.cutoff)
     }
 
-    fn keys(&self, systems: &mut [Box<dyn System>]) -> Result<Labels, Error> {
+    fn keys(&self, systems: &mut [System]) -> Result<Labels, Error> {
         return CenterSpeciesKeys.keys(systems);
     }
 
     fn sample_names(&self) -> Vec<&str> {
         AtomCenteredSamples::sample_names()
     }
 
-    fn samples(&self, keys: &Labels, systems: &mut [Box<dyn System>]) -> Result<Vec<Labels>, Error> {
+    fn samples(&self, keys: &Labels, systems: &mut [System]) -> Result<Vec<Labels>, Error> {
         assert_eq!(keys.names(), ["species_center"]);
         let mut samples = Vec::new();
         for [species_center] in keys.iter_fixed_size() {
@@ -75,7 +75,7 @@ impl CalculatorBase for DummyCalculator {
         }
     }
 
-    fn positions_gradient_samples(&self, keys: &Labels, samples: &[Labels], systems: &mut [Box<dyn System>]) -> Result<Vec<Labels>, Error> {
+    fn positions_gradient_samples(&self, keys: &Labels, samples: &[Labels], systems: &mut [System]) -> Result<Vec<Labels>, Error> {
         debug_assert_eq!(keys.count(), samples.len());
         let mut gradient_samples = Vec::new();
         for ([species_center], samples) in keys.iter_fixed_size().zip(samples) {
@@ -110,7 +110,7 @@ impl CalculatorBase for DummyCalculator {
     }
 
     #[time_graph::instrument(name = "DummyCalculator::compute")]
-    fn compute(&mut self, systems: &mut [Box<dyn System>], descriptor: &mut TensorMap) -> Result<(), Error> {
+    fn compute(&mut self, systems: &mut [System], descriptor: &mut TensorMap) -> Result<(), Error> {
         if self.name.contains("log-test-info:") {
             info!("{}", self.name);
         } else if self.name.contains("log-test-warn:") {