class CoulombCloudWall(ut.TestCase): """This compares p3m, p3m_gpu, scafacos_p3m and scafacos_p2nfft electrostatic forces and energy against stored data. """ S = espressomd.System(box_l=[1.0, 1.0, 1.0]) S.seed = S.cell_system.get_state()['n_nodes'] * [1234] forces = {} tolerance = 1E-3 # Reference energy from p3m in the tcl test case reference_energy = 148.94229549 def setUp(self): self.S.box_l = (10, 10, 10) self.S.time_step = 0.01 self.S.cell_system.skin = 0.4 # Clear actors that might be left from prev tests if self.S.actors: del self.S.actors[0] self.S.part.clear() data = np.genfromtxt( tests_common.abspath("data/coulomb_cloud_wall_system.data")) # Add particles to system and store reference forces in hash # Input format: id pos q f for particle in data: id = particle[0] pos = particle[1:4] q = particle[4] f = particle[5:] self.S.part.add(id=int(id), pos=pos, q=q) self.forces[id] = f def compare(self, method_name, energy=True, prefactor=None): # Compare forces and energy now in the system to stored ones # Force force_abs_diff = 0. for p in self.S.part: force_abs_diff += np.linalg.norm(p.f / prefactor - self.forces[p.id]) force_abs_diff /= len(self.S.part) print(method_name, "force difference", force_abs_diff) # Energy if energy: energy_abs_diff = abs(self.S.analysis.energy()["total"] / prefactor - self.reference_energy) print(method_name, "energy difference", energy_abs_diff) self.assertLessEqual( energy_abs_diff, self.tolerance, "Absolute energy difference " + str(energy_abs_diff) + " too large for " + method_name) self.assertLessEqual( force_abs_diff, self.tolerance, "Absolute force difference " + str(force_abs_diff) + " too large for method " + method_name) # Tests for individual methods @utx.skipIfMissingFeatures(["P3M"]) def test_p3m_direct_caf(self): """ This checks P3M with using the charge assignment function (window function) directly by setting the `inter` parameter to zero. """ self.S.actors.add( espressomd.electrostatics.P3M(prefactor=3, r_cut=1.001, accuracy=1e-3, mesh=64, cao=7, alpha=2.70746, tune=False, inter=0)) self.S.integrator.run(0) self.compare("p3m", energy=True, prefactor=3) @utx.skipIfMissingFeatures(["P3M"]) def test_p3m_interpolated_caf(self): """ This checks P3M with using an interpolated charge assignment function (window function), which is the default. """ self.S.actors.add( espressomd.electrostatics.P3M(prefactor=3, r_cut=1.001, accuracy=1e-3, mesh=64, cao=7, alpha=2.70746, tune=False)) self.S.integrator.run(0) self.compare("p3m", energy=True, prefactor=3) @utx.skipIfMissingGPU(skip_ci_amd=True) def test_p3m_gpu(self): self.S.actors.add( espressomd.electrostatics.P3MGPU(prefactor=2.2, r_cut=1.001, accuracy=1e-3, mesh=64, cao=7, alpha=2.70746, tune=False)) self.S.integrator.run(0) self.compare("p3m_gpu", energy=False, prefactor=2.2) @ut.skipIf(not espressomd.has_features(["SCAFACOS"]) or 'p3m' not in scafacos.available_methods(), 'Skipping test: missing feature SCAFACOS or p3m method') def test_scafacos_p3m(self): self.S.actors.add( espressomd.electrostatics.Scafacos(prefactor=0.5, method_name="p3m", method_params={ "p3m_r_cut": 1.001, "p3m_grid": 64, "p3m_cao": 7, "p3m_alpha": 2.70746 })) self.S.integrator.run(0) self.compare("scafacos_p3m", energy=True, prefactor=0.5) @ut.skipIf(not espressomd.has_features("SCAFACOS") or 'p2nfft' not in scafacos.available_methods(), 'Skipping test: missing feature SCAFACOS or p2nfft method') def test_scafacos_p2nfft(self): self.S.actors.add( espressomd.electrostatics.Scafacos(prefactor=2.8, method_name="p2nfft", method_params={ "p2nfft_r_cut": 1.001, "tolerance_field": 1E-4 })) self.S.integrator.run(0) self.compare("scafacos_p2nfft", energy=True, prefactor=2.8) def test_zz_deactivation(self): # Is the energy and force 0, if no methods active self.assertEqual(self.S.analysis.energy()["total"], 0.0) self.S.integrator.run(0, recalc_forces=True) for p in self.S.part: self.assertAlmostEqual(np.linalg.norm(p.f), 0, places=11)
class CoulombMixedPeriodicity(ut.TestCase): """Test mixed periodicity electrostatics""" S = espressomd.System(box_l=[1.0, 1.0, 1.0]) buf_node_grid = S.cell_system.node_grid S.thermostat.turn_off() forces = {} tolerance_force = 5E-4 tolerance_energy = 1.8E-3 generate_data = False # Reference energy from MMM2D reference_energy = 216.640984711 def setUp(self): self.S.box_l = (10, 10, 10) self.S.time_step = 0.01 self.S.cell_system.skin = 0. while self.S.actors: del self.S.actors[0] # Clear actors that might be left from prev tests self.S.part.clear() data = np.genfromtxt(tests_common.abspath( "data/coulomb_mixed_periodicity_system.data")) # Add particles to system and store reference forces in hash # Input format: id pos q f for particle in data: id = particle[0] pos = particle[1:4] q = particle[4] f = particle[5:] self.S.part.add(id=int(id), pos=pos, q=q) self.forces[id] = f def compare(self, method_name, energy=True): # Compare forces and energy now in the system to stored ones # Force rms_force_diff = 0. for p in self.S.part: rms_force_diff += np.sum((p.f - self.forces[p.id])**2) rms_force_diff = np.sqrt(rms_force_diff / len(self.S.part)) print(method_name, "rms force difference", rms_force_diff) # Energy if energy: energy_abs_diff = abs( self.S.analysis.energy()["total"] - self.reference_energy) print(method_name, "energy", self.S.analysis.energy()["total"]) print(method_name, "energy difference", energy_abs_diff) self.assertLessEqual( energy_abs_diff, self.tolerance_energy, "Absolute energy difference " + str(energy_abs_diff) + " too large for " + method_name) self.assertLessEqual( rms_force_diff, self.tolerance_force, "Absolute force difference " + str(rms_force_diff) + " too large for method " + method_name) # Tests for individual methods @utx.skipIfMissingFeatures(["P3M"]) def test_zz_p3mElc(self): # Make sure, the data satisfies the gap for p in self.S.part: if p.pos[2] < 0 or p.pos[2] > 9.: raise Exception("Particle z pos invalid") self.S.cell_system.set_domain_decomposition() self.S.cell_system.node_grid = sorted( self.S.cell_system.node_grid, key=lambda x: -x) self.S.periodicity = [1, 1, 1] self.S.box_l = (10, 10, 10) p3m = electrostatics.P3M(prefactor=1, accuracy=1e-6, mesh=(64, 64, 64)) self.S.actors.add(p3m) elc = electrostatic_extensions.ELC(maxPWerror=1E-6, gap_size=1) self.S.actors.add(elc) self.S.integrator.run(0) self.compare("elc", energy=True) self.S.actors.remove(p3m) def test_MMM2D(self): self.S.box_l = (10, 10, 10) self.S.cell_system.set_layered(n_layers=10, use_verlet_lists=False) self.S.periodicity = [1, 1, 0] mmm2d = electrostatics.MMM2D(prefactor=1, maxPWerror=1E-7) self.S.actors.add(mmm2d) self.S.integrator.run(0) if self.generate_data: n = len(self.S.part) data = np.hstack((self.S.part[:].id.reshape((n, 1)), self.S.part[:].pos_folded, self.S.part[:].q.reshape((n, 1)), self.S.part[:].f)) np.savetxt(tests_common.abspath( "data/coulomb_mixed_periodicity_system.data"), data) self.compare("mmm2d (compared to stored data)", energy=True) self.S.actors.remove(mmm2d) @ut.skipIf(not espressomd.has_features("SCAFACOS") or 'p2nfft' not in scafacos.available_methods(), 'Skipping test: missing feature SCAFACOS or p2nfft method') def test_scafacos_p2nfft(self): self.S.periodicity = [1, 1, 0] self.S.cell_system.set_domain_decomposition() self.S.box_l = [10, 10, 10] scafacos = electrostatics.Scafacos( prefactor=1, method_name="p2nfft", method_params={ "tolerance_field": 5E-5, "pnfft_n": "96,96,128", "pnfft_N": "96,96,128", "r_cut": 2.4, "pnfft_m": 3}) self.S.actors.add(scafacos) self.S.integrator.run(0) self.compare("scafacos_p2nfft", energy=True) self.S.actors.remove(scafacos)
class CoulombCloudWall(ut.TestCase): """This compares p3m, p3m_gpu, scafacos_p3m and scafacos_p2nfft electrostatic forces and energy against stored data.""" S = espressomd.System() forces = {} tolerance = 1E-3 # Reference energy from p3m in the tcl test case reference_energy = 148.94229549 def setUp(self): self.S.box_l = (10, 10, 10) self.S.time_step = 0.01 self.S.skin = 0.4 # Clear actors that might be left from prev tests if len(self.S.actors): del self.S.actors[0] self.S.part.clear() data = np.genfromtxt("data/coulomb_cloud_wall_system.data") # Add particles to system and store reference forces in hash # Input format: id pos q f for particle in data: id = particle[0] pos = particle[1:4] q = particle[4] f = particle[5:] self.S.part.add(id=int(id), pos=pos, q=q) self.forces[id] = f def compare(self, method_name, energy=True): # Compare forces and energy now in the system to stored ones # Force force_abs_diff = 0. for p in self.S.part: force_abs_diff += abs(np.sqrt(sum((p.f - self.forces[p.id])**2))) force_abs_diff /= len(self.S.part) print method_name, "force difference", force_abs_diff # Energy if energy: energy_abs_diff = abs(self.S.analysis.energy( self.S)["total"] - self.reference_energy) print method_name, "energy difference", energy_abs_diff self.assertTrue(energy_abs_diff <= self.tolerance, "Absolte energy difference " + str(energy_abs_diff) + " too large for " + method_name) self.assertTrue(force_abs_diff <= self.tolerance, "Asbolute force difference " + str(force_abs_diff) + " too large for method " + method_name) # Tests for individual methods if "P3M" in espressomd.features(): def test_p3m(self): self.S.actors.add(P3M(bjerrum_length=1, r_cut=1.001, mesh=64, cao=7, alpha=2.70746, tune=False)) integrate(0) self.compare("p3m", energy=True) if "ELECTROSTATICS" in espressomd.features() and "CUDA" in espressomd.features(): def test_p3m_gpu(self): self.S.actors.add(P3M_GPU( bjerrum_length=1, r_cut=1.001, mesh=64, cao=7, alpha=2.70746, tune=False)) integrate(0) self.compare("p3m_gpu", energy=False) if "SCAFACOS" in espressomd.features(): if "p3m" in scafacos.available_methods(): def test_scafacos_p3m(self): self.S.actors.add(Scafacos(bjerrum_length=1, method_name="p3m", method_params={ "p3m_r_cut": 1.001, "p3m_grid": 64, "p3m_cao": 7, "p3m_alpha": 2.70746})) integrate(0) self.compare("scafacos_p3m", energy=True) if "p2nfft" in scafacos.available_methods(): def test_scafacos_p2nfft(self): self.S.actors.add(Scafacos(bjerrum_length=1, method_name="p2nfft", method_params={ "p2nfft_r_cut": 1.001, "tolerance_field": 1E-4})) integrate(0) self.compare("scafacos_p2nfft", energy=True) def test_zz_deactivation(self): # Is the energy 0, if no methods active self.assertTrue(self.S.analysis.energy(self.S)["total"] == 0.0)
class CoulombCloudWall(ut.TestCase): """This compares p3m, p3m_gpu, scafacos_p3m and scafacos_p2nfft electrostatic forces and energy against stored data. """ S = espressomd.System(box_l=[1.0, 1.0, 1.0]) data = np.genfromtxt( tests_common.abspath("data/coulomb_cloud_wall_system.data")) tolerance = 1E-3 # Reference energy from p3m in the tcl test case reference_energy = 148.94229549 def setUp(self): self.S.box_l = (10, 10, 10) self.S.time_step = 0.01 self.S.cell_system.skin = 0.4 # Add particles to system and store reference forces in hash # Input format: id pos q f self.S.part.add(pos=self.data[:, 1:4], q=self.data[:, 4]) self.forces = self.data[:, 5:8] def tearDown(self): self.S.part.clear() self.S.actors.clear() def compare(self, method_name, energy=True, prefactor=None): # Compare forces and energy now in the system to stored ones # Force force_diff = np.linalg.norm(self.S.part[:].f / prefactor - self.forces, axis=1) self.assertLess(np.mean(force_diff), self.tolerance, msg="Absolute force difference too large for method " + method_name) # Energy if energy: self.assertAlmostEqual( self.S.analysis.energy()["total"] / prefactor, self.reference_energy, delta=self.tolerance, msg="Absolute energy difference too large for " + method_name) # Tests for individual methods @utx.skipIfMissingFeatures(["P3M"]) def test_p3m_direct(self): """ This checks P3M. """ self.S.actors.add( espressomd.electrostatics.P3M(prefactor=3, r_cut=1.001, accuracy=1e-3, mesh=64, cao=7, alpha=2.70746, tune=False)) self.S.integrator.run(0) self.compare("p3m", energy=True, prefactor=3) @utx.skipIfMissingGPU() def test_p3m_gpu(self): self.S.actors.add( espressomd.electrostatics.P3MGPU(prefactor=2.2, r_cut=1.001, accuracy=1e-3, mesh=64, cao=7, alpha=2.70746, tune=False)) self.S.integrator.run(0) self.compare("p3m_gpu", energy=False, prefactor=2.2) @ut.skipIf(not espressomd.has_features("SCAFACOS") or 'p2nfft' not in scafacos.available_methods(), 'Skipping test: missing feature SCAFACOS or p2nfft method') def test_scafacos_p2nfft(self): self.S.actors.add( espressomd.electrostatics.Scafacos(prefactor=2.8, method_name="p2nfft", method_params={ "p2nfft_r_cut": 1.001, "tolerance_field": 1E-4 })) self.S.integrator.run(0) self.compare("scafacos_p2nfft", energy=True, prefactor=2.8) def test_zz_deactivation(self): # Is the energy and force 0, if no methods active self.assertEqual(self.S.analysis.energy()["total"], 0.0) self.S.integrator.run(0, recalc_forces=True) for p in self.S.part: self.assertAlmostEqual(np.linalg.norm(p.f), 0, places=11)
class CoulombCloudWall(ut.TestCase): """This compares p3m, p3m_gpu, scafacos_p3m and scafacos_p2nfft electrostatic forces and energy against stored data.""" S = espressomd.System(box_l=[1.0, 1.0, 1.0]) forces = {} tolerance = 1E-3 # Reference energy from p3m in the tcl test case reference_energy = 148.94229549 def setUp(self): self.S.box_l = (10, 10, 10) self.S.time_step = 0.01 self.S.cell_system.skin = 0.4 # Clear actors that might be left from prev tests if len(self.S.actors): del self.S.actors[0] self.S.part.clear() data = np.genfromtxt( tests_common.abspath("data/coulomb_cloud_wall_system.data")) # Add particles to system and store reference forces in hash # Input format: id pos q f for particle in data: id = particle[0] pos = particle[1:4] q = particle[4] f = particle[5:] self.S.part.add(id=int(id), pos=pos, q=q) self.forces[id] = f def compare(self, method_name, energy=True, prefactor=None): # Compare forces and energy now in the system to stored ones # Force force_abs_diff = 0. for p in self.S.part: force_abs_diff += abs( np.sqrt(sum((p.f / prefactor - self.forces[p.id])**2))) force_abs_diff /= len(self.S.part) print(method_name, "force difference", force_abs_diff) # Energy if energy: energy_abs_diff = abs(self.S.analysis.energy()["total"] / prefactor - self.reference_energy) print(method_name, "energy difference", energy_abs_diff) self.assertLessEqual( energy_abs_diff, self.tolerance, "Absolte energy difference " + str(energy_abs_diff) + " too large for " + method_name) self.assertLessEqual( force_abs_diff, self.tolerance, "Asbolute force difference " + str(force_abs_diff) + " too large for method " + method_name) # Tests for individual methods if espressomd.has_features(["P3M"]): def test_p3m(self): self.S.actors.add( P3M(prefactor=3, r_cut=1.001, accuracy=1e-3, mesh=64, cao=7, alpha=2.70746, tune=False)) self.S.integrator.run(0) self.compare("p3m", energy=True, prefactor=3) if espressomd.has_features(["ELECTROSTATICS", "CUDA"]): def test_p3m_gpu(self): self.S.actors.add( P3MGPU(prefactor=2.2, r_cut=1.001, accuracy=1e-3, mesh=64, cao=7, alpha=2.70746, tune=False)) self.S.integrator.run(0) self.compare("p3m_gpu", energy=False, prefactor=2.2) if espressomd.has_features(["SCAFACOS"]): if "p3m" in scafacos.available_methods(): def test_scafacos_p3m(self): self.S.actors.add( Scafacos(prefactor=0.5, method_name="p3m", method_params={ "p3m_r_cut": 1.001, "p3m_grid": 64, "p3m_cao": 7, "p3m_alpha": 2.70746 })) self.S.integrator.run(0) self.compare("scafacos_p3m", energy=True, prefactor=0.5) if "p2nfft" in scafacos.available_methods(): def test_scafacos_p2nfft(self): self.S.actors.add( Scafacos(prefactor=2.8, method_name="p2nfft", method_params={ "p2nfft_r_cut": 1.001, "tolerance_field": 1E-4 })) self.S.integrator.run(0) self.compare("scafacos_p2nfft", energy=True, prefactor=2.8) def test_zz_deactivation(self): # Is the energy and force 0, if no methods active self.assertEqual(self.S.analysis.energy()["total"], 0.0) self.S.integrator.run(0, recalc_forces=True) for p in self.S.part: self.assertAlmostEqual(np.linalg.norm(p.f), 0, places=11)
class CoulombMixedPeriodicity(ut.TestCase): """Test mixed periodicity electrostatics""" S = espressomd.System(box_l=[1.0, 1.0, 1.0]) data = np.genfromtxt(tests_common.abspath( "data/coulomb_mixed_periodicity_system.data")) tolerance_force = 5E-4 tolerance_energy = 1.8E-3 # Reference energy from MMM2D reference_energy = 216.640984711 def setUp(self): self.S.box_l = (10, 10, 10) self.S.time_step = 0.01 self.S.cell_system.skin = 0. # Add particles to system and store reference forces in hash # Input format: id pos q f self.S.part.add(pos=self.data[:, 1:4], q=self.data[:, 4]) self.forces = self.data[:, 5:8] def tearDown(self): self.S.part.clear() self.S.actors.clear() def compare(self, method_name, energy=True): # Compare forces and energy now in the system to stored ones # Force force_diff = np.linalg.norm(self.S.part[:].f - self.forces, axis=1) self.assertLessEqual( np.mean(force_diff), self.tolerance_force, "Absolute force difference too large for method " + method_name) # Energy if energy: self.assertAlmostEqual( self.S.analysis.energy()["total"], self.reference_energy, delta=self.tolerance_energy, msg="Absolute energy difference too large for " + method_name) # Tests for individual methods @utx.skipIfMissingFeatures(["P3M"]) def test_elc(self): # Make sure, the data satisfies the gap for p in self.S.part: if p.pos[2] < 0 or p.pos[2] > 9.: raise Exception("Particle z pos invalid") self.S.cell_system.set_domain_decomposition() self.S.cell_system.node_grid = sorted( self.S.cell_system.node_grid, key=lambda x: -x) self.S.periodicity = [1, 1, 1] self.S.box_l = (10, 10, 10) p3m = electrostatics.P3M(prefactor=1, accuracy=1e-6, mesh=(64, 64, 64)) elc = electrostatics.ELC(p3m_actor=p3m, maxPWerror=1E-6, gap_size=1) self.S.actors.add(elc) self.S.integrator.run(0) self.compare("elc", energy=True) @ut.skipIf(not espressomd.has_features("SCAFACOS") or 'p2nfft' not in scafacos.available_methods(), 'Skipping test: missing feature SCAFACOS or p2nfft method') def test_scafacos_p2nfft(self): self.S.periodicity = [1, 1, 0] self.S.cell_system.set_domain_decomposition() self.S.box_l = [10, 10, 10] scafacos = electrostatics.Scafacos( prefactor=1, method_name="p2nfft", method_params={ "tolerance_field": 5E-5, "pnfft_n": "96,96,128", "pnfft_N": "96,96,128", "r_cut": 2.4, "pnfft_m": 3}) self.S.actors.add(scafacos) self.S.integrator.run(0) self.compare("scafacos_p2nfft", energy=True)
class CoulombCloudWall(ut.TestCase): """This compares p3m, p3m_gpu, scafacos_p3m and scafacos_p2nfft electrostatic forces and energy against stored data. """ S = espressomd.System(box_l=[1.0, 1.0, 1.0]) forces = {} tolerance = 1E-3 # Reference energy from p3m in the tcl test case reference_energy = 148.94229549 def setUp(self): self.S.box_l = (10, 10, 10) self.S.time_step = 0.01 self.S.cell_system.skin = 0.4 data = np.genfromtxt( tests_common.abspath("data/coulomb_cloud_wall_system.data")) # Add particles to system and store reference forces in hash # Input format: id pos q f for particle in data: id = particle[0] pos = particle[1:4] q = particle[4] f = particle[5:] self.S.part.add(id=int(id), pos=pos, q=q) self.forces[id] = f def tearDown(self): self.S.part.clear() self.S.actors.clear() def compare(self, method_name, energy=True, prefactor=None): # Compare forces and energy now in the system to stored ones # Force force_abs_diff = 0. for p in self.S.part: force_abs_diff += np.linalg.norm(p.f / prefactor - self.forces[p.id]) force_abs_diff /= len(self.S.part) # Energy if energy: self.assertAlmostEqual( self.S.analysis.energy()["total"] / prefactor, self.reference_energy, delta=self.tolerance, msg="Absolute energy difference too large for " + method_name) self.assertLessEqual( force_abs_diff, self.tolerance, "Absolute force difference too large for method " + method_name) # Tests for individual methods @utx.skipIfMissingFeatures(["P3M"]) def test_p3m_direct(self): """ This checks P3M. """ self.S.actors.add( espressomd.electrostatics.P3M(prefactor=3, r_cut=1.001, accuracy=1e-3, mesh=64, cao=7, alpha=2.70746, tune=False)) self.S.integrator.run(0) self.compare("p3m", energy=True, prefactor=3) @utx.skipIfMissingGPU() def test_p3m_gpu(self): self.S.actors.add( espressomd.electrostatics.P3MGPU(prefactor=2.2, r_cut=1.001, accuracy=1e-3, mesh=64, cao=7, alpha=2.70746, tune=False)) self.S.integrator.run(0) self.compare("p3m_gpu", energy=False, prefactor=2.2) @ut.skipIf(not espressomd.has_features(["SCAFACOS"]) or 'p3m' not in scafacos.available_methods(), 'Skipping test: missing feature SCAFACOS or p3m method') def test_scafacos_p3m(self): self.S.actors.add( espressomd.electrostatics.Scafacos(prefactor=0.5, method_name="p3m", method_params={ "p3m_r_cut": 1.001, "p3m_grid": 64, "p3m_cao": 7, "p3m_alpha": 2.70746 })) self.S.integrator.run(0) self.compare("scafacos_p3m", energy=True, prefactor=0.5) @ut.skipIf(not espressomd.has_features(["SCAFACOS"]) or 'p3m' not in scafacos.available_methods(), 'Skipping test: missing feature SCAFACOS or p3m method') def test_scafacos_p3m_tuning(self): # check that the tuning function can be called without throwing # an exception or causing an MPI deadlock self.S.actors.add( espressomd.electrostatics.Scafacos(prefactor=0.5, method_name="p3m", method_params={ "p3m_r_cut": -1.5, "p3m_grid": 64, "p3m_cao": 7, "p3m_alpha": 2.70746 })) self.S.integrator.run(0) # check the scafacos script interface self.assertEqual(self.S.actors[-1].get_params()['prefactor'], 0.5) @ut.skipIf(not espressomd.has_features("SCAFACOS") or 'p2nfft' not in scafacos.available_methods(), 'Skipping test: missing feature SCAFACOS or p2nfft method') def test_scafacos_p2nfft(self): self.S.actors.add( espressomd.electrostatics.Scafacos(prefactor=2.8, method_name="p2nfft", method_params={ "p2nfft_r_cut": 1.001, "tolerance_field": 1E-4 })) self.S.integrator.run(0) self.compare("scafacos_p2nfft", energy=True, prefactor=2.8) def test_zz_deactivation(self): # Is the energy and force 0, if no methods active self.assertEqual(self.S.analysis.energy()["total"], 0.0) self.S.integrator.run(0, recalc_forces=True) for p in self.S.part: self.assertAlmostEqual(np.linalg.norm(p.f), 0, places=11)