lazy_static in benchmarks

lazy_benchmarks.patch

diff --git a/Cargo.toml b/Cargo.toml
index 68e2fc36..5389a05e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -26,6 +26,7 @@ clap = "2"
 
 [dev-dependencies]
 bencher = "0.1"
+lazy_static = "0.2"
 rand = "0.3"
 
 [[bench]]
diff --git a/benches/argon.rs b/benches/argon.rs
index 8b1f6ce5..cb671589 100644
--- a/benches/argon.rs
+++ b/benches/argon.rs
@@ -3,53 +3,64 @@
 
 #[macro_use]
 extern crate bencher;
+#[macro_use]
+extern crate lazy_static;
 extern crate rand;
 extern crate lumol;
 extern crate lumol_input;
 
+use std::sync::RwLock;
+
 use bencher::Bencher;
 use rand::Rng;
 
-use lumol::sys::EnergyCache;
+use lumol::sys::{EnergyCache, System};
 use lumol::types::Vector3D;
 
 #[macro_use]
 mod utils;
 
 fn energy(bencher: &mut Bencher) {
-    let system = utils::get_system("argon");
+    lazy_static!(static ref SYSTEM: System = utils::get_system("argon"););
     bencher.iter(||{
-        let _ = system.potential_energy();
+        SYSTEM.potential_energy();
     })
 }
 
 fn forces(bencher: &mut Bencher) {
-    let system = utils::get_system("argon");
+    lazy_static!(static ref SYSTEM: System = utils::get_system("argon"););
     bencher.iter(||{
-        let _ = system.forces();
+        SYSTEM.forces();
     })
 }
 
 fn virial(bencher: &mut Bencher) {
-    let system = utils::get_system("argon");
+    lazy_static!(static ref SYSTEM: System = utils::get_system("argon"););
     bencher.iter(||{
-        let _ = system.virial();
+        SYSTEM.virial();
     })
 }
 
 fn cache_move_particle(bencher: &mut Bencher) {
-    let system = utils::get_system("argon");
-    let mut cache = EnergyCache::new();
-    cache.init(&system);
+    lazy_static!(
+        static ref SYSTEM: System = utils::get_system("argon");
+
+        static ref CACHE: RwLock<EnergyCache> = {
+            let mut cache = EnergyCache::new();
+            cache.init(&SYSTEM);
+            RwLock::new(cache)
+        };
+    );
 
     let mut rng = utils::get_rng(654646);
 
-    let particle: usize = rng.gen_range(0, system.size());
-    let mut delta = system[particle].position;
+    let particle: usize = rng.gen_range(0, SYSTEM.size());
+    let mut delta = SYSTEM[particle].position;
     delta += Vector3D::new(rng.gen(), rng.gen(), rng.gen());
 
+    let mut cache = CACHE.write().unwrap();
     bencher.iter(||{
-        cache.move_particles_cost(&system, vec![particle], &[delta])
+        cache.move_particles_cost(&SYSTEM, vec![particle], &[delta]);
     })
 }
 
diff --git a/benches/nacl.rs b/benches/nacl.rs
index a35af1f3..ab20ff4a 100644
--- a/benches/nacl.rs
+++ b/benches/nacl.rs
@@ -3,109 +3,131 @@
 
 #[macro_use]
 extern crate bencher;
+#[macro_use]
+extern crate lazy_static;
 extern crate rand;
 extern crate lumol;
 extern crate lumol_input;
 
+use std::sync::RwLock;
+
 use bencher::Bencher;
 use rand::Rng;
 
 use lumol::energy::{Ewald, SharedEwald, Wolf, GlobalPotential};
-use lumol::sys::EnergyCache;
+use lumol::sys::{EnergyCache, System};
 use lumol::types::Vector3D;
 
 #[macro_use]
 mod utils;
 
 fn energy_ewald(bencher: &mut Bencher) {
-    let system = utils::get_system("nacl");
+    lazy_static!(static ref SYSTEM: System = utils::get_system("nacl"););
     let ewald = SharedEwald::new(Ewald::new(9.5, 7));
 
     bencher.iter(||{
-        let _ = ewald.energy(&system);
+        ewald.energy(&SYSTEM);
     })
 }
 
 fn forces_ewald(bencher: &mut Bencher) {
-    let system = utils::get_system("nacl");
+    lazy_static!(static ref SYSTEM: System = utils::get_system("nacl"););
     let ewald = SharedEwald::new(Ewald::new(9.5, 7));
 
     bencher.iter(||{
-        let _ = ewald.forces(&system);
+        ewald.forces(&SYSTEM);
     })
 }
 
 fn virial_ewald(bencher: &mut Bencher) {
-    let system = utils::get_system("nacl");
+    lazy_static!(static ref SYSTEM: System = utils::get_system("nacl"););
     let ewald = SharedEwald::new(Ewald::new(9.5, 7));
 
     bencher.iter(||{
-        let _ = ewald.virial(&system);
+        ewald.virial(&SYSTEM);
     })
 }
 
 fn energy_wolf(bencher: &mut Bencher) {
-    let system = utils::get_system("nacl");
+    lazy_static!(static ref SYSTEM: System = utils::get_system("nacl"););
     let wolf = Wolf::new(12.0);
 
     bencher.iter(||{
-        let _ = wolf.energy(&system);
+        wolf.energy(&SYSTEM);
     })
 }
 
 fn forces_wolf(bencher: &mut Bencher) {
-    let system = utils::get_system("nacl");
+    lazy_static!(static ref SYSTEM: System = utils::get_system("nacl"););
     let wolf = Wolf::new(12.0);
 
     bencher.iter(||{
-        let _ = wolf.forces(&system);
+        wolf.forces(&SYSTEM);
     })
 }
 
 fn virial_wolf(bencher: &mut Bencher) {
-    let system = utils::get_system("nacl");
+    lazy_static!(static ref SYSTEM: System = utils::get_system("nacl"););
     let wolf = Wolf::new(12.0);
 
     bencher.iter(||{
-        let _ = wolf.virial(&system);
+        wolf.virial(&SYSTEM);
     })
 }
 
 fn cache_move_particle_ewald(bencher: &mut Bencher) {
-    let mut system = utils::get_system("nacl");
-    system.interactions_mut().set_coulomb(
-        Box::new(SharedEwald::new(Ewald::new(9.5, 7)))
+    lazy_static!(
+        static ref SYSTEM: System = {
+            let mut system = utils::get_system("nacl");
+            system.interactions_mut().set_coulomb(
+                Box::new(SharedEwald::new(Ewald::new(9.5, 7)))
+            );
+            system
+        };
+
+        static ref CACHE: RwLock<EnergyCache> = {
+            let mut cache = EnergyCache::new();
+            cache.init(&SYSTEM);
+            RwLock::new(cache)
+        };
     );
 
-    let mut cache = EnergyCache::new();
-    cache.init(&system);
-
     let mut rng = utils::get_rng(41201154);
 
-    let particle: usize = rng.gen_range(0, system.size());
-    let mut delta = system[particle].position;
+    let particle: usize = rng.gen_range(0, SYSTEM.size());
+    let mut delta = SYSTEM[particle].position;
     delta += Vector3D::new(rng.gen(), rng.gen(), rng.gen());
 
+    let mut cache = CACHE.write().unwrap();
     bencher.iter(||{
-        cache.move_particles_cost(&system, vec![particle], &[delta])
+        cache.move_particles_cost(&SYSTEM, vec![particle], &[delta]);
     })
 }
 
 fn cache_move_particle_wolf(bencher: &mut Bencher) {
-    let mut system = utils::get_system("nacl");
-    system.interactions_mut().set_coulomb(Box::new(Wolf::new(12.0)));
-
-    let mut cache = EnergyCache::new();
-    cache.init(&system);
+    lazy_static!(
+        static ref SYSTEM: System = {
+            let mut system = utils::get_system("nacl");
+            system.interactions_mut().set_coulomb(Box::new(Wolf::new(12.0)));
+            system
+        };
+
+        static ref CACHE: RwLock<EnergyCache> = {
+            let mut cache = EnergyCache::new();
+            cache.init(&SYSTEM);
+            RwLock::new(cache)
+        };
+    );
 
     let mut rng = utils::get_rng(474114);
 
-    let particle: usize = rng.gen_range(0, system.size());
-    let mut delta = system[particle].position;
+    let particle: usize = rng.gen_range(0, SYSTEM.size());
+    let mut delta = SYSTEM[particle].position;
     delta += Vector3D::new(rng.gen(), rng.gen(), rng.gen());
 
+    let mut cache = CACHE.write().unwrap();
     bencher.iter(||{
-        cache.move_particles_cost(&system, vec![particle], &[delta])
+        cache.move_particles_cost(&SYSTEM, vec![particle], &[delta]);
     })
 }
 
diff --git a/benches/propane.rs b/benches/propane.rs
index 173cc410..2bd919c7 100644
--- a/benches/propane.rs
+++ b/benches/propane.rs
@@ -3,74 +3,99 @@
 
 #[macro_use]
 extern crate bencher;
+#[macro_use]
+extern crate lazy_static;
 extern crate rand;
 extern crate lumol;
 extern crate lumol_input;
 
+use std::sync::RwLock;
+
 use bencher::Bencher;
 use rand::Rng;
 
-use lumol::sys::EnergyCache;
+use lumol::sys::{EnergyCache, System};
 use lumol::types::Vector3D;
 
 #[macro_use]
 mod utils;
 
 fn energy(bencher: &mut Bencher) {
-    let system = utils::get_system("propane");
+    lazy_static!(static ref SYSTEM: System = utils::get_system("propane"););
     bencher.iter(||{
-        let _ = system.potential_energy();
+        SYSTEM.potential_energy();
     })
 }
 
 fn forces(bencher: &mut Bencher) {
-    let system = utils::get_system("propane");
+    lazy_static!(static ref SYSTEM: System = utils::get_system("propane"););
     bencher.iter(||{
-        let _ = system.forces();
+        SYSTEM.forces();
     })
 }
 
 fn virial(bencher: &mut Bencher) {
-    let system = utils::get_system("propane");
+    lazy_static!(static ref SYSTEM: System = utils::get_system("propane"););
     bencher.iter(||{
-        let _ = system.virial();
+        SYSTEM.virial();
     })
 }
 
 fn cache_move_particles(bencher: &mut Bencher) {
-    let system = utils::get_system("propane");
-    let mut cache = EnergyCache::new();
-    cache.init(&system);
+    lazy_static!(
+        static ref SYSTEM: System = utils::get_system("argon");
+
+        static ref CACHE: RwLock<EnergyCache> = {
+            let mut cache = EnergyCache::new();
+            cache.init(&SYSTEM);
+            RwLock::new(cache)
+        };
+    );
 
     let mut rng = utils::get_rng(84541545);
 
-    let molecule = rng.choose(system.molecules()).unwrap();
+
+    let molecule = rng.choose(SYSTEM.molecules()).unwrap();
     let mut delta = vec![];
     for i in molecule {
-        let position = system[i].position;
+        let position = SYSTEM[i].position;
         delta.push(position + Vector3D::new(rng.gen(), rng.gen(), rng.gen()));
     }
 
+    let mut cache = CACHE.write().unwrap();
     bencher.iter(||{
-        cache.move_particles_cost(&system, molecule.iter().collect(), &delta)
+        cache.move_particles_cost(
+            &SYSTEM, molecule.iter().collect(), &delta
+        );
     })
 }
 
 fn cache_move_all_rigid_molecules(bencher: &mut Bencher) {
-    let mut system = utils::get_system("propane");
-    let mut cache = EnergyCache::new();
-    cache.init(&system);
-
-    let mut rng = utils::get_rng(7012121);
-    for molecule in system.molecules().to_owned() {
-        let delta = Vector3D::new(rng.gen(), rng.gen(), rng.gen());
-        for i in molecule {
-            system[i].position += delta;
+    lazy_static!(
+        static ref SYSTEM: RwLock<System> = RwLock::new(utils::get_system("argon"));
+
+        static ref CACHE: RwLock<EnergyCache> = {
+            let mut cache = EnergyCache::new();
+            cache.init(&SYSTEM.read().unwrap());
+            RwLock::new(cache)
+        };
+    );
+
+    {
+        let mut system = SYSTEM.write().unwrap();
+        let mut rng = utils::get_rng(7012121);
+        for molecule in system.molecules().to_owned() {
+            let delta = Vector3D::new(rng.gen(), rng.gen(), rng.gen());
+            for i in molecule {
+                system[i].position += delta;
+            }
         }
     }
 
+    let mut cache = CACHE.write().unwrap();
+    let system = SYSTEM.read().unwrap();
     bencher.iter(||{
-        cache.move_all_rigid_molecules_cost(&system)
+        cache.move_all_rigid_molecules_cost(&system);
     })
 }
 
diff --git a/benches/water.rs b/benches/water.rs
index bc6d057b..3f17fdc0 100644
--- a/benches/water.rs
+++ b/benches/water.rs
@@ -3,15 +3,19 @@
 
 #[macro_use]
 extern crate bencher;
+#[macro_use]
+extern crate lazy_static;
 extern crate rand;
 extern crate lumol;
 extern crate lumol_input;
 
+use std::sync::RwLock;
+
 use bencher::Bencher;
 use rand::Rng;
 
 use lumol::energy::{Ewald, SharedEwald, Wolf, PairRestriction, CoulombicPotential, GlobalPotential};
-use lumol::sys::EnergyCache;
+use lumol::sys::{EnergyCache, System};
 use lumol::types::Vector3D;
 
 #[macro_use]
@@ -30,138 +34,178 @@ fn get_wolf() -> Wolf {
 }
 
 fn energy_ewald(bencher: &mut Bencher) {
-    let system = utils::get_system("water");
+    lazy_static!(static ref SYSTEM: System = utils::get_system("water"););
     let ewald = get_ewald();
 
     bencher.iter(||{
-        let _ = ewald.energy(&system);
+        ewald.energy(&SYSTEM);
     })
 }
 
 fn forces_ewald(bencher: &mut Bencher) {
-    let system = utils::get_system("water");
+    lazy_static!(static ref SYSTEM: System = utils::get_system("water"););
     let ewald = get_ewald();
 
     bencher.iter(||{
-        let _ = ewald.forces(&system);
+        ewald.forces(&SYSTEM);
     })
 }
 
 fn virial_ewald(bencher: &mut Bencher) {
-    let system = utils::get_system("water");
+    lazy_static!(static ref SYSTEM: System = utils::get_system("water"););
     let ewald = get_ewald();
 
     bencher.iter(||{
-        let _ = ewald.virial(&system);
+        ewald.virial(&SYSTEM);
     })
 }
 
 fn energy_wolf(bencher: &mut Bencher) {
-    let system = utils::get_system("water");
+    lazy_static!(static ref SYSTEM: System = utils::get_system("water"););
     let wolf = get_wolf();
 
     bencher.iter(||{
-        let _ = wolf.energy(&system);
+        wolf.energy(&SYSTEM);
     })
 }
 
 fn forces_wolf(bencher: &mut Bencher) {
-    let system = utils::get_system("water");
+    lazy_static!(static ref SYSTEM: System = utils::get_system("water"););
     let wolf = get_wolf();
 
     bencher.iter(||{
-        let _ = wolf.forces(&system);
+        wolf.forces(&SYSTEM);
     })
 }
 
 fn virial_wolf(bencher: &mut Bencher) {
-    let system = utils::get_system("water");
+    lazy_static!(static ref SYSTEM: System = utils::get_system("water"););
     let wolf = get_wolf();
 
     bencher.iter(||{
-        let _ = wolf.virial(&system);
+        wolf.virial(&SYSTEM);
     })
 }
 
 fn cache_move_particles_wolf(bencher: &mut Bencher) {
-    let mut system = utils::get_system("water");
-    system.interactions_mut().set_coulomb(Box::new(get_wolf()));
-
-    let mut cache = EnergyCache::new();
-    cache.init(&system);
+    lazy_static!(
+        static ref SYSTEM: System = {
+            let mut system = utils::get_system("water");
+            system.interactions_mut().set_coulomb(Box::new(get_wolf()));
+            system
+        };
+
+        static ref CACHE: RwLock<EnergyCache> = {
+            let mut cache = EnergyCache::new();
+            cache.init(&SYSTEM);
+            RwLock::new(cache)
+        };
+    );
 
     let mut rng = utils::get_rng(454548784);
-
-    let molecule = rng.choose(system.molecules()).unwrap();
+    let molecule = rng.choose(SYSTEM.molecules()).unwrap();
     let mut delta = vec![];
     for i in molecule {
-        let position = system[i].position;
+        let position = SYSTEM[i].position;
         delta.push(position + Vector3D::new(rng.gen(), rng.gen(), rng.gen()));
     }
 
+    let mut cache = CACHE.write().unwrap();
     bencher.iter(||{
-        cache.move_particles_cost(&system, molecule.iter().collect(), &delta)
+        cache.move_particles_cost(&SYSTEM, molecule.iter().collect(), &delta);
     })
 }
 
 fn cache_move_particles_ewald(bencher: &mut Bencher) {
-    let mut system = utils::get_system("water");
-    system.interactions_mut().set_coulomb(Box::new(get_ewald()));
-
-    let mut cache = EnergyCache::new();
-    cache.init(&system);
+    lazy_static!(
+        static ref SYSTEM: System = {
+            let mut system = utils::get_system("water");
+            system.interactions_mut().set_coulomb(Box::new(get_ewald()));
+            system
+        };
+
+        static ref CACHE: RwLock<EnergyCache> = {
+            let mut cache = EnergyCache::new();
+            cache.init(&SYSTEM);
+            RwLock::new(cache)
+        };
+    );
 
     let mut rng = utils::get_rng(9886565);
-
-    let molecule = rng.choose(system.molecules()).unwrap();
+    let molecule = rng.choose(SYSTEM.molecules()).unwrap();
     let mut delta = vec![];
     for i in molecule {
-        let position = system[i].position;
+        let position = SYSTEM[i].position;
         delta.push(position + Vector3D::new(rng.gen(), rng.gen(), rng.gen()));
     }
 
+    let mut cache = CACHE.write().unwrap();
     bencher.iter(||{
-        cache.move_particles_cost(&system, molecule.iter().collect(), &delta)
+        cache.move_particles_cost(&SYSTEM, molecule.iter().collect(), &delta);
     })
 }
 
 fn cache_move_all_rigid_molecules_wolf(bencher: &mut Bencher) {
-    let mut system = utils::get_system("water");
-    system.interactions_mut().set_coulomb(Box::new(get_wolf()));
-
-    let mut cache = EnergyCache::new();
-    cache.init(&system);
-
-    let mut rng = utils::get_rng(3);
-    for molecule in system.molecules().to_owned() {
-        let delta = Vector3D::new(rng.gen(), rng.gen(), rng.gen());
-        for i in molecule {
-            system[i].position += delta;
+    lazy_static!(
+        static ref SYSTEM: RwLock<System> = {
+            let mut system = utils::get_system("water");
+            system.interactions_mut().set_coulomb(Box::new(get_wolf()));
+            RwLock::new(system)
+        };
+
+        static ref CACHE: RwLock<EnergyCache> = {
+            let mut cache = EnergyCache::new();
+            cache.init(&SYSTEM.read().unwrap());
+            RwLock::new(cache)
+        };
+    );
+
+    {
+        let mut system = SYSTEM.write().unwrap();
+        let mut rng = utils::get_rng(3);
+        for molecule in system.molecules().to_owned() {
+            let delta = Vector3D::new(rng.gen(), rng.gen(), rng.gen());
+            for i in molecule {
+                system[i].position += delta;
+            }
         }
     }
 
+    let mut cache = CACHE.write().unwrap();
     bencher.iter(||{
-        cache.move_all_rigid_molecules_cost(&system)
+        cache.move_all_rigid_molecules_cost(&SYSTEM.read().unwrap());
     })
 }
 
 fn cache_move_all_rigid_molecules_ewald(bencher: &mut Bencher) {
-    let mut system = utils::get_system("water");
-    system.interactions_mut().set_coulomb(Box::new(get_ewald()));
-
-    let mut cache = EnergyCache::new();
-    cache.init(&system);
-
-    let mut rng = utils::get_rng(2121);
-    for molecule in system.molecules().to_owned() {
-        let delta = Vector3D::new(rng.gen(), rng.gen(), rng.gen());
-        for i in molecule {
-            system[i].position += delta;
+    lazy_static!(
+        static ref SYSTEM: RwLock<System> = {
+            let mut system = utils::get_system("water");
+            system.interactions_mut().set_coulomb(Box::new(get_wolf()));
+            RwLock::new(system)
+        };
+
+        static ref CACHE: RwLock<EnergyCache> = {
+            let mut cache = EnergyCache::new();
+            cache.init(&SYSTEM.read().unwrap());
+            RwLock::new(cache)
+        };
+    );
+
+    {
+        let mut system = SYSTEM.write().unwrap();
+        let mut rng = utils::get_rng(2121);
+        for molecule in system.molecules().to_owned() {
+            let delta = Vector3D::new(rng.gen(), rng.gen(), rng.gen());
+            for i in molecule {
+                system[i].position += delta;
+            }
         }
     }
 
+    let mut cache = CACHE.write().unwrap();
     bencher.iter(||{
-        cache.move_all_rigid_molecules_cost(&system)
+        cache.move_all_rigid_molecules_cost(&SYSTEM.read().unwrap());
     })
 }