def test_p3m_pressure(self):
pressures_via_virial = []
pressures_via_volume_scaling = []
p3m = electrostatics.P3M(
prefactor=2.0,
accuracy=1e-3,
mesh=16,
cao=6,
r_cut=1.4941e-01 * self.system.box_l[0])
self.system.actors.add(p3m)
print("Tune skin: {}".format(self.system.cell_system.tune_skin(
min_skin=0.0, max_skin=2.5, tol=0.05, int_steps=100)))
num_samples = 100
pressure_via_volume_scaling = pressureViaVolumeScaling(
self.system, self.kT)
for i in range(num_samples):
self.system.integrator.run(100)
pressures_via_virial.append(
self.system.analysis.pressure()['total'])
pressure_via_volume_scaling.measure_pressure_via_volume_scaling()
pressure_virial = np.mean(pressures_via_virial)
# deviation should be below 5%
abs_deviation_in_percent = 100 * abs(
pressure_virial / pressure_via_volume_scaling.get_result() - 1.0)
npt.assert_array_less(abs_deviation_in_percent, 5.0)
def test_electrostatics(self):
from espressomd import electrostatics
self.system.part[0].pos = [1, 2, 2]
self.system.part[1].pos = [3, 2, 2]
self.system.part[0].q = 1
self.system.part[1].q = -1
p3m = electrostatics.P3M(prefactor=1.0,
accuracy=9.910945054074526e-08,
mesh=[22, 22, 22],
cao=7,
r_cut=8.906249999999998,
alpha=0.387611049779351,
tune=False)
self.system.actors.add(p3m)
# did not verify if this is correct, but looks pretty good (close to
# 1/2)
u_p3m = -0.501062398379
energy = self.system.analysis.energy()
self.assertAlmostEqual(energy["total"], u_p3m, delta=1e-5)
self.assertAlmostEqual(energy["kinetic"], 0., delta=1e-7)
self.assertAlmostEqual(energy["bonded"], 0., delta=1e-7)
self.assertAlmostEqual(energy["non_bonded"], 0, delta=1e-7)
self.assertAlmostEqual(energy["coulomb"], u_p3m, delta=1e-7)
self.system.part[0].q = 0
self.system.part[1].q = 0
self.system.part[0].pos = [1, 2, 2]
self.system.part[1].pos = [5, 2, 2]
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)
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)
return ValueError("No combination rule defined")
# Lennard-Jones interactions parameters
for s in [["Cl", "Na"], ["Cl", "Cl"], ["Na", "Na"]]:
lj_sig = combination_rule_sigma("Berthelot", lj_sigmas[s[0]],
lj_sigmas[s[1]])
lj_cut = combination_rule_sigma("Berthelot", lj_cuts[s[0]], lj_cuts[s[1]])
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")
print("\n--->Tuning Electrostatics")
p3m = electrostatics.P3M(prefactor=l_bjerrum, accuracy=1e-2)
system.actors.add(p3m)
def main():
print("\n--->Temperature Equilibration")
system.time = 0.0
for i in range(num_steps_equilibration):
energy = system.analysis.energy()
temp_measured = energy['kinetic'] / ((3.0 / 2.0) * n_part)
print("t={0:.1f}, E_total={1:.2f}, E_coulomb={2:.2f}, T_cur={3:.4f}".
format(system.time, energy['total'], energy['coulomb'],
temp_measured))
system.integrator.run(100)
visualizer.update()
act_min_dist = system.analysis.min_dist()
print("Start with minimal distance {}".format(act_min_dist))
system.cell_system.max_num_cells = 14**3
# Assign charges to particles
for i in range(n_part // 2 - 1):
system.part[2 * i].q = -1.0
system.part[2 * i + 1].q = 1.0
# P3M setup after charge assignment
#############################################################
print("\nSCRIPT--->Create p3m\n")
#p3m = electrostatics.P3M_GPU(prefactor=2.0, accuracy=1e-2)
p3m = electrostatics.P3M(prefactor=1.0, accuracy=1e-2)
print("\nSCRIPT--->Add actor\n")
system.actors.add(p3m)
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()):
sys.stdout.flush()
system.integrator.run(integ_steps)
ljcap+=5
system.force_cap = 0
#let the colloid move now that bad overlaps have been eliminated
for i in range(n_col_part):
system.part[i].fix=np.zeros(3,dtype=np.int)
# Turning on the electrostatics
errorCoulomb = 0.01
print("\n# p3m starting...")
sys.stdout.flush()
bjerrum = 2.
p3m = electrostatics.P3M(bjerrum_length=bjerrum, accuracy=0.001)
system.actors.add(p3m)
print("# p3m started!")
system.time_step=time_step
#note that it is important to set all of the particle velocities to zero just before initializing the LB so that the total system momentum is zero
system.galilei.kill_particle_motion()
system.thermostat.turn_off()
lb=espressomd.lb.LBFluidGPU(dens=1., visc=3., agrid=1., tau=time_step, fric=20)
system.actors.add(lb)
#replace the Langevin thermostat with the lb thermostat
system.thermostat.set_lb(kT=1.)
# Lennard-Jones interactions parameters
for i in range(len(species)):
for j in range(i, len(species)):
s = [species[i], species[j]]
lj_sig = combination_rule_sigma(
"Berthelot", lj_sigmas[s[0]], lj_sigmas[s[1]])
lj_cut = combination_rule_sigma(
"Berthelot", lj_cuts[s[0]], lj_cuts[s[1]])
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")
energy = system.analysis.energy()
print("Before Minimization: E_total = {}".format(energy['total']))
system.minimize_energy.init(f_max=1000, gamma=30.0,
max_steps=1000, max_displacement=0.01)
system.minimize_energy.minimize()
energy = system.analysis.energy()
print("After Minimization: E_total = {}".format(energy['total']))
print("Tune p3m")
p3m = electrostatics.P3M(prefactor=coulomb_prefactor, accuracy=1e-1)
system.actors.add(p3m)
system.thermostat.set_langevin(kT=temperature, gamma=2.0)
visualizer.run(1)
lj_sigmas[s[1]])
lj_cut = combination_rule_sigma("Berthelot", lj_cuts[s[0]], lj_cuts[s[1]])
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(bjerrum_length=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 Ez
Ez += 1000
for p in system.part:
p.ext_force = [0, 0, Ez * p.q]
print(Ez)
def decreaseElectricField():
global Ez
def main():
print("\n--->Setup system")
# System parameters
n_ppside = 10
n_part = int(n_ppside**3)
n_ionpairs = n_part / 2
density = 1.5736
time_step = 0.001823
temp = 298.0
gamma = 20.0
#l_bjerrum = 0.885^2 * e^2/(4*pi*epsilon_0*k_B*T)
l_bjerrum = 130878.0 / temp
num_steps_equilibration = 3000
num_configs = 50
integ_steps_per_config = 500
# Particle parameters
types = {"Cl": 0, "Na": 1}
numbers = {"Cl": n_ionpairs, "Na": n_ionpairs}
charges = {"Cl": -1.0, "Na": 1.0}
lj_sigmas = {"Cl": 3.85, "Na": 2.52}
lj_epsilons = {"Cl": 192.45, "Na": 17.44}
lj_cuts = {"Cl": 3.0 * lj_sigmas["Cl"], "Na": 3.0 * lj_sigmas["Na"]}
masses = {"Cl": 35.453, "Na": 22.99}
# Setup System
box_l = (n_ionpairs * sum(masses.values()) / density)**(1. / 3.)
system.box_l = [box_l, box_l, box_l]
system.periodicity = [1, 1, 1]
system.time_step = time_step
system.cell_system.skin = 0.3
system.thermostat.set_langevin(kT=temp, gamma=gamma)
# Place particles
q = 1
l = box_l / n_ppside
for i in range(n_ppside):
for j in range(n_ppside):
for k in range(n_ppside):
p = numpy.array([i, j, k]) * l
if q < 0:
system.part.add(id=len(system.part),
type=types["Cl"],
pos=p,
q=charges["Cl"],
mass=masses["Cl"])
else:
system.part.add(id=len(system.part),
type=types["Na"],
pos=p,
q=charges["Na"],
mass=masses["Na"])
q *= -1
q *= -1
q *= -1
def combination_rule_epsilon(rule, eps1, eps2):
if rule == "Lorentz":
return (eps1 * eps2)**0.5
else:
return ValueError("No combination rule defined")
def combination_rule_sigma(rule, sig1, sig2):
if rule == "Berthelot":
return (sig1 + sig2) * 0.5
else:
return ValueError("No combination rule defined")
# Lennard-Jones interactions parameters
for s in [["Cl", "Na"], ["Cl", "Cl"], ["Na", "Na"]]:
lj_sig = combination_rule_sigma("Berthelot", lj_sigmas[s[0]],
lj_sigmas[s[1]])
lj_cut = combination_rule_sigma("Berthelot", lj_cuts[s[0]],
lj_cuts[s[1]])
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")
print("\n--->Tuning Electrostatics")
#p3m = electrostatics.P3M(bjerrum_length=l_bjerrum, accuracy=1e-2, mesh=[84,84,84], cao=6)
p3m = electrostatics.P3M(bjerrum_length=l_bjerrum, accuracy=1e-2)
system.actors.add(p3m)
print("\n--->Temperature Equilibration")
system.time = 0.0
for i in range(int(num_steps_equilibration / 100)):
energy = system.analysis.energy()
temp_measured = energy['kinetic'] / ((3.0 / 2.0) * n_part)
print("t={0:.1f}, E_total={1:.2f}, E_coulomb={2:.2f}, T_cur={3:.4f}".
format(system.time, energy['total'], energy['coulomb'],
temp_measured))
system.integrator.run(100)
visualizer.update()
print("\n--->Integration")
system.time = 0.0
while (True):
system.integrator.run(1)
visualizer.update()
print("After Minimization: E_total = {}".format(energy["total"]))
system.integrator.set_vv()
system.thermostat.set_langevin(kT=1.0, gamma=1.0, seed=42)
# tuning and equilibration
system.integrator.run(min(3 * measurement_steps, 1000))
print("Tune skin: {}".format(
system.cell_system.tune_skin(min_skin=0.4,
max_skin=1.6,
tol=0.05,
int_steps=100,
adjust_max_skin=True)))
system.integrator.run(min(3 * measurement_steps, 3000))
print("Tune p3m")
p3m = electrostatics.P3M(prefactor=args.prefactor, accuracy=1e-4)
system.actors.add(p3m)
system.integrator.run(min(3 * measurement_steps, 3000))
print("Tune skin: {}".format(
system.cell_system.tune_skin(min_skin=1.0,
max_skin=1.6,
tol=0.05,
int_steps=100,
adjust_max_skin=True)))
if not args.visualizer:
# print initial energies
energies = system.analysis.energy()
print(energies)
# time integration loop
for i in range(N0):
system.part.add(id=i, pos=np.random.random(3) * system.box_l, type=1, q=-1)
for i in range(N0, 2 * N0):
system.part.add(id=i, pos=np.random.random(3) * system.box_l, type=2, q=1)
lj_eps = 1.0
lj_sig = 1.0
lj_cut = 2**(1.0 / 6)
types = [0, 1, 2]
for type_1 in types:
for type_2 in types:
system.non_bonded_inter[type_1, type_2].lennard_jones.set_params(
epsilon=lj_eps, sigma=lj_sig,
cutoff=lj_cut, shift="auto")
p3m = electrostatics.P3M(prefactor=0.9, accuracy=1e-3)
system.actors.add(p3m)
p3m_params = p3m.get_params()
for key in list(p3m_params.keys()):
print("{} = {}".format(key, p3m_params[key]))
# Warmup
#############################################################
# warmup integration (with capped LJ potential)
warm_steps = 1000
warm_n_times = 20
# do the warmup until the particles have at least the distance min_dist
# set LJ cap
lj_cap = 20
system.force_cap = lj_cap
for i in range(nHCl):
system.part.add(pos=np.random.random(3) * system.box_l,
type=type_Cl,
q=charges[type_Cl])
# setting up LJ-interactions
for i in range(1, 5):
for j in range(i + 1, 6):
system.non_bonded_inter[i, j].lennard_jones.set_params(epsilon=lj_eps,
sigma=lj_sig,
cutoff=lj_cut,
shift=lj_shift)
# Setting up electrostatics
#
p3m = electrostatics.P3M(prefactor=l_bjerrum * temperature, accuracy=1e-3)
system.actors.add(p3m)
K_diss = 0.002694
K_w = 10.**(-14) * 0.02694**2
RE = None
if (mode == "reaction_ensemble"):
RE = reaction_ensemble.ReactionEnsemble(temperature=temperature,
exclusion_radius=1,
seed=3)
elif (mode == "constant_pH_ensemble"):
RE = reaction_ensemble.ConstantpHEnsemble(temperature=temperature,
exclusion_radius=1,
seed=3)
RE.constant_pH = 0
energy = system.analysis.energy()
print("After Minimization: E_total = {}".format(energy["total"]))
system.integrator.set_vv()
system.thermostat.set_langevin(kT=1.0, gamma=1.0, seed=42)
# tuning and equilibration
system.integrator.run(min(3 * measurement_steps, 1000))
print("Tune skin: {}".format(
system.cell_system.tune_skin(min_skin=0.4,
max_skin=1.6,
tol=0.05,
int_steps=100)))
system.integrator.run(min(3 * measurement_steps, 3000))
print("Tune p3m")
p3m = electrostatics.P3M(prefactor=args.bjerrum_length, accuracy=1e-4)
system.actors.add(p3m)
system.integrator.run(min(3 * measurement_steps, 3000))
print("Tune skin: {}".format(
system.cell_system.tune_skin(min_skin=1.0,
max_skin=1.6,
tol=0.05,
int_steps=100)))
if not args.visualizer:
# print initial energies
energies = system.analysis.energy()
print(energies)
# time integration loop
print("Timing every {} steps".format(measurement_steps))
lj_cut = 2.**(1. / 6.)
system.non_bonded_inter[0, 0].lennard_jones.set_params(
epsilon=lj_eps, sigma=lj_sig, cutoff=lj_cut, shift="auto")
system.non_bonded_inter[1, 0].lennard_jones.set_params(
epsilon=lj_eps, sigma=lj_sig, cutoff=lj_cut, shift="auto")
system.non_bonded_inter[1, 1].lennard_jones.set_params(
epsilon=lj_eps, sigma=lj_sig, cutoff=lj_cut, shift="auto")
# Check if electrostatics method is clear...
if method not in implemented_methods:
print("Please select an electrostatics method in the script.")
exit()
# Distinguish between different methods
if method == "p3m":
p3m = electrostatics.P3M(bjerrum_length=10.0, accuracy=1e-3)
system.actors.add(p3m)
print("P3M parameter:\n")
p3m_params = p3m.get_params()
for key in p3m_params.keys():
print("{} = {}".format(key, p3m_params[key]))
# elif method == "memd":
# TODO
if "ROTATION" in code_info.features():
deg_free = 6
else:
deg_free = 3
# Integration parameters
integ_steps = 200
