def test_scafacos_dipoles(self):
s = self.s
s.part.clear()
rho = 0.09
# This is only for box size calculation. The actual particle numbwe is
# lower, because particles are removed from the mdlc gap region
n_particle = 1000
particle_radius = 1
box_l = pow(((4 * n_particle * 3.141592654) /
(3 * rho)), 1.0 / 3.0) * particle_radius
s.box_l = box_l, box_l, box_l
# Particles
data = np.genfromtxt(abspath("data/p3m_magnetostatics_system.data"))
for p in data[:, :]:
s.part.add(id=int(p[0]),
pos=p[1:4],
dip=p[4:7],
rotation=(1, 1, 1))
scafacos = magnetostatics.Scafacos(prefactor=1,
method_name="p2nfft",
method_params={
"p2nfft_verbose_tuning": 0,
"pnfft_N": "32,32,32",
"pnfft_n": "32,32,32",
"pnfft_window_name": "bspline",
"pnfft_m": "4",
"p2nfft_ignore_tolerance": "1",
"pnfft_diff_ik": "0",
"p2nfft_r_cut": "11",
"p2nfft_alpha": "0.31"
})
s.actors.add(scafacos)
s.integrator.run(0)
expected = np.genfromtxt(
abspath("data/p3m_magnetostatics_expected.data"))[:, 1:]
err_f = np.sum(np.sqrt(np.sum((s.part[:].f - expected[:, 0:3])**2, 1)),
0) / np.sqrt(data.shape[0])
err_t = np.sum(
np.sqrt(np.sum((s.part[:].torque_lab - expected[:, 3:6])**2, 1)),
0) / np.sqrt(data.shape[0])
ref_E = 5.570
err_e = s.analysis.energy()["dipolar"] - ref_E
print("Energy difference", err_e)
print("Force difference", err_f)
print("Torque difference", err_t)
tol_f = 2E-3
tol_t = 2E-3
tol_e = 1E-3
self.assertLessEqual(abs(err_e), tol_e, "Energy difference too large")
self.assertLessEqual(abs(err_t), tol_t, "Torque difference too large")
self.assertLessEqual(abs(err_f), tol_f, "Force difference too large")
s.part.clear()
del s.actors[0]
def test_mdlc(self):
s = self.system
rho = 0.3
# This is only for box size calculation. The actual particle number is
# lower, because particles are removed from the mdlc gap region
n_particle = 100
particle_radius = 0.5
box_l = np.cbrt(4 * n_particle * np.pi / (3 * rho)) * particle_radius
s.box_l = 3 * [box_l]
ref_E_path = tests_common.abspath(
"data/mdlc_reference_data_energy.dat")
ref_E = float(np.genfromtxt(ref_E_path)) * DIPOLAR_PREFACTOR
gap_size = 2.0
# Particles
data = np.genfromtxt(
tests_common.abspath(
"data/mdlc_reference_data_forces_torques.dat"))
partcls = s.part.add(pos=data[:, 1:4], dip=data[:, 4:7])
partcls.rotation = 3 * [True]
p3m = espressomd.magnetostatics.DipolarP3M(prefactor=DIPOLAR_PREFACTOR,
mesh=32,
accuracy=1E-4)
dlc = espressomd.magnetostatic_extensions.DLC(maxPWerror=1E-5,
gap_size=gap_size)
s.actors.add(p3m)
s.actors.add(dlc)
s.integrator.run(0)
err_f = self.vector_error(partcls.f, data[:, 7:10] * DIPOLAR_PREFACTOR)
err_t = self.vector_error(partcls.torque_lab,
data[:, 10:13] * DIPOLAR_PREFACTOR)
err_e = s.analysis.energy()["dipolar"] - ref_E
tol_f = 2E-3
tol_t = 2E-3
tol_e = 1E-3
self.assertLessEqual(abs(err_e), tol_e, "Energy difference too large")
self.assertLessEqual(abs(err_t), tol_t, "Torque difference too large")
self.assertLessEqual(abs(err_f), tol_f, "Force difference too large")
# Check if error is thrown when particles enter the MDLC gap
# positive direction
p0 = s.part.by_id(0)
p0.pos = [s.box_l[0] / 2, s.box_l[1] / 2, s.box_l[2] - gap_size / 2]
with self.assertRaises(Exception):
self.system.analysis.energy()
with self.assertRaises(Exception):
self.integrator.run(2)
# negative direction
p0.pos = [s.box_l[0] / 2, s.box_l[1] / 2, -gap_size / 2]
with self.assertRaises(Exception):
self.system.analysis.energy()
with self.assertRaises(Exception):
self.integrator.run(2)
def test_scafacos_dipoles(self):
s = self.system
rho = 0.09
# This is only for box size calculation. The actual particle number is
# lower, because particles are removed from the mdlc gap region
n_particle = 1000
particle_radius = 1
box_l = np.cbrt(4 * n_particle * np.pi / (3 * rho)) * particle_radius
s.box_l = 3 * [box_l]
# Particles
data = np.genfromtxt(
tests_common.abspath("data/p3m_magnetostatics_system.data"))
partcls = s.part.add(pos=data[:, 1:4], dip=data[:, 4:7])
partcls.rotation = 3 * [True]
scafacos = espressomd.magnetostatics.Scafacos(
prefactor=DIPOLAR_PREFACTOR,
method_name="p2nfft",
method_params={
"p2nfft_verbose_tuning": 0,
"pnfft_N": "32,32,32",
"pnfft_n": "32,32,32",
"pnfft_window_name": "bspline",
"pnfft_m": "4",
"p2nfft_ignore_tolerance": "1",
"pnfft_diff_ik": "0",
"p2nfft_r_cut": "11",
"p2nfft_alpha": "0.31"
})
s.actors.add(scafacos)
s.integrator.run(0)
expected = np.genfromtxt(
tests_common.abspath("data/p3m_magnetostatics_expected.data"))[:,
1:]
err_f = self.vector_error(partcls.f,
expected[:, 0:3] * DIPOLAR_PREFACTOR)
err_t = self.vector_error(partcls.torque_lab,
expected[:, 3:6] * DIPOLAR_PREFACTOR)
ref_E = 5.570 * DIPOLAR_PREFACTOR
err_e = s.analysis.energy()["dipolar"] - ref_E
tol_f = 2E-3
tol_t = 2E-3
tol_e = 1E-3
self.assertLessEqual(abs(err_e), tol_e, "Energy difference too large")
self.assertLessEqual(abs(err_t), tol_t, "Torque difference too large")
self.assertLessEqual(abs(err_f), tol_f, "Force difference too large")
def test_mdlc(self):
s = self.s
s.part.clear()
rho = 0.3
# This is only for box size calculation. The actual particle numbwe is
# lower, because particles are removed from the mdlc gap region
n_particle = 100
particle_radius = 0.5
box_l = pow(((4 * n_particle * 3.141592654) /
(3 * rho)), 1.0 / 3.0) * particle_radius
s.box_l = box_l, box_l, box_l
f = open(abspath("data/mdlc_reference_data_energy.dat"))
ref_E = float(f.readline())
f.close()
# Particles
data = np.genfromtxt(
abspath("data/mdlc_reference_data_forces_torques.dat"))
for p in data[:, :]:
s.part.add(id=int(p[0]), pos=p[1:4], dip=p[4:7])
s.part[:].rotation = (1, 1, 1)
p3m = magnetostatics.DipolarP3M(prefactor=1, mesh=32, accuracy=1E-4)
dlc = magnetostatic_extensions.DLC(maxPWerror=1E-5, gap_size=2.)
s.actors.add(p3m)
s.actors.add(dlc)
s.thermostat.turn_off()
s.integrator.run(0)
err_f = np.sum(np.sqrt(np.sum(
(s.part[:].f - data[:, 7:10])**2, 1)), 0) / np.sqrt(data.shape[0])
err_t = np.sum(
np.sqrt(np.sum((s.part[:].torque_lab - data[:, 10:13])**2, 1)),
0) / np.sqrt(data.shape[0])
err_e = s.analysis.energy()["dipolar"] - ref_E
print("Energy difference", err_e)
print("Force difference", err_f)
print("Torque difference", err_t)
tol_f = 2E-3
tol_t = 2E-3
tol_e = 1E-3
self.assertLessEqual(abs(err_e), tol_e, "Energy difference too large")
self.assertLessEqual(abs(err_t), tol_t, "Torque difference too large")
self.assertLessEqual(abs(err_f), tol_f, "Force difference too large")
s.part.clear()
del s.actors[0]
del s.actors[0]
def test(self):
import object_in_fluid as oif
system = espressomd.System(box_l=(10, 10, 10))
self.assertEqual(system.max_oif_objects, 0)
system.time_step = 0.4
system.cell_system.skin = 0.5
system.thermostat.set_langevin(kT=0, gamma=0.7, seed=42)
# creating the template for OIF object
cell_type = oif.OifCellType(
nodes_file=abspath("data/sphere393nodes.dat"),
triangles_file=abspath("data/sphere393triangles.dat"),
system=system,
ks=1.0,
kb=1.0,
kal=1.0,
kag=0.1,
kv=0.1,
check_orientation=False,
resize=(3.0, 3.0, 3.0))
# creating the OIF object
cell0 = oif.OifCell(cell_type=cell_type,
particle_type=0,
origin=[5.0, 5.0, 5.0])
self.assertEqual(system.max_oif_objects, 1)
# cell0.output_vtk_pos_folded(file_name="cell0_0.vtk")
# fluid
diameter_init = cell0.diameter()
print("initial diameter = " + str(diameter_init))
# OIF object is being stretched by factor 1.5
maxCycle = 500
system.part[:].pos = (system.part[:].pos - 5) * 1.5 + 5
diameter_stretched = cell0.diameter()
print("stretched diameter = " + str(diameter_stretched))
# main integration loop
# OIF object is let to relax into relaxed shape of the sphere
for i in range(3):
system.integrator.run(steps=90)
diameter_final = cell0.diameter()
print("final diameter = " + str(diameter_final))
self.assertAlmostEqual(diameter_final / diameter_init - 1,
0,
delta=0.005)
def test_p3m(self):
s = self.s
s.part.clear()
rho = 0.09
# This is only for box size calculation. The actual particle numbwe is
# lower, because particles are removed from the mdlc gap region
n_particle = 1000
particle_radius = 1
box_l = pow(((4 * n_particle * 3.141592654) /
(3 * rho)), 1.0 / 3.0) * particle_radius
s.box_l = box_l, box_l, box_l
# Particles
data = np.genfromtxt(abspath("data/p3m_magnetostatics_system.data"))
for p in data[:, :]:
s.part.add(id=int(p[0]), pos=p[1:4], dip=p[4:7])
s.part[:].rotation = (1, 1, 1)
p3m = magnetostatics.DipolarP3M(prefactor=1,
mesh=32,
accuracy=1E-6,
epsilon="metallic")
s.actors.add(p3m)
s.integrator.run(0)
expected = np.genfromtxt(
abspath("data/p3m_magnetostatics_expected.data"))[:, 1:]
err_f = np.sum(np.sqrt(np.sum((s.part[:].f - expected[:, 0:3])**2, 1)),
0) / np.sqrt(data.shape[0])
err_t = np.sum(
np.sqrt(np.sum((s.part[:].torque_lab - expected[:, 3:6])**2, 1)),
0) / np.sqrt(data.shape[0])
ref_E = 5.570
err_e = s.analysis.energy()["dipolar"] - ref_E
print("Energy difference", err_e)
print("Force difference", err_f)
print("Torque difference", err_t)
tol_f = 2E-3
tol_t = 2E-3
tol_e = 1E-3
self.assertLessEqual(abs(err_e), tol_e, "Energy difference too large")
self.assertLessEqual(abs(err_t), tol_t, "Torque difference too large")
self.assertLessEqual(abs(err_f), tol_f, "Force difference too large")
s.part.clear()
del s.actors[0]
def test_02__direction(self):
"""Test for NpT constrained in one direction."""
data = np.genfromtxt(tests_common.abspath("data/npt_lj_system.data"))
ref_box_l = 1.01 * np.max(data[:, 0:3])
system = self.system
system.box_l = 3 * [ref_box_l]
system.part.add(pos=data[:, 0:3], type=len(data) * [2])
system.non_bonded_inter[2, 2].wca.set_params(epsilon=1., sigma=1.)
system.time_step = 0.01
for n in range(3):
direction = np.roll([True, False, False], n)
system.box_l = 3 * [ref_box_l]
system.part.all().pos = data[:, 0:3]
system.part.all().v = data[:, 3:6]
system.thermostat.set_npt(kT=1.0, gamma0=2, gammav=0.004, seed=42)
system.integrator.set_isotropic_npt(ext_pressure=2.0, piston=0.0001,
direction=direction)
system.integrator.run(20)
box_l_rel = np.copy(system.box_l) / ref_box_l
box_l_rel_ref = np.roll([np.max(box_l_rel), 1., 1.], n)
np.testing.assert_allclose(box_l_rel, box_l_rel_ref, atol=1e-10)
self.assertGreater(np.max(box_l_rel), 2)
def test_compressibility(self):
system = self.system
system.box_l = [5.86326165] * 3
data = np.genfromtxt(tests_common.abspath("data/npt_lj_system.data"))
p_ext = 2.0
system.part.add(pos=data[:, :3], v=data[:, 3:])
system.non_bonded_inter[0, 0].lennard_jones.set_params(
epsilon=1, sigma=1, cutoff=1.12246, shift=0.25)
system.thermostat.set_npt(kT=1.0, gamma0=2, gammav=0.004, seed=42)
system.integrator.set_isotropic_npt(ext_pressure=p_ext, piston=0.0001)
system.integrator.run(800)
avp = 0
n = 30000
skip_p = 8
ls = np.zeros(n)
for t in range(n):
system.integrator.run(2)
if t % skip_p == 0:
avp += system.analysis.pressure()['total']
ls[t] = system.box_l[0]
avp /= (n / skip_p)
Vs = np.array(ls)**3
compressibility = np.var(Vs) / np.average(Vs)
self.assertAlmostEqual(avp, p_ext, delta=0.02)
self.assertAlmostEqual(compressibility, 0.32, delta=0.02)
def setUp(self):
self.system.box_l = (10, 10, 10)
self.system.time_step = 0.01
self.system.cell_system.skin = 0.4
data = np.load(tests_common.abspath("data/coulomb_tuning_system.npz"))
self.forces = data['forces']
self.system.part.add(pos=data['pos'], q=data['charges'])
class LennardJonesTest(ut.TestCase):
system = espressomd.System(box_l=[1.0, 1.0, 1.0])
data = numpy.loadtxt(abspath('data/lj_system.dat'))
def setUp(self):
self.system.part.clear()
self.system.box_l = [10.7437] * 3
lj_eps = 1.0
lj_sig = 1.0
lj_cut = 1.12246
self.system.non_bonded_inter[0, 0].lennard_jones.set_params(
epsilon=lj_eps, sigma=lj_sig, cutoff=lj_cut, shift="auto")
self.system.cell_system.skin = 0.4
self.system.time_step = .1
for i in range(self.data.shape[0]):
self.system.part.add(
id=int(self.data[i][0]),
pos=[self.data[i][1], self.data[i][2], self.data[i][3]])
def check(self):
rms = 0.0
max_df = 0.0
for i in range(self.data.shape[0]):
f = self.system.part[i].f
for j in range(3):
df2 = (self.data[i][4 + j] - f[j])**2
rms += df2
max_df = max(max_df, (df2)**0.5)
rms = rms**0.5
self.assertTrue(rms < 1e-5)
self.assertTrue(max_df < 1e-5)
def test_dd(self):
self.system.cell_system.set_domain_decomposition(
use_verlet_lists=False)
self.system.integrator.run(recalc_forces=True, steps=0)
self.check()
def test_dd_vl(self):
self.system.cell_system.set_domain_decomposition(use_verlet_lists=True)
# Build VL and calc ia
self.system.integrator.run(recalc_forces=True, steps=0)
self.check()
# Calc is from VLs
self.system.integrator.run(recalc_forces=True, steps=0)
self.check()
def test(self):
lbm = espressomd.lb.LBFluid(
agrid=1.0, tau=self.S.time_step, visc=1.0, dens=1.0)
self.S.actors.add(lbm)
self.S.thermostat.set_lb(LB_fluid=lbm, gamma=0.5)
self.run_and_check(
lbm, abspath("data/engine_lb.vtk"),
"engine_test_cpu_tmp.vtk", 1.5e-6)
self.S.thermostat.turn_off()
self.S.actors.remove(lbm)
def test_p3m(self):
s = self.system
rho = 0.09
# This is only for box size calculation. The actual particle number is
# lower, because particles are removed from the mdlc gap region
n_particle = 1000
particle_radius = 1
box_l = np.cbrt(4 * n_particle * np.pi / (3 * rho)) * particle_radius
s.box_l = 3 * [box_l]
# Particles
data = np.genfromtxt(
tests_common.abspath("data/p3m_magnetostatics_system.data"))
partcls = s.part.add(pos=data[:, 1:4], dip=data[:, 4:7])
partcls.rotation = 3 * [True]
p3m = espressomd.magnetostatics.DipolarP3M(prefactor=DIPOLAR_PREFACTOR,
mesh=32,
accuracy=1E-6,
epsilon="metallic")
s.actors.add(p3m)
s.integrator.run(0)
expected = np.genfromtxt(
tests_common.abspath("data/p3m_magnetostatics_expected.data"))[:,
1:]
err_f = self.vector_error(partcls.f,
expected[:, 0:3] * DIPOLAR_PREFACTOR)
err_t = self.vector_error(partcls.torque_lab,
expected[:, 3:6] * DIPOLAR_PREFACTOR)
ref_E = 5.570 * DIPOLAR_PREFACTOR
err_e = s.analysis.energy()["dipolar"] - ref_E
tol_f = 2E-3
tol_t = 2E-3
tol_e = 1E-3
self.assertLessEqual(abs(err_e), tol_e, "Energy difference too large")
self.assertLessEqual(abs(err_t), tol_t, "Torque difference too large")
self.assertLessEqual(abs(err_f), tol_f, "Force difference too large")
def test(self):
self.new_configuration = False
self.sampsteps = 2000
S = espressomd.System(box_l=[1.0, 1.0, 1.0])
self.prepare(S)
lbm = espressomd.lb.LBFluid(
agrid=1.0, tau=S.time_step, fric=0.5, visc=1.0, dens=1.0)
S.actors.add(lbm)
if (S.cell_system.get_state()["n_nodes"] > 1):
print("NOTE: Ignoring testcase for n_nodes > 1")
else:
self.run_and_check(S, lbm, tests_common.abspath("data/engine_lb.vtk"))
def test(self):
self.new_configuration = False
self.sampsteps = 2000
S = espressomd.System(box_l=[1.0, 1.0, 1.0])
S.seed = S.cell_system.get_state()['n_nodes'] * [1234]
self.prepare(S)
lbm = espressomd.lb.LBFluid(
agrid=1.0, tau=S.time_step, visc=1.0, dens=1.0)
S.actors.add(lbm)
S.thermostat.set_lb(LB_fluid=lbm, gamma=0.5)
self.run_and_check(
S, lbm, tests_common.abspath("data/engine_lb.vtk"))
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=(el.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)
def test(self):
self.new_configuration = False
self.sampsteps = 2000
S = espressomd.System(box_l=[1.0, 1.0, 1.0])
self.prepare(S)
lbm = espressomd.lb.LBFluidGPU(
agrid=1.0,
tau=S.time_step,
fric=0.5,
visc=1.0,
dens=1.0,
couple="2pt")
S.actors.add(lbm)
self.run_and_check(S, lbm, tests_common.abspath("data/engine_lbgpu_2pt.vtk"))
class LennardJonesTest(ut.TestCase):
system = espressomd.System(box_l=[1.0, 1.0, 1.0])
data = np.loadtxt(tests_common.abspath('data/lj_system.dat'))
pos = data[:, 1:4]
forces = data[:, 4:7]
def setUp(self):
self.system.part.clear()
self.system.box_l = [10.7437] * 3
lj_eps = 1.0
lj_sig = 1.0
lj_cut = 1.12246
self.system.non_bonded_inter[0, 0].lennard_jones.set_params(
epsilon=lj_eps, sigma=lj_sig, cutoff=lj_cut, shift="auto")
self.system.cell_system.skin = 0.4
self.system.time_step = .1
self.system.part.add(pos=self.pos)
def check(self):
all_partcls = self.system.part.all()
f_diff = np.linalg.norm(all_partcls.f - self.forces, axis=1)
max_deviation = np.max(np.abs(all_partcls.f - self.forces))
self.assertLess(np.mean(f_diff), 1e-7)
self.assertLess(max_deviation, 1e-5)
def test_dd(self):
self.system.cell_system.set_regular_decomposition(
use_verlet_lists=False)
self.system.integrator.run(recalc_forces=True, steps=0)
self.check()
def test_dd_vl(self):
self.system.cell_system.set_regular_decomposition(
use_verlet_lists=True)
# Build VL and calc ia
self.system.integrator.run(recalc_forces=True, steps=0)
self.check()
# Calc is from VLs
self.system.integrator.run(recalc_forces=True, steps=0)
self.check()
def setUp(self):
self.S.box_l = (10, 10, 20)
self.S.time_step = 0.01
self.S.cell_system.skin = 0.4
data = np.genfromtxt(
abspath("data/coulomb_cloud_wall_duplicated_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 setUp(self):
self.system.box_l = (10, 10, 10)
self.system.time_step = 0.01
self.system.cell_system.skin = 0.4
# Clear actors that might be left from prev tests
self.system.actors.clear()
self.system.part.clear()
data = np.load(tests_common.abspath("data/coulomb_tuning_system.npz"))
self.forces = []
# Add particles to system and store reference forces in hash
# Input format: id pos q f
for id in range(len(data['pos'])):
pos = data['pos'][id]
q = data['charges'][id]
self.forces.append(data['forces'][id])
self.system.part.add(id=id, pos=pos, q=q)
def setUp(self):
self.S.box_l = (10, 10, 10)
self.S.time_step = 0.01
self.S.cell_system.skin = 0.
self.S.actors.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 setUp(self):
box_l = 5.86326165
self.S.box_l = [box_l] * 3
self.S.time_step = 0.01
self.S.cell_system.skin = 0.25
data = np.genfromtxt(tests_common.abspath("data/npt_lj_system.data"))
# Input format: id pos f
for particle in data:
pos = particle[:3]
v = particle[3:]
self.S.part.add(pos=pos, v=v)
self.S.non_bonded_inter[0, 0].lennard_jones.set_params(
epsilon=1, sigma=1, cutoff=1.12246, shift=0.25)
self.S.thermostat.set_npt(kT=1.0, gamma0=2, gammav=0.004, seed=42)
self.S.integrator.set_isotropic_npt(
ext_pressure=self.p_ext, piston=0.0001)
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 setUp(self):
self.params = {
'int_steps': 25,
'int_times': 10,
'time_step': 0.01,
'tau': 0.02,
'agrid': 0.5,
'box_l': 12.0,
'dens': 0.85,
'viscosity': 30.0,
'friction': 2.0,
'temp': 1.5,
'gamma': 1.5,
'skin': 0.2,
'mom_prec': 1.e-11,
'mass_prec_per_node': 4.e-8,
'temp_confidence': 10
}
if espressomd.has_features("ROTATION"):
self.dof = 6.
else:
self.dof = 3.
self.system.box_l = [
self.params['box_l'], self.params['box_l'], self.params['box_l']
]
self.system.periodicity = [1, 1, 1]
self.system.time_step = self.params['time_step']
self.system.cell_system.skin = self.params['skin']
# clear actors that might be left from prev tests
for i in self.system.actors:
self.system.actors.remove(i)
self.system.part.clear()
# import particle data
self.data = np.genfromtxt(abspath("data/lb_system.data"))
for particle in self.data:
id = particle[0]
typ = particle[1]
pos = particle[3:6]
f = particle[9:]
v = particle[6:9]
p = self.system.part.add(id=int(id), pos=pos, v=v, type=int(typ))
if espressomd.has_features("ROTATION"):
p.rotation = [1, 1, 1]
self.n_col_part = len(self.system.part)
self.system.thermostat.set_langevin(kT=self.params['temp'],
gamma=self.params['gamma'])
self.system.integrator.run(50)
# kill particle motion
for i in range(self.n_col_part):
self.system.part[i].v = [0.0, 0.0, 0.0]
self.system.thermostat.turn_off()
self.lbf = lb.LBFluid(visc=self.params['viscosity'],
dens=self.params['dens'],
agrid=self.params['agrid'],
tau=self.system.time_step,
fric=self.params['friction'])
self.system.actors.add(self.lbf)
self.system.thermostat.set_lb(kT=self.params['temp'])
# give particles a push
for i in range(self.n_col_part):
self.system.part[i].v = self.system.part[i].v + [0.1, 0.0, 0.0]
self.fluidmass = self.params['dens']
self.tot_mom = [0.0, 0.0, 0.0]
for i in range(self.n_col_part):
self.tot_mom = self.tot_mom + self.system.part[i].v
self.system.integrator.run(50)
self.max_dmass = 0.0
self.max_dm = [0, 0, 0]
self.avg_temp = 0.0
self.avg_fluid_temp = 0.0
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
import espressomd
import espressomd.magnetostatics
import espressomd.magnetostatic_extensions
import os
import numpy as np
import unittest as ut
import unittest_decorators as utx
from tests_common import abspath, random_dipoles
OPEN_BOUNDARIES_REF_ENERGY = abspath("data/dipolar_open_boundaries_energy.npy")
OPEN_BOUNDARIES_REF_ARRAYS = abspath("data/dipolar_open_boundaries_arrays.npy")
@utx.skipIfMissingFeatures(["DIPOLES"])
class dds(ut.TestCase):
system = espressomd.System(box_l=[3, 3, 3])
system.time_step = 0.01
system.cell_system.skin = 0.1
system.periodicity = [False, False, False]
def tearDown(self):
self.system.part.clear()
self.system.actors.clear()
class ElectrostaticInteractionsTests:
MMM1D = None
# Handle to espresso system
system = espressomd.System(box_l=[10.0] * 3)
system.periodicity = [0, 0, 1]
system.time_step = 0.01
system.cell_system.skin = 0.4
system.cell_system.set_n_square()
system.thermostat.set_langevin(kT=0, gamma=1, seed=8)
data = np.loadtxt(tests_common.abspath("data/mmm1d_data.txt"))
p_pos = data[:, 1:4]
p_q = data[:, 4]
forces_target = data[:, 5:8]
energy_target = -7.156365298205383
allowed_error = 2e-5
def setUp(self):
self.system.periodicity = [0, 0, 1]
self.system.part.add(pos=self.p_pos, q=self.p_q)
self.mmm1d = self.MMM1D(prefactor=1.0, maxPWerror=1e-20)
self.system.actors.add(self.mmm1d)
self.system.integrator.run(steps=0)
def tearDown(self):
self.system.part.clear()
self.system.actors.clear()
def test_forces(self):
measured_f = np.copy(self.system.part[:].f)
np.testing.assert_allclose(measured_f,
self.forces_target,
atol=self.allowed_error)
def test_energy(self):
measured_el_energy = self.system.analysis.energy()["coulomb"]
self.assertAlmostEqual(
measured_el_energy,
self.energy_target,
delta=self.allowed_error,
msg="Measured energy deviates too much from stored result")
def test_with_analytical_result(self, prefactor=1.0, accuracy=1e-4):
self.system.part.clear()
p = self.system.part.add(pos=[0, 0, 0], q=1)
self.system.part.add(pos=[0, 0, 1], q=1)
self.system.integrator.run(steps=0)
f_measured = p.f
energy_measured = self.system.analysis.energy()["total"]
target_energy_config = 1.00242505606 * prefactor
target_force_z_config = -0.99510759 * prefactor
self.assertAlmostEqual(
f_measured[0],
0,
delta=self.allowed_error,
msg="Measured force in x deviates too much from analytical result")
self.assertAlmostEqual(
f_measured[1],
0,
delta=self.allowed_error,
msg="Measured force in y deviates too much from analytical result")
self.assertAlmostEqual(
f_measured[2],
target_force_z_config,
delta=accuracy,
msg="Measured force in z deviates too much from analytical result")
self.assertAlmostEqual(
energy_measured,
target_energy_config,
delta=self.allowed_error,
msg="Measured energy deviates too much from analytical result")
def test_bjerrum_length_change(self):
self.system.part.clear()
self.system.actors.clear()
prefactor = 2
mmm1d = self.MMM1D(prefactor=prefactor, maxPWerror=1e-20)
self.system.actors.add(mmm1d)
self.test_with_analytical_result(prefactor=prefactor, accuracy=0.0017)
def test_exceptions(self):
self.system.actors.clear()
del self.mmm1d
# check periodicity exceptions
for periodicity in itertools.product(range(2), range(2), range(2)):
if periodicity == (0, 0, 1):
continue
self.system.periodicity = periodicity
with self.assertRaisesRegex(
Exception, r"MMM1D requires periodicity \(0, 0, 1\)"):
mmm1d = self.MMM1D(prefactor=1.0, maxPWerror=1e-2)
self.system.actors.add(mmm1d)
self.system.periodicity = (0, 0, 1)
self.system.actors.clear()
class ElectrostaticInteractionsTests:
# Handle to espresso system
system = espressomd.System(box_l=[10.0] * 3)
system.periodicity = [0, 0, 1]
system.time_step = 0.01
system.cell_system.skin = 0.4
system.cell_system.set_n_square()
system.thermostat.set_langevin(kT=0, gamma=1, seed=8)
pid_target, pos_x_target, pos_y_target, pos_z_target, q_target, f_x_target, f_y_target, f_z_target = np.loadtxt(
tests_common.abspath("data/mmm1d_data.txt"), unpack=True)
vec_f_target = np.stack((f_x_target, f_y_target, f_z_target), axis=-1)
energy_target = -7.156365298205383
num_particles = pid_target.shape[0]
allowed_error = 1e-4
def setUp(self):
for i in range(self.num_particles):
self.system.part.add(pos=[
self.pos_x_target[i], self.pos_y_target[i],
self.pos_z_target[i]
],
q=self.q_target[i])
self.mmm1d = self.MMM1D(prefactor=1.0, maxPWerror=1e-20)
self.system.actors.add(self.mmm1d)
self.system.integrator.run(steps=0)
def tearDown(self):
self.system.part.clear()
self.system.actors.clear()
def test_forces(self):
measured_f = self.system.part[:].f
for i in range(self.num_particles):
for comp in range(3):
self.assertAlmostEqual(
measured_f[i, comp],
self.vec_f_target[i, comp],
delta=self.allowed_error,
msg="Measured force deviates too much "
"for particle {} in component {}".format(i, comp))
def test_energy(self):
measured_el_energy = self.system.analysis.energy()["total"] \
- self.system.analysis.energy()["kinetic"]
self.assertAlmostEqual(
measured_el_energy,
self.energy_target,
delta=self.allowed_error,
msg="Measured energy deviates too much from stored result")
def test_with_analytical_result(self, prefactor=1.0, accuracy=1e-4):
self.system.part.clear()
self.system.part.add(pos=[0, 0, 0], q=1)
self.system.part.add(pos=[0, 0, 1], q=1)
self.system.integrator.run(steps=0)
f_measured = self.system.part[0].f
energy_measured = self.system.analysis.energy()["total"]
target_energy_config = 1.00242505606 * prefactor
target_force_z_config = -0.99510759 * prefactor
self.assertAlmostEqual(
f_measured[0],
0,
delta=self.allowed_error,
msg="Measured force in x deviates too much from analytical result")
self.assertAlmostEqual(
f_measured[1],
0,
delta=self.allowed_error,
msg="Measured force in y deviates too much from analytical result")
self.assertAlmostEqual(
f_measured[2],
target_force_z_config,
delta=accuracy,
msg="Measured force in z deviates too much from analytical result")
self.assertAlmostEqual(
energy_measured,
target_energy_config,
delta=self.allowed_error,
msg="Measured energy deviates too much from analytical result")
def test_bjerrum_length_change(self):
self.system.part.clear()
self.system.actors.clear()
prefactor = 2
mmm1d = self.MMM1D(prefactor=prefactor, maxPWerror=1e-20)
self.system.actors.add(mmm1d)
self.test_with_analytical_result(prefactor=prefactor, accuracy=0.0017)
def test(self):
import object_in_fluid as oif
system = espressomd.System(box_l=(10, 10, 10))
self.assertEqual(system.max_oif_objects, 0)
system.time_step = 0.4
system.cell_system.skin = 0.5
# creating the template for OIF object
cell_type = oif.OifCellType(
nodes_file=abspath("data/sphere393nodes.dat"),
triangles_file=abspath("data/sphere393triangles.dat"),
system=system,
ks=1.0,
kb=1.0,
kal=1.0,
kag=0.1,
kv=0.1,
check_orientation=False,
resize=(3.0, 3.0, 3.0))
# creating the OIF object
cell0 = oif.OifCell(cell_type=cell_type,
particle_type=0,
origin=[5.0, 5.0, 5.0])
self.assertEqual(system.max_oif_objects, 1)
# cell0.output_vtk_pos_folded(file_name="cell0_0.vtk")
# fluid
diameter_init = cell0.diameter()
print("initial diameter = " + str(diameter_init))
# OIF object is being stretched by factor 1.5
system.part[:].pos = (system.part[:].pos - 5) * 1.5 + 5
diameter_stretched = cell0.diameter()
print("stretched diameter = " + str(diameter_stretched))
# Apply non-isotropic deformation
system.part[:].pos = system.part[:].pos * np.array((0.96, 1.05, 1.02))
# Test that restoring forces net to zero and don't produce a torque
system.integrator.run(1)
np.testing.assert_allclose(np.sum(system.part[:].f, axis=0),
[0., 0., 0.],
atol=1E-12)
total_torque = np.zeros(3)
for p in system.part:
total_torque += np.cross(p.pos, p.f)
np.testing.assert_allclose(total_torque, [0., 0., 0.], atol=2E-12)
# main integration loop
system.thermostat.set_langevin(kT=0, gamma=0.7, seed=42)
# OIF object is let to relax into relaxed shape of the sphere
for _ in range(2):
system.integrator.run(steps=240)
diameter_final = cell0.diameter()
print("final diameter = " + str(diameter_final))
self.assertAlmostEqual(diameter_final / diameter_init - 1,
0,
delta=0.005)
def test_scafacos(self):
s = self.system
rho = 0.3
# This is only for box size calculation. The actual particle number is
# lower, because particles are removed from the mdlc gap region
n_particle = 100
particle_radius = 0.5
box_l = np.cbrt(4 * n_particle * np.pi / (3 * rho)) * particle_radius
s.box_l = 3 * [box_l]
for dim in (2, 1):
print("Dimension", dim)
# Read reference data
if dim == 2:
file_prefix = "data/mdlc"
s.periodicity = [1, 1, 0]
else:
s.periodicity = [1, 0, 0]
file_prefix = "data/scafacos_dipoles_1d"
ref_E_path = tests_common.abspath(file_prefix +
"_reference_data_energy.dat")
ref_E = float(np.genfromtxt(ref_E_path))
# Particles
data = np.genfromtxt(
tests_common.abspath(file_prefix +
"_reference_data_forces_torques.dat"))
s.part.add(pos=data[:, 1:4], dip=data[:, 4:7])
s.part.all().rotation = 3 * [True]
if dim == 2:
scafacos = espressomd.magnetostatics.Scafacos(
prefactor=1,
method_name="p2nfft",
method_params={
"p2nfft_verbose_tuning": 0,
"pnfft_N": "80,80,160",
"pnfft_window_name": "bspline",
"pnfft_m": "4",
"p2nfft_ignore_tolerance": "1",
"pnfft_diff_ik": "0",
"p2nfft_r_cut": "6",
"p2nfft_alpha": "0.8",
"p2nfft_epsB": "0.05"
})
s.actors.add(scafacos)
# change box geometry in x,y direction to ensure that
# scafacos survives it
s.box_l = np.array((1, 1, 1.3)) * box_l
else:
# 1d periodic in x
scafacos = espressomd.magnetostatics.Scafacos(
prefactor=1,
method_name="p2nfft",
method_params={
"p2nfft_verbose_tuning": 1,
"pnfft_N": "32,128,128",
"pnfft_direct": 0,
"p2nfft_r_cut": 2.855,
"p2nfft_alpha": "1.5",
"p2nfft_intpol_order": "-1",
"p2nfft_reg_kernel_name": "ewald",
"p2nfft_p": "16",
"p2nfft_ignore_tolerance": "1",
"pnfft_window_name": "bspline",
"pnfft_m": "8",
"pnfft_diff_ik": "1",
"p2nfft_epsB": "0.125"
})
s.box_l = np.array((1, 1, 1)) * box_l
s.actors.add(scafacos)
s.integrator.run(0)
# Calculate errors
err_f = self.vector_error(s.part.all().f, data[:, 7:10])
err_t = self.vector_error(s.part.all().torque_lab, data[:, 10:13])
err_e = s.analysis.energy()["dipolar"] - ref_E
tol_f = 2E-3
tol_t = 2E-3
tol_e = 1E-3
self.assertLessEqual(abs(err_e), tol_e,
"Energy difference too large")
self.assertLessEqual(abs(err_t), tol_t,
"Torque difference too large")
self.assertLessEqual(abs(err_f), tol_f,
"Force difference too large")
s.part.clear()
s.actors.clear()
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)
def test_scafacos(self):
rho = 0.3
# This is only for box size calculation. The actual particle number is
# lower, because particles are removed from the mdlc gap region
n_particle = 100
particle_radius = 0.5
#################################################
box_l = pow(((4 * n_particle * np.pi) /
(3 * rho)), 1.0 / 3.0) * particle_radius
skin = 0.5
s = espressomd.System(box_l=[1.0, 1.0, 1.0])
# give Espresso some parameters
s.time_step = 0.01
s.cell_system.skin = skin
s.box_l = 3 * [box_l]
for dim in 2, 1:
print("Dimension", dim)
# Read reference data
if dim == 2:
file_prefix = "data/mdlc"
s.periodicity = [1, 1, 0]
else:
s.periodicity = [1, 0, 0]
file_prefix = "data/scafacos_dipoles_1d"
with open(abspath(file_prefix +
"_reference_data_energy.dat")) as f:
ref_E = float(f.readline())
# Particles
data = np.genfromtxt(
abspath(file_prefix + "_reference_data_forces_torques.dat"))
for p in data[:, :]:
s.part.add(id=int(p[0]),
pos=p[1:4],
dip=p[4:7],
rotation=(1, 1, 1))
if dim == 2:
scafacos = magnetostatics.Scafacos(
prefactor=1,
method_name="p2nfft",
method_params={
"p2nfft_verbose_tuning": 0,
"pnfft_N": "80,80,160",
"pnfft_window_name": "bspline",
"pnfft_m": "4",
"p2nfft_ignore_tolerance": "1",
"pnfft_diff_ik": "0",
"p2nfft_r_cut": "6",
"p2nfft_alpha": "0.8",
"p2nfft_epsB": "0.05"
})
s.actors.add(scafacos)
# change box geometry in x,y direction to ensure that
# scafacos survives it
s.box_l = np.array((1, 1, 1.3)) * box_l
else:
if dim == 1:
# 1d periodic in x
scafacos = magnetostatics.Scafacos(
prefactor=1,
method_name="p2nfft",
method_params={
"p2nfft_verbose_tuning": 1,
"pnfft_N": "32,128,128",
"pnfft_direct": 0,
"p2nfft_r_cut": 2.855,
"p2nfft_alpha": "1.5",
"p2nfft_intpol_order": "-1",
"p2nfft_reg_kernel_name": "ewald",
"p2nfft_p": "16",
"p2nfft_ignore_tolerance": "1",
"pnfft_window_name": "bspline",
"pnfft_m": "8",
"pnfft_diff_ik": "1",
"p2nfft_epsB": "0.125"
})
s.box_l = np.array((1, 1, 1)) * box_l
s.actors.add(scafacos)
else:
raise Exception("This shouldn't happen.")
s.thermostat.turn_off()
s.integrator.run(0)
# Calculate errors
err_f = np.sum(
np.sqrt(np.sum((s.part[:].f - data[:, 7:10])**2, 1)),
0) / np.sqrt(data.shape[0])
err_t = np.sum(
np.sqrt(np.sum((s.part[:].torque_lab - data[:, 10:13])**2, 1)),
0) / np.sqrt(data.shape[0])
err_e = s.analysis.energy()["dipolar"] - ref_E
print("Energy difference", err_e)
print("Force difference", err_f)
print("Torque difference", err_t)
tol_f = 2E-3
tol_t = 2E-3
tol_e = 1E-3
self.assertLessEqual(abs(err_e), tol_e,
"Energy difference too large")
self.assertLessEqual(abs(err_t), tol_t,
"Torque difference too large")
self.assertLessEqual(abs(err_f), tol_f,
"Force difference too large")
s.part.clear()
del s.actors[0]
