def test_elc(self):
"""
Testing ELC against the analytic solution for an infinite large simulation box with dielectric contrast on the bottom of the box, which can be calculated analytically with image charges.
"""
self.system.part.add(id=1, pos=self.system.box_l / 2., q=self.q[0])
self.system.part.add(id=2,
pos=self.system.box_l / 2. +
[0, 0, self.distance],
q=-self.q[0])
self.system.box_l = [self.box_l, self.box_l, self.box_l + self.elc_gap]
self.system.cell_system.set_domain_decomposition(use_verlet_lists=True)
self.system.periodicity = [1, 1, 1]
p3m = espressomd.electrostatics.P3M(prefactor=self.prefactor,
accuracy=self.accuracy,
mesh=[58, 58, 70],
cao=4)
self.system.actors.add(p3m)
elc = electrostatic_extensions.ELC(gap_size=self.elc_gap,
maxPWerror=self.accuracy,
delta_mid_bot=self.delta_mid_bot,
delta_mid_top=self.delta_mid_top)
self.system.actors.add(elc)
elc_results = self.scan()
# ANALYTIC SOLUTION
charge_reshaped = self.prefactor * np.square(self.q.reshape(-1, 1))
analytic_force = charge_reshaped * (
1 / self.distance**2 + self.delta_mid_bot *
(1 / np.square(2 * self.zPos) -
1 / np.square(2 * self.zPos + self.distance)))
analytic_energy = charge_reshaped * (
-1 / self.distance + self.delta_mid_bot *
(1 / (4 * self.zPos) - 1 / (2 * self.zPos + self.distance) + 1 /
(4 * (self.zPos + self.distance))))
analytic_results = np.dstack((analytic_force, analytic_energy))
np.testing.assert_allclose(elc_results,
analytic_results,
rtol=0,
atol=self.check_accuracy)
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 = self.buf_node_grid
self.S.periodicity=1,1,1
self.S.box_l = (10, 10, 10)
p3m=el.P3M(prefactor=1, accuracy = 1e-6,mesh=(64,64,64))
self.S.actors.add(p3m)
elc=el_ext.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_finite_potential_drop(self):
s = self.system
p1 = s.part.add(pos=GAP + [0, 0, 1], q=+1)
p2 = s.part.add(pos=GAP + [0, 0, 9], q=-1)
s.actors.add(
electrostatics.P3M(
# zero is not allowed
prefactor=1e-100,
mesh=32,
cao=5,
accuracy=1e-3,
))
s.actors.add(
electrostatic_extensions.ELC(
gap_size=GAP[2],
maxPWerror=1e-3,
delta_mid_top=-1,
delta_mid_bot=-1,
const_pot=1,
pot_diff=POTENTIAL_DIFFERENCE,
))
# Calculated energy
U_elc = s.analysis.energy()['coulomb']
# Expected E-Field is voltage drop over the box
E_expected = POTENTIAL_DIFFERENCE / (BOX_L[2] - GAP[2])
# Expected potential is -E_expected * z, so
U_expected = -E_expected * (p1.pos[2] * p1.q + p2.pos[2] * p2.q)
self.assertAlmostEqual(U_elc, U_expected)
s.integrator.run(0)
self.assertAlmostEqual(E_expected, p1.f[2] / p1.q)
self.assertAlmostEqual(E_expected, p2.f[2] / p2.q)
lj_eps = combination_rule_epsilon("Lorentz", lj_epsilons[s[0]],
lj_epsilons[s[1]])
system.non_bonded_inter[types[s[0]], types[s[1]]].lennard_jones.set_params(
epsilon=lj_eps, sigma=lj_sig, cutoff=lj_cut, shift="auto")
system.minimize_energy.init(f_max=10,
gamma=10,
max_steps=2000,
max_displacement=0.1)
system.minimize_energy.minimize()
print("\n--->Tuning Electrostatics")
p3m = electrostatics.P3M(prefactor=l_bjerrum, accuracy=1e-2)
system.actors.add(p3m)
elc = electrostatic_extensions.ELC(gap_size=elc_gap, maxPWerror=1e-3)
system.actors.add(elc)
def increaseElectricField():
global Vz
Vz += 3
for p in system.part:
p.ext_force = [0, 0, p.q * Vz * Vz_to_Ez]
print('Potential difference: {:.0V}'.format(Vz))
def decreaseElectricField():
global Ez
Vz -= 3
for p in system.part:
def test_elc_vs_mmm2d(self):
elc_param_sets = {
"inert": {
"gap_size": self.elc_gap,
"maxPWerror": self.acc
},
"dielectric": {
"gap_size": self.elc_gap,
"maxPWerror": self.acc,
"delta_mid_bot": 0.1,
"delta_mid_top": 0.9
},
"const_pot_0": {
"gap_size": self.elc_gap,
"maxPWerror": self.acc,
"const_pot": 1,
"pot_diff": 0.0
},
"const_pot_1": {
"gap_size": self.elc_gap,
"maxPWerror": self.acc,
"const_pot": 1,
"pot_diff": 1.0
},
"const_pot_m1": {
"gap_size": self.elc_gap,
"maxPWerror": self.acc,
"const_pot": 1,
"pot_diff": -1.0
}
}
mmm2d_param_sets = {
"inert": {
"prefactor": 1.0,
"maxPWerror": self.acc
},
"dielectric": {
"prefactor": 1.0,
"maxPWerror": self.acc,
"dielectric_contrast_on": 1,
"delta_mid_bot": 0.1,
"delta_mid_top": 0.9
},
"const_pot_0": {
"prefactor": 1.0,
"maxPWerror": self.acc,
"const_pot": 1,
"pot_diff": 0.0
},
"const_pot_1": {
"prefactor": 1.0,
"maxPWerror": self.acc,
"const_pot": 1,
"pot_diff": 1.0
},
"const_pot_m1": {
"prefactor": 1.0,
"maxPWerror": self.acc,
"const_pot": 1,
"pot_diff": -1.0
}
}
self.system.box_l = [self.box_l, self.box_l, self.box_l]
buf_node_grid = self.system.cell_system.node_grid
self.system.cell_system.set_layered(n_layers=10,
use_verlet_lists=False)
self.system.periodicity = [1, 1, 0]
q = 1.0
self.system.part.add(id=0, pos=(5.0, 5.0, 5.0), q=-q)
self.system.part.add(id=1, pos=(2.0, 2.0, 5.0), q=q / 3.0)
self.system.part.add(id=2, pos=(2.0, 5.0, 2.0), q=q / 3.0)
self.system.part.add(id=3, pos=(5.0, 2.0, 7.0), q=q / 3.0)
#MMM2D
mmm2d = MMM2D(**mmm2d_param_sets["inert"])
self.system.actors.add(mmm2d)
mmm2d_res = {}
mmm2d_res["inert"] = self.scan()
mmm2d.set_params(**mmm2d_param_sets["dielectric"])
mmm2d_res["dielectric"] = self.scan()
mmm2d.set_params(**mmm2d_param_sets["const_pot_0"])
mmm2d_res["const_pot_0"] = self.scan()
mmm2d.set_params(**mmm2d_param_sets["const_pot_1"])
mmm2d_res["const_pot_1"] = self.scan()
mmm2d.set_params(**mmm2d_param_sets["const_pot_m1"])
mmm2d_res["const_pot_m1"] = self.scan()
self.system.actors.remove(mmm2d)
#ELC
self.system.box_l = [self.box_l, self.box_l, self.box_l + self.elc_gap]
self.system.cell_system.set_domain_decomposition(use_verlet_lists=True)
self.system.cell_system.node_grid = buf_node_grid
self.system.periodicity = [1, 1, 1]
p3m = P3M(prefactor=1.0, accuracy=self.acc, mesh=[16, 16, 24], cao=6)
self.system.actors.add(p3m)
elc = electrostatic_extensions.ELC(**elc_param_sets["inert"])
self.system.actors.add(elc)
elc_res = {}
elc_res["inert"] = self.scan()
elc.set_params(**elc_param_sets["dielectric"])
elc_res["dielectric"] = self.scan()
elc.set_params(**elc_param_sets["const_pot_0"])
elc_res["const_pot_0"] = self.scan()
elc.set_params(**elc_param_sets["const_pot_1"])
elc_res["const_pot_1"] = self.scan()
elc.set_params(**elc_param_sets["const_pot_m1"])
elc_res["const_pot_m1"] = self.scan()
for run in elc_res:
self.assertTrue(
np.testing.assert_allclose(
mmm2d_res[run], elc_res[run], rtol=0, atol=1e-4) == None)
system.constraints.add(shape=espressomd.shapes.Wall(dist=-box_l,
normal=[0, 0, -1]),
particle_type=1)
system.non_bonded_inter[0, 1].wca.set_params(epsilon=1.0, sigma=1.0)
system.non_bonded_inter[0, 0].wca.set_params(epsilon=1.0, sigma=1.0)
energy = system.analysis.energy()
print("Before Minimization: E_total=", energy['total'])
steepest_descent(system,
f_max=10,
gamma=50.0,
max_steps=1000,
max_displacement=0.2)
energy = system.analysis.energy()
print("After Minimization: E_total=", energy['total'])
system.thermostat.set_langevin(kT=0.1, gamma=1.0, seed=42)
p3m = electrostatics.P3M(prefactor=1.0, accuracy=1e-2)
system.actors.add(p3m)
elc = electrostatic_extensions.ELC(maxPWerror=1.0,
gap_size=elc_gap,
const_pot=True,
pot_diff=potential_diff)
system.actors.add(elc)
visualizer.run(1)
def test_elc_vs_mmm2d(self):
elc_param_sets = {
"inert": {
"gap_size": self.elc_gap,
"maxPWerror": self.acc,
"neutralize": False,
"check_neutrality": False
}
# "const_pot_0": {
# "gap_size": self.elc_gap,
# "maxPWerror": self.acc,
# "const_pot": True,
# "pot_diff": 0.0},
# "const_pot_1": {
# "gap_size": self.elc_gap,
# "maxPWerror": self.acc,
# "const_pot": True,
# "pot_diff": 1.0},
# "const_pot_m1": {
# "gap_size": self.elc_gap,
# "maxPWerror": self.acc,
# "const_pot": True,
# "pot_diff": -1.0}
}
mmm2d_param_sets = {
"inert": {
"prefactor": 1.0,
"maxPWerror": self.acc,
"check_neutrality": False
}
# "const_pot_0": {
# "prefactor": 1.0,
# "maxPWerror": self.acc,
# "const_pot": True,
# "pot_diff": 0.0},
# "const_pot_1": {
# "prefactor": 1.0,
# "maxPWerror": self.acc,
# "const_pot": True,
# "pot_diff": 1.0},
# "const_pot_m1": {
# "prefactor": 1.0,
# "maxPWerror": self.acc,
# "const_pot": True,
# "pot_diff": -1.0}
}
self.system.box_l = 3 * [self.box_l]
buf_node_grid = self.system.cell_system.node_grid
self.system.cell_system.set_layered(n_layers=10,
use_verlet_lists=False)
self.system.periodicity = [1, 1, 0]
q = 1.0
self.system.part.add(id=0, pos=(5.0, 5.0, 5.0), q=-3.0 * q)
self.system.part.add(id=1, pos=(2.0, 2.0, 5.0), q=q / 3.0)
self.system.part.add(id=2, pos=(2.0, 5.0, 2.0), q=q / 3.0)
self.system.part.add(id=3, pos=(5.0, 2.0, 7.0), q=q / 3.0)
# MMM2D
mmm2d = espressomd.electrostatics.MMM2D(**mmm2d_param_sets["inert"])
self.system.actors.add(mmm2d)
mmm2d_res = {}
mmm2d_res["inert"] = self.scan()
# mmm2d.set_params(**mmm2d_param_sets["const_pot_0"])
# mmm2d_res["const_pot_0"] = self.scan()
# mmm2d.set_params(**mmm2d_param_sets["const_pot_1"])
# mmm2d_res["const_pot_1"] = self.scan()
# mmm2d.set_params(**mmm2d_param_sets["const_pot_m1"])
# mmm2d_res["const_pot_m1"] = self.scan()
self.system.actors.remove(mmm2d)
# ELC
self.system.box_l = [self.box_l, self.box_l, self.box_l + self.elc_gap]
self.system.cell_system.set_domain_decomposition(use_verlet_lists=True)
self.system.cell_system.node_grid = buf_node_grid
self.system.periodicity = [1, 1, 1]
p3m = espressomd.electrostatics.P3M(prefactor=1.0,
accuracy=self.acc,
mesh=[20, 20, 32],
cao=7,
check_neutrality=False)
self.system.actors.add(p3m)
elc = electrostatic_extensions.ELC(**elc_param_sets["inert"])
self.system.actors.add(elc)
elc_res = {}
elc_res["inert"] = self.scan()
# elc.set_params(**elc_param_sets["const_pot_0"])
# elc_res["const_pot_0"] = self.scan()
# elc.set_params(**elc_param_sets["const_pot_1"])
# elc_res["const_pot_1"] = self.scan()
# elc.set_params(**elc_param_sets["const_pot_m1"])
# elc_res["const_pot_m1"] = self.scan()
for run in elc_res:
self.assertTrue(
np.testing.assert_allclose(
mmm2d_res[run], elc_res[run], rtol=0, atol=1e-4) is None)
def test_elc_and_mmm2d(self):
"""
Testing ELC and MMM2D against the analytic solution for an infinite large simulation box with dielectric contrast on the bottom of the box, which can be calculated analytically with image charges.
"""
# MMM2D
self.system.cell_system.skin = 0.1
buf_node_grid = self.system.cell_system.node_grid
self.system.cell_system.set_layered(n_layers=10,
use_verlet_lists=False)
self.system.periodicity = [1, 1, 0]
self.system.part.add(id=1, pos=self.system.box_l / 2., q=self.q[0])
self.system.part.add(id=2,
pos=self.system.box_l / 2. + [0, 0, 1],
q=-self.q[0])
# MMM2D
mmm2d = espressomd.electrostatics.MMM2D(
prefactor=1.0,
maxPWerror=self.accuracy,
delta_mid_bot=self.delta_mid_bot,
delta_mid_top=self.delta_mid_top,
dielectric_contrast_on=1)
self.system.actors.add(mmm2d)
mmm2d_results = self.scan()
self.system.actors.remove(mmm2d)
# ELC
self.system.box_l = [self.box_l, self.box_l, self.box_l + self.elc_gap]
self.system.cell_system.set_domain_decomposition(use_verlet_lists=True)
self.system.cell_system.node_grid = buf_node_grid
self.system.periodicity = [1, 1, 1]
p3m = espressomd.electrostatics.P3M(prefactor=1.,
accuracy=self.accuracy,
mesh=[58, 58, 70],
cao=4)
self.system.actors.add(p3m)
elc = electrostatic_extensions.ELC(gap_size=self.elc_gap,
maxPWerror=self.accuracy,
delta_mid_bot=self.delta_mid_bot,
delta_mid_top=self.delta_mid_top)
self.system.actors.add(elc)
elc_results = self.scan()
# ANALYTIC SOLUTION
charge_reshaped = np.square(self.q.reshape(-1, 1))
analytic_force = charge_reshaped * (
1 / self.distance**2 + self.delta_mid_bot *
(1 / np.square(2 * self.zPos) -
1 / np.square(2 * self.zPos + self.distance)))
analytic_energy = charge_reshaped * (
-1 / self.distance + self.delta_mid_bot *
(1 / (4 * self.zPos) - 1 / (2 * self.zPos + self.distance) + 1 /
(4 * (self.zPos + self.distance))))
analytic_results = np.dstack((analytic_force, analytic_energy))
self.assertTrue(
np.testing.assert_allclose(mmm2d_results,
analytic_results,
rtol=0,
atol=self.check_accuracy) is None)
self.assertTrue(
np.testing.assert_allclose(elc_results,
analytic_results,
rtol=0,
atol=self.check_accuracy) is None)
print("\nSCRIPT--->P3M parameter:\n")
p3m_params = p3m.get_params()
for key in list(p3m_params.keys()):
print("{} = {}".format(key, p3m_params[key]))
print("\nSCRIPT--->Explicit tune call\n")
p3m.tune(accuracy=1e3)
print("\nSCRIPT--->P3M parameter:\n")
p3m_params = p3m.get_params()
for key in list(p3m_params.keys()):
print("{} = {}".format(key, p3m_params[key]))
if args.mode == "elc":
elc = electrostatic_extensions.ELC(maxPWerror=1.0, gap_size=1.0)
system.actors.add(elc)
print(system.actors)
#############################################################
# Warmup Integration #
#############################################################
print("""
Start warmup integration:
At maximum {} times {} steps
Stop if minimal distance is larger than {}
""".strip().format(warm_n_times, warm_steps, min_dist))
# minimize energy using min_dist as the convergence criterion
