def testAppend(self):
"""Test appending to the StateDataReporter output."""
with tempfile.TemporaryDirectory() as tempdir:
# Create a Simulation and produce 10 steps of output.
filename = os.path.join(tempdir, 'templog.txt')
simulation = app.Simulation(
self.pdb.topology, self.system,
mm.LangevinMiddleIntegrator(300 * unit.kelvin,
1.0 / unit.picosecond,
0.002 * unit.picoseconds))
simulation.context.setPositions(self.pdb.positions)
simulation.reporters.append(
app.StateDataReporter(filename, 1, step=True))
simulation.step(10)
# Create a new Simulation and append 5 more steps of output.
simulation = app.Simulation(
self.pdb.topology, self.system,
mm.LangevinMiddleIntegrator(300 * unit.kelvin,
1.0 / unit.picosecond,
0.002 * unit.picoseconds))
simulation.context.setPositions(self.pdb.positions)
simulation.reporters.append(
app.StateDataReporter(filename, 1, step=True, append=True))
simulation.step(5)
# See if the log contents are correct.
del simulation
lines = open(filename).read().split('\n')
self.assertTrue(lines[0].startswith('#'))
for i in range(10):
self.assertEqual(lines[i + 1], f'{i+1}')
for i in range(5):
self.assertEqual(lines[i + 11], f'{i+1}')
def add_simulations(sim_openmm, model, topology, positions, box_vectors):
"""
"""
sim_openmm.umbrella_simulation = openmm_app.Simulation(
topology.topology, sim_openmm.umbrella_system,
sim_openmm.umbrella_integrator, sim_openmm.platform,
sim_openmm.properties)
#for force in self.sim_openmm.rev_system.getForces():
# print("force name:", force.__class__.__name__,
# "force.usesPeriodicBoundaryConditions():",
# force.usesPeriodicBoundaryConditions())
#exit()
sim_openmm.rev_simulation = openmm_app.Simulation(
topology.topology, sim_openmm.rev_system, sim_openmm.rev_integrator,
sim_openmm.platform, sim_openmm.properties)
sim_openmm.fwd_simulation = openmm_app.Simulation(
topology.topology, sim_openmm.fwd_system, sim_openmm.fwd_integrator,
sim_openmm.platform, sim_openmm.properties)
sim_openmm.umbrella_simulation.context.setPositions(positions.positions)
if box_vectors is not None:
sim_openmm.umbrella_simulation.context.setPeriodicBoxVectors(
*box_vectors.to_quantity())
if model.openmm_settings.run_minimization:
sim_openmm.umbrella_simulation.minimizeEnergy()
sim_openmm.umbrella_simulation.context.setVelocitiesToTemperature(
model.openmm_settings.initial_temperature * unit.kelvin)
assert sim_openmm.timestep is not None
return
def add_simulation(sim_openmm, model, topology, positions, box_vectors):
"""
Assign the OpenMM simulation object for MMVT.
"""
sim_openmm.simulation = openmm_app.Simulation(topology.topology,
sim_openmm.system,
sim_openmm.integrator,
sim_openmm.platform,
sim_openmm.properties)
sim_openmm.simulation.context.setPositions(positions.positions)
if box_vectors is not None:
sim_openmm.simulation.context.setPeriodicBoxVectors(
*box_vectors.to_quantity())
if model.openmm_settings.run_minimization:
print("Warning: running minimizations. It is recommended that "\
"structures are minimized and verified by the user before "\
"running SEEKR, since minimizations might cause the system "\
"to drift out of the MMVT cell.")
sim_openmm.simulation.minimizeEnergy()
sim_openmm.simulation.context.setVelocitiesToTemperature(
model.openmm_settings.initial_temperature * unit.kelvin)
assert sim_openmm.timestep is not None
return
def test_local_coord_sites():
"""Make sure that the internal prep of vs positions matches that given by OpenMM."""
# make a system
mol = app.PDBFile(os.path.join("files", "vs_mol.pdb"))
modeller = app.Modeller(topology=mol.topology, positions=mol.positions)
forcefield = app.ForceField(
os.path.join("files", "forcefield", "vs_mol.xml"))
modeller.addExtraParticles(forcefield)
system = forcefield.createSystem(modeller.topology, constraints=None)
integrator = mm.VerletIntegrator(1.0 * unit.femtoseconds)
platform = mm.Platform.getPlatformByName("Reference")
simulation = app.Simulation(modeller.topology, system, integrator,
platform)
simulation.context.setPositions(modeller.positions)
# update the site positions
simulation.context.computeVirtualSites()
# one vs and it should be last
vs_pos = simulation.context.getState(getPositions=True).getPositions(
asNumpy=True)[-1]
# now compute and compare
vsinfo = PrepareVirtualSites(system=system)
new_pos = ResetVirtualSites_fast(positions=modeller.positions,
vsinfo=vsinfo)[-1]
assert np.allclose(vs_pos._value,
np.array([new_pos.x, new_pos.y, new_pos.z]))
def setUp(self):
with open('systems/alanine-dipeptide-implicit.pdb') as f:
pdb = app.PDBFile(f)
forcefield = app.ForceField('amber99sbildn.xml')
system = forcefield.createSystem(pdb.topology,
nonbondedMethod=app.CutoffNonPeriodic, nonbondedCutoff=1.0*unit.nanometers,
constraints=app.HBonds)
self.simulation = app.Simulation(pdb.topology, system, mm.VerletIntegrator(0.002*unit.picoseconds))
self.simulation.context.setPositions(pdb.positions)
def Calculate_ParmEd(gro_file, top_file, sysargs, defines):
#===============================#
#| ParmEd object creation |#
#===============================#
# Make sure the proper defines from the .mdp file are passed into the GromacsTopologyFile() :)
ParmEd_GmxTop = gromacs.GromacsTopologyFile(top_file)
ParmEd_GmxGro = gromacs.GromacsGroFile.parse(gro_file)
ParmEd_GmxTop.box = ParmEd_GmxGro.box
ParmEd_GmxTop.positions = ParmEd_GmxGro.positions
#===============================#
#| OpenMM simulation setup |#
#===============================#
# ParmEd creates System object
system = ParmEd_GmxTop.createSystem(**sysargs)
# Keep a record of which atoms are real (not virtual sites)
isAtom = []
for i in range(system.getNumParticles()):
isAtom.append(system.getParticleMass(i).value_in_unit(u.dalton) > 0.0)
# Setting force groups enables energy components analysis
for i, f in enumerate(system.getForces()):
f.setForceGroup(i)
if isinstance(f, mm.NonbondedForce):
f.setUseDispersionCorrection(True)
integ = mm.VerletIntegrator(1.0 * u.femtosecond)
plat = mm.Platform.getPlatformByName('Reference')
# Create Simulation object
simul = app.Simulation(ParmEd_GmxTop.topology, system, integ, plat)
simul.context.setPositions(ParmEd_GmxGro.positions)
simul.context.applyConstraints(1e-12)
# Obtain OpenMM potential energy
state = simul.context.getState(getPositions=True,
getEnergy=True,
getForces=True)
parmed_energy = state.getPotentialEnergy()
parmed_forces = state.getForces()
pos = np.array(state.getPositions().value_in_unit(u.angstrom)).reshape(
-1, 3)
# Obtain and save constrained positions
# M = Molecule(gro_file)
# M.xyzs[0] = pos
# M.write('constrained.gro')
# Print OpenMM-via-ParmEd energy components
Ecomps_OMM = energy_components(simul)
printcool_dictionary(Ecomps_OMM,
title="OpenMM energy components via ParmEd")
parmed_forces = np.array([
f for i, f in enumerate(
parmed_forces.value_in_unit(u.kilojoule_per_mole / u.nanometer))
if isAtom[i]
])
return parmed_energy, parmed_forces, Ecomps_OMM
def testAppend(self):
"""Test appending to an existing trajectory."""
fname = tempfile.mktemp(suffix='.dcd')
pdb = app.PDBFile('systems/alanine-dipeptide-implicit.pdb')
ff = app.ForceField('amber99sb.xml', 'tip3p.xml')
system = ff.createSystem(pdb.topology)
# Create a simulation and write some frames to a DCD file.
integrator = mm.VerletIntegrator(0.001 * unit.picoseconds)
simulation = app.Simulation(pdb.topology, system, integrator,
mm.Platform.getPlatformByName('Reference'))
dcd = app.DCDReporter(fname, 2)
simulation.reporters.append(dcd)
simulation.context.setPositions(pdb.positions)
simulation.context.setVelocitiesToTemperature(300 * unit.kelvin)
simulation.step(10)
self.assertEqual(5, dcd._dcd._modelCount)
del simulation
del dcd
len1 = os.stat(fname).st_size
# Create a new simulation and have it append some more frames.
integrator = mm.VerletIntegrator(0.001 * unit.picoseconds)
simulation = app.Simulation(pdb.topology, system, integrator,
mm.Platform.getPlatformByName('Reference'))
dcd = app.DCDReporter(fname, 2, append=True)
simulation.reporters.append(dcd)
simulation.context.setPositions(pdb.positions)
simulation.context.setVelocitiesToTemperature(300 * unit.kelvin)
simulation.step(10)
self.assertEqual(10, dcd._dcd._modelCount)
len2 = os.stat(fname).st_size
self.assertTrue(len2 - len1 > 3 * 4 * 5 * system.getNumParticles())
del simulation
del dcd
os.remove(fname)
def setUp(self):
prmtop = app.AmberPrmtopFile('systems/water-box-216.prmtop')
system = prmtop.createSystem(nonbondedMethod=app.PME,
nonbondedCutoff=0.9 * unit.nanometers,
constraints=app.HBonds,
rigidWater=True,
ewaldErrorTolerance=0.0005)
integrator = mm.LangevinIntegrator(300 * unit.kelvin,
1.0 / unit.picoseconds,
2.0 * unit.femtoseconds)
self.simulation = app.Simulation(
prmtop.topology, system, integrator,
mm.Platform.getPlatformByName('Reference'))
def _configure_amber_implicit(
pdb_file: PathLike,
top_file: Optional[PathLike],
dt_ps: float,
temperature_kelvin: float,
heat_bath_friction_coef: float,
platform: "openmm.Platform",
platform_properties: dict,
) -> Tuple["app.Simulation", Optional["app.PDBFile"]]:
# Configure system
if top_file is not None:
pdb = None
top = app.AmberPrmtopFile(str(top_file))
system = top.createSystem(
nonbondedMethod=app.CutoffNonPeriodic,
nonbondedCutoff=1.0 * u.nanometer,
constraints=app.HBonds,
implicitSolvent=app.OBC1,
)
else:
pdb = app.PDBFile(str(pdb_file))
top = pdb.topology
forcefield = app.ForceField("amber99sbildn.xml", "amber99_obc.xml")
system = forcefield.createSystem(
top,
nonbondedMethod=app.CutoffNonPeriodic,
nonbondedCutoff=1.0 * u.nanometer,
constraints=app.HBonds,
)
# Configure integrator
integrator = openmm.LangevinIntegrator(
temperature_kelvin * u.kelvin,
heat_bath_friction_coef / u.picosecond,
dt_ps * u.picosecond,
)
integrator.setConstraintTolerance(0.00001)
sim = app.Simulation(top, system, integrator, platform,
platform_properties)
# Returning the pdb file object for later use to reduce I/O.
# If a topology file is passed, the pdb variable is None.
return sim, pdb
def _configure_amber_explicit(
top_file: PathLike,
dt_ps: float,
temperature_kelvin: float,
heat_bath_friction_coef: float,
platform: "openmm.Platform",
platform_properties: dict,
explicit_barostat: str,
) -> "app.Simulation":
top = app.AmberPrmtopFile(str(top_file))
system = top.createSystem(
nonbondedMethod=app.PME,
nonbondedCutoff=1.0 * u.nanometer,
constraints=app.HBonds,
)
# Congfigure integrator
integrator = openmm.LangevinIntegrator(
temperature_kelvin * u.kelvin,
heat_bath_friction_coef / u.picosecond,
dt_ps * u.picosecond,
)
if explicit_barostat == "MonteCarloBarostat":
system.addForce(
openmm.MonteCarloBarostat(1 * u.bar,
temperature_kelvin * u.kelvin))
elif explicit_barostat == "MonteCarloAnisotropicBarostat":
system.addForce(
openmm.MonteCarloAnisotropicBarostat(
(1, 1, 1) * u.bar, temperature_kelvin * u.kelvin, False, False,
True))
else:
raise ValueError(
f"Invalid explicit_barostat option: {explicit_barostat}")
sim = app.Simulation(top.topology, system, integrator, platform,
platform_properties)
return sim
def add_simulation(sim_openmm,
model,
topology,
positions,
box_vectors,
load_state_file=None):
"""
Assign the OpenMM simulation object for MMVT.
"""
sim_openmm.simulation = openmm_app.Simulation(topology, sim_openmm.system,
sim_openmm.integrator,
sim_openmm.platform,
sim_openmm.properties)
if positions is not None:
sim_openmm.simulation.context.setPositions(positions)
if load_state_file is not None:
print("loading state file")
sim_openmm.simulation.loadState(load_state_file)
state = sim_openmm.simulation.context.getState(getPositions=True)
positions = state.getPositions(positions)
else:
sim_openmm.simulation.context.setVelocitiesToTemperature(
model.openmm_settings.initial_temperature * unit.kelvin)
if box_vectors is not None:
sim_openmm.simulation.context.setPeriodicBoxVectors(
*box_vectors.to_quantity())
if model.openmm_settings.run_minimization:
assert positions is not None, "If states are being loaded as starting"\
"positions, minimizations cannot be activated."
print("Warning: running minimizations. It is recommended that "\
"structures are minimized and verified by the user before "\
"running SEEKR, since minimizations might cause the system "\
"to drift out of the MMVT cell.")
sim_openmm.simulation.minimizeEnergy()
assert sim_openmm.timestep is not None
return positions
def _equil_NPT_OpenMM_protocol_0(topology,
positions,
temperature=300.0 * _unit.kelvin,
pressure=1.0 * _unit.atmosphere,
time=1.0 * _unit.nanosecond,
forcefield=None,
verbose=True,
progress_bar=True):
import numpy as np
import openmm.app as app
import openmm as mm
from openmmtools.integrators import LangevinIntegrator, GeodesicBAOABIntegrator
if progress_bar:
from tqdm import tqdm
else:
def tqdm(arg):
return arg
#item needs to be openmm.modeller
forcefield = app.ForceField("amber99sbildn.xml", "tip3p.xml")
topology = item.topology
positions = item.positions
system = forcefield_generator.createSystem(topology,
contraints=app.HBonds,
nonbondedMethod=app.PME,
nonbondedCutoff=1.0 *
_unit.nanometers,
rigidWater=True,
ewaldErrorTolerance=0.0005)
## Thermodynamic State
kB = _unit.BOLTZMANN_CONSTANT_kB * _unit.AVOGADRO_CONSTANT_NA
temperature = temperature
pressure = pressure
## Barostat
barostat_frequency = 25 # steps
barostat = mm.MonteCarloBarostat(pressure, temperature, barostat_frequency)
system.addForce(barostat)
## Integrator
friction = 1.0 / _unit.picosecond
step_size = 2.0 * _unit.femtoseconds
integrator = LangevinIntegrator(temperature, friction, step_size)
integrator.setConstraintTolerance(0.00001)
## Platform
platform = mm.Platform.getPlatformByName('CUDA')
properties = {'CudaPrecision': 'mixed'}
## Simulation
simulation = app.Simulation(topology, system, integrator, platform,
properties)
simulation.context.setPositions(positions)
simulation.context.setVelocitiesToTemperature(temperature)
time_equilibration = time
time_iteration = 0.2 * _unit.picoseconds
number_iterations = int(time_equilibration / time_iteration)
steps_iteration = int(time_iteration / step_size)
steps_equilibration = number_iterations * steps_iteration
## Reporters
net_mass, n_degrees_of_freedom = m3t.get(system,
net_mass=True,
n_degrees_of_freedom=True)
niters = number_iterations
data = dict()
data['time'] = _unit.Quantity(np.zeros([niters], np.float64),
_unit.picoseconds)
data['potential'] = _unit.Quantity(np.zeros([niters], np.float64),
_unit.kilocalories_per_mole)
data['kinetic'] = _unit.Quantity(np.zeros([niters], np.float64),
_unit.kilocalories_per_mole)
data['volume'] = _unit.Quantity(np.zeros([niters], np.float64),
_unit.angstroms**3)
data['density'] = _unit.Quantity(np.zeros([niters], np.float64),
_unit.gram / _unit.centimeters**3)
data['kinetic_temperature'] = unit.Quantity(np.zeros([niters], np.float64),
_unit.kelvin)
for iteration in tqdm(range(number_iterations)):
integrator.step(steps_iteration)
state = simulation.context.getState(getEnergy=True)
time = state.getTime()
potential_energy = state.getPotentialEnergy()
kinetic_energy = state.getKineticEnergy()
volume = state.getPeriodicBoxVolume()
density = (net_mass / volume).in_units_of(unit.gram /
unit.centimeter**3)
kinetic_temperature = (2.0 * kinetic_energy /
kB / n_degrees_of_freedom).in_units_of(
unit.kelvin) # (1/2) ndof * kB * T = KE
data['time'][iteration] = time
data['potential'] = potential_energy
data['kinetic'] = kinetic_energy
data['volume'] = volume
data['density'] = density
data['kinetic_temperature'] = kinetic_temperature
final_state = simulation.context.getState(getPositions=True,
getVelocities=True)
final_positions = final_state.getPositions()
final_velocities = final_state.getVelocities()
return final_positions, final_velocities, data
)
# Create the integrator to do Langevin dynamics
integrator = mm.LangevinIntegrator(
300 * u.kelvin, # Temperature of heat bath
1.0 / u.picoseconds, # Friction coefficient
2.0 * u.femtoseconds, # Time step
)
# Define the platform to use; CUDA, OpenCL, CPU, or Reference. Or do not specify
# the platform to use the default (fastest) platform
platform = mm.Platform.getPlatformByName('CUDA')
prop = dict(CudaPrecision='mixed') # Use mixed single/double precision
# Create the Simulation object
sim = app.Simulation(top.topology, system, integrator, platform, prop)
# Set the particle positions
sim.context.setPositions(top.positions)
# Minimize the energy
print('Minimizing energy')
sim.minimizeEnergy(maxIterations=500)
# Set up the reporters to report energies and coordinates every 100 steps
sim.reporters.append(
app.StateDataReporter(sys.stdout,
100,
step=True,
potentialEnergy=True,
kineticEnergy=True,
engine="OpenMM",
verbose=False)
_ = msm.convert(molsys, to_form='villin_hp35_solvated.msmpk')
# simulation
print('Trajectory files...')
modeller = msm.convert(molsys, to_form='openmm.Modeller')
forcefield = app.ForceField("amber14-all.xml", "amber14/tip3p.xml")
system = forcefield.createSystem(modeller.topology,
nonbondedMethod=app.PME,
nonbondedCutoff=1.2 * unit.nanometer,
constraints=app.HBonds)
integrator = mm.LangevinIntegrator(300 * unit.kelvin, 1.0 / unit.picosecond,
2.0 * unit.femtoseconds)
platform = mm.Platform.getPlatformByName('CUDA')
simulation = app.Simulation(modeller.topology, system, integrator, platform)
simulation.context.setPositions(modeller.positions)
simulation.minimizeEnergy()
simulation.context.setVelocitiesToTemperature(300 * unit.kelvin)
simulation.reporters.append(
app.StateDataReporter(stdout,
50000,
progress=True,
potentialEnergy=True,
temperature=True,
remainingTime=True,
totalSteps=1000000))
simulation.reporters.append(
app.DCDReporter('villin_hp35_solvated.dcd', 50000,
enforcePeriodicBox=True))
simulation.reporters.append(HDF5Reporter('villin_hp35_solvated.h5', 50000))
)
# Create the integrator to do Langevin dynamics
integrator = mm.LangevinIntegrator(
300 * u.kelvin, # Temperature of heat bath
1.0 / u.picoseconds, # Friction coefficient
2.0 * u.femtoseconds, # Time step
)
# Define the platform to use; CUDA, OpenCL, CPU, or Reference. Or do not specify
# the platform to use the default (fastest) platform
platform = mm.Platform.getPlatformByName('CUDA')
prop = dict(CudaPrecision='mixed') # Use mixed single/double precision
# Create the Simulation object
sim = app.Simulation(ala2_solv.topology, system, integrator, platform, prop)
# Set the particle positions
sim.context.setPositions(ala2_crds.positions)
# Minimize the energy
print('Minimizing energy')
sim.minimizeEnergy(maxIterations=500)
# Set up the reporters to report energies and coordinates every 100 steps
sim.reporters.append(
StateDataReporter(sys.stdout,
100,
step=True,
potentialEnergy=True,
kineticEnergy=True,
