def test_structure_to_hoomdsimulation(self, ethane):
import hoomd
from foyer.forcefield import Forcefield
from mbuild.formats.hoomd_simulation import create_hoomd_simulation
ff = Forcefield(name="oplsaa")
structure = ff.apply(ethane)
sim = hoomd.context.SimulationContext()
with sim:
create_hoomd_simulation(structure, 2.5)
sim_forces = hoomd.context.current.forces
pair_force = import_("hoomd.md.pair")
charge_force = import_("hoomd.md.charge")
special_pair_force = import_("hoomd.md.special_pair")
bond_force = import_("hoomd.md.bond")
angle_force = import_("hoomd.md.angle")
dihedral_force = import_("hoomd.md.dihedral")
assert isinstance(sim_forces[0], pair_force.lj)
assert isinstance(sim_forces[1], charge_force.pppm)
assert isinstance(sim_forces[2], pair_force.ewald)
assert isinstance(sim_forces[3], special_pair_force.lj)
assert isinstance(sim_forces[4], special_pair_force.coulomb)
assert isinstance(sim_forces[5], bond_force.harmonic)
assert isinstance(sim_forces[6], angle_force.harmonic)
assert isinstance(sim_forces[7], dihedral_force.opls)
def simulate(parametrized_structure, **kwargs):
""" Simulate in Hoomd
Parameters
----------
parametrized_structure : parmed.Structure
**kwargs : kwargs for run_hoomd_simulation
"""
from mbuild.formats.hoomd_simulation import create_hoomd_simulation
create_hoomd_simulation(parametrized_structure,
ref_distance=10,
ref_energy=1 / 4.184,
r_cut=1.4)
run_hoomd_simulation(**kwargs)
def test_hoomdsimulation_restart(self):
import gsd.hoomd
import hoomd
from foyer.forcefield import Forcefield
from mbuild.formats.hoomd_simulation import create_hoomd_simulation
box = mb.Compound()
box.add(mb.Compound(name="Ar", pos=[1, 1, 1]))
box.add(mb.Compound(name="Ar", pos=[1, 1, 1]))
ff = Forcefield(forcefield_files=get_fn("lj.xml"))
structure = ff.apply(box)
structure.box = [10, 10, 10, 90, 90, 90]
sim = hoomd.context.SimulationContext()
with sim:
hoomd_obj, ref_vals = create_hoomd_simulation(
structure, 2.5, restart=get_fn("restart.gsd"))
sim_forces = hoomd.context.current.forces
pair_force = import_("hoomd.md.pair")
assert isinstance(sim_forces[0], pair_force.lj)
snap = hoomd_obj[0]
with gsd.hoomd.open(get_fn("restart.gsd")) as f:
rsnap = f[0]
assert np.array_equal(snap.particles.position,
rsnap.particles.position)
def test_lj_to_hoomdsimulation(self):
import hoomd
from foyer.forcefield import Forcefield
from mbuild.formats.hoomd_simulation import create_hoomd_simulation
box = mb.Compound()
box.add(mb.Compound(name="Ar", pos=[1, 1, 1]))
box.add(mb.Compound(name="Ar", pos=[1, 1, 1]))
ff = Forcefield(forcefield_files=get_fn("lj.xml"))
structure = ff.apply(box)
structure.box = [10, 10, 10, 90, 90, 90]
sim = hoomd.context.SimulationContext()
with sim:
create_hoomd_simulation(structure, 2.5)
sim_forces = hoomd.context.current.forces
pair_force = import_("hoomd.md.pair")
assert isinstance(sim_forces[0], pair_force.lj)
def build_run_measure_hoomd(structure, **kwargs):
""" Build and run a HOOMD simulation from a parmed.Structure """
hoomd.util.quiet_status()
hoomd.context.initialize("--msg-file=hoomd.out")
create_hoomd_simulation(structure, **kwargs)
all_group = hoomd.group.all()
# Arbitrary small simulation
hoomd.md.integrate.mode_standard(dt=0.0000001)
hoomd.md.integrate.nve(all_group)
hoomd.run(1)
hoomd_force_groups = get_hoomd_force_groups()
energies = {
'hoomd': {
key: get_hoomd_energy(key, hoomd_force_groups, all_group)
for key in hoomd_force_groups
}
}
df = pd.DataFrame.from_dict(energies, orient='index')
return df
def run(self):
"""Run the simulation."""
hoomd_args = f"--single-mpi --mode={self.mode}"
sim = hoomd.context.initialize(hoomd_args)
with sim:
hoomd.util.quiet_status()
# mbuild units are nm, amu
hoomd_objects, ref_values = create_hoomd_simulation(
self.system, auto_scale=True, restart=self.restart)
self.ref_values = ref_values
snap = hoomd_objects[0]
hoomd.util.unquiet_status()
if self.target_length is not None:
self.target_length /= ref_values.distance
if self.e_factor != 1:
print("Scaling LJ coeffs by e_factor")
hoomd.util.quiet_status()
# catch all instances of LJ pair
ljtypes = [
i for i in sim.forces if isinstance(i, hoomd.md.pair.lj)
or isinstance(i, hoomd.md.special_pair.lj)
]
for lj in ljtypes:
pair_list = lj.get_metadata()["pair_coeff"].get_metadata()
for pair_dict in pair_list:
# Scale the epsilon values by e_factor
try:
a, b, new_dict = set_coeffs(
pair_dict, self.e_factor)
lj.pair_coeff.set(a, b, **new_dict)
except ValueError:
# if the pair has not been defined,
# it will not have a dictionary object
# instead it will be a string (e.g. "ca-ca")
# and will fail when trying to make the new_dict
pass
hoomd.util.unquiet_status()
integrator_mode = hoomd.md.integrate.mode_standard(dt=self.dt)
all_particles = hoomd.group.all()
try:
integrator = hoomd.md.integrate.nvt(group=both,
tau=self.tau,
kT=self.shrink_kT_reduced)
except NameError:
# both does not exist
integrator = hoomd.md.integrate.nvt(group=all_particles,
tau=self.tau,
kT=self.shrink_kT_reduced)
hoomd.dump.gsd(
filename="trajectory.gsd",
period=self.gsd_write,
group=all_particles,
overwrite=False,
phase=0,
dynamic=["momentum"],
)
gsd_restart = hoomd.dump.gsd(
"restart.gsd",
period=self.gsd_write,
group=all_particles,
truncate=True,
phase=0,
dynamic=["momentum"],
)
log_quantities = [
"temperature",
"pressure",
"volume",
"potential_energy",
"kinetic_energy",
"pair_lj_energy",
"bond_harmonic_energy",
"angle_harmonic_energy",
]
hoomd.analyze.log(
"trajectory.log",
quantities=log_quantities,
period=self.log_write,
header_prefix="#",
overwrite=False,
phase=0,
)
if self.restart is None:
integrator.randomize_velocities(seed=42)
if self.target_length is not None:
# Run the shrink step
final_length = self.target_length.to("Angstrom").value
final_box = (self.shrink_steps, final_length)
size_variant = hoomd.variant.linear_interp(
[(0, snap.box.Lx), final_box], zero=0)
box_resize = hoomd.update.box_resize(L=size_variant)
hoomd.run_upto(self.shrink_steps)
box_resize.disable()
self.n_steps += self.shrink_steps
# After shrinking, reset velocities and change temp
integrator.set_params(kT=self.kT)
integrator.randomize_velocities(seed=42)
integrator_mode.set_params(dt=self.dt)
try:
hoomd.run_upto(self.n_steps + 1, limit_multiple=self.gsd_write)
except hoomd.WalltimeLimitReached:
print("Walltime limit reached")
pass
finally:
gsd_restart.write_restart()
print("Restart file written")
def quench(
self,
n_steps,
kT=None,
pressure=None,
shrink_kT=None,
shrink_steps=None,
shrink_period=None,
walls=True,
):
""""""
if walls and pressure:
raise ValueError(
"Wall potentials can only be used with the NVT ensemble")
hoomd_args = f"--single-mpi --mode={self.mode}"
sim = hoomd.context.initialize(hoomd_args)
with sim:
objs, refs = create_hoomd_simulation(self.system_pmd,
self.ref_distance,
self.ref_mass,
self.ref_energy,
self.r_cut,
self.auto_scale,
nlist=self.nlist)
hoomd_system = objs[1]
init_snap = objs[0]
_all = hoomd.group.all()
hoomd.md.integrate.mode_standard(dt=self.dt)
hoomd.dump.gsd(
"sim_traj.gsd",
period=self.gsd_write,
group=_all,
phase=0,
dynamic=["momentum"],
overwrite=False,
)
hoomd.analyze.log(
"sim_traj.log",
period=self.log_write,
quantities=self.log_quantities,
header_prefix="#",
overwrite=True,
phase=0,
)
if len([i for i in (shrink_kT, shrink_steps) if i is None]) == 1:
raise ValueError(
"Both of shrink_kT and shrink_steps need to be given")
if shrink_kT and shrink_steps:
integrator = hoomd.md.integrate.nvt(group=_all,
kT=shrink_kT,
tau=self.tau_kt)
integrator.randomize_velocities(seed=self.seed)
x_variant = hoomd.variant.linear_interp([
(0, init_snap.box.Lx),
(shrink_steps, self.target_box[0] * 10)
])
y_variant = hoomd.variant.linear_interp([
(0, init_snap.box.Ly),
(shrink_steps, self.target_box[1] * 10)
])
z_variant = hoomd.variant.linear_interp([
(0, init_snap.box.Lz),
(shrink_steps, self.target_box[2] * 10)
])
box_updater = hoomd.update.box_resize(Lx=x_variant,
Ly=y_variant,
Lz=z_variant,
period=shrink_period)
# Update wall origins during shrinking
if walls:
wall_origin = (init_snap.box.Lx / 2, 0, 0)
normal_vector = (-1, 0, 0)
wall_origin2 = (-init_snap.box.Lx / 2, 0, 0)
normal_vector2 = (1, 0, 0)
walls = wall.group(
wall.plane(origin=wall_origin,
normal=normal_vector,
inside=True),
wall.plane(origin=wall_origin2,
normal=normal_vector2,
inside=True),
)
wall_force = wall.lj(walls, r_cut=2.5)
wall_force.force_coeff.set(init_snap.particles.types,
sigma=1.0,
epsilon=1.0,
r_extrap=0)
step = 0
start = time.time()
while step < shrink_steps:
hoomd.run_upto(step + shrink_period)
current_box = hoomd_system.box
walls.del_plane([0, 1])
walls.add_plane((current_box.Lx / 2, 0, 0),
normal_vector)
walls.add_plane((-current_box.Lx / 2, 0, 0),
normal_vector2)
step += shrink_period
print(f"Finished step {step} of {shrink_steps}")
print(
f"Shrinking is {round(step / shrink_steps, 5) * 100}% complete"
)
print(f"time elapsed: {time.time() - start}")
else:
hoomd.run_upto(shrink_steps)
box_updater.disable()
gsd_restart = hoomd.dump.gsd("restart.gsd",
period=self.gsd_write,
group=_all,
truncate=True,
phase=0,
dynamic=["momentum"])
# Run the primary simulation
if pressure:
try: # Not defined if no shrink step
integrator.disable()
except NameError:
pass
integrator = hoomd.md.integrate.npt(group=_all,
tau=self.tau_kt,
tauP=self.tau_p,
P=pressure,
kT=kT)
elif not pressure:
try:
integrator
except NameError:
integrator = hoomd.md.integrate.nvt(group=_all,
tau=self.tau_kt,
kT=kT)
integrator.randomize_velocities(seed=self.seed)
try:
hoomd.run(n_steps)
except hoomd.WalltimeLimitReached:
pass
finally:
gsd_restart.write_restart()
def anneal(
self,
kT_init=None,
kT_final=None,
pressure=None,
step_sequence=None,
schedule=None,
walls=True,
shrink_kT=None,
shrink_steps=None,
shrink_period=None,
):
if walls and pressure:
raise ValueError(
"Wall potentials can only be used with the NVT ensemble")
if not schedule:
temps = np.linspace(kT_init, kT_final, len(step_sequence))
temps = [np.round(t, 1) for t in temps]
schedule = dict(zip(temps, step_sequence))
# Get hoomd stuff set:
hoomd_args = f"--single-mpi --mode={self.mode}"
sim = hoomd.context.initialize(hoomd_args)
with sim:
objs, refs = create_hoomd_simulation(self.system_pmd,
self.ref_distance,
self.ref_mass,
self.ref_energy,
self.r_cut,
self.auto_scale,
nlist=self.nlist)
hoomd_system = objs[1]
init_snap = objs[0]
_all = hoomd.group.all()
hoomd.md.integrate.mode_standard(dt=self.dt)
hoomd.dump.gsd(
"sim_traj.gsd",
period=self.gsd_write,
group=_all,
phase=0,
dynamic=["momentum"],
overwrite=False,
)
hoomd.analyze.log(
"sim_traj.log",
period=self.log_write,
quantities=self.log_quantities,
header_prefix="#",
overwrite=True,
phase=0,
)
if shrink_kT and shrink_steps:
integrator = hoomd.md.integrate.nvt(group=_all,
tau=self.tau_kt,
kT=shrink_kT)
integrator.randomize_velocities(seed=self.seed)
x_variant = hoomd.variant.linear_interp([
(0, self.reduced_init_L),
(shrink_steps, self.target_box[0] * 10)
])
y_variant = hoomd.variant.linear_interp([
(0, self.reduced_init_L),
(shrink_steps, self.target_box[1] * 10)
])
z_variant = hoomd.variant.linear_interp([
(0, self.reduced_init_L),
(shrink_steps, self.target_box[2] * 10)
])
box_updater = hoomd.update.box_resize(Lx=x_variant,
Ly=y_variant,
Lz=z_variant,
period=shrink_period)
if walls:
wall_origin = (init_snap.box.Lx / 2, 0, 0)
normal_vector = (-1, 0, 0)
wall_origin2 = (-init_snap.box.Lx / 2, 0, 0)
normal_vector2 = (1, 0, 0)
walls = wall.group(
wall.plane(origin=wall_origin,
normal=normal_vector,
inside=True),
wall.plane(origin=wall_origin2,
normal=normal_vector2,
inside=True))
wall_force = wall.lj(walls, r_cut=2.5)
wall_force.force_coeff.set(init_snap.particles.types,
sigma=1.0,
epsilon=1.0,
r_extrap=0)
step = 0
while step < shrink_steps:
hoomd.run_upto(step + shrink_period)
current_box = hoomd_system.box
walls.del_plane([0, 1])
walls.add_plane((current_box.Lx / 2, 0, 0),
normal_vector)
walls.add_plane((-current_box.Lx / 2, 0, 0),
normal_vector2)
step += shrink_period
else:
hoomd.run_upto(shrink_steps)
box_updater.disable()
gsd_restart = hoomd.dump.gsd("restart.gsd",
period=self.gsd_write,
group=_all,
truncate=True,
phase=0,
dynamic=["momentum"])
if pressure:
try:
integrator.disable()
except NameError:
pass
integrator = hoomd.md.integrate.npt(group=_all,
tau=self.tau_kt,
tauP=self.tau_p,
P=pressure,
kT=1)
elif not pressure:
try:
integrator
except NameError:
integrator = hoomd.md.integrate.nvt(group=_all,
tau=self.tau_kt,
kT=1)
for kT in schedule:
n_steps = schedule[kT]
integrator.set_params(kT=kT)
integrator.randomize_velocities(seed=self.seed)
print(f"Running @ Temp = {kT} kT")
print(f"Running for {n_steps} steps")
try:
hoomd.run(n_steps)
except hoomd.WalltimeLimitReached:
pass
finally:
gsd_restart.write_restart()
def test_compound_to_hoomdsimulation(self, ethane):
from mbuild.formats.hoomd_simulation import create_hoomd_simulation
with pytest.raises(ValueError):
create_hoomd_simulation(ethane, 2.5)
def test_bad_input_to_hoomdsimulation(self):
from mbuild.formats.hoomd_simulation import create_hoomd_simulation
with pytest.raises(ValueError):
create_hoomd_simulation("fake_object", 2)
n_compounds=2000,
box=mb.Box(lengths=[8, 8, 8]))
hoomd.context.initialize("")
box_arr = [8, 8, 8]
wrap_xyz = meth_box.xyz - 1 * np.floor_divide(meth_box.xyz, box_arr) * box_arr
meth_box.xyz = wrap_xyz
struc = meth_box.to_parmed()
meth_box.save('meth_box.hoomdxml', forcefield_name='trappe-ua', overwrite=True)
ff = foyer.Forcefield(name='trappe-ua')
param = ff.apply(struc)
#for atom in param.atoms:
#atom.charge = 0
from mbuild.formats.hoomd_simulation import create_hoomd_simulation
create_hoomd_simulation(param, ref_distance=10, ref_energy=1 / 4.184)
nl = hoomd.md.nlist.cell()
nl.reset_exclusions(['1-2', '1-3', '1-4'])
all = hoomd.group.all()
#fire = md.integrate.mode_minimize_fire(dt=0.002)
#nve = md.integrate.nve(group=all, limit = 0.01)
#while not fire.has_converged():
# print([a.get_energy(all) for a in hoomd.context.current.forces])
# hoomd.run(1000)
#nve.disable()
md.integrate.mode_standard(dt=0.002)
nvt = md.integrate.nvt(group=all, kT=2.286476462, tau=1)
hoomd.analyze.log(filename="analyze2.log",
