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)
