import pickle
import os
import lb_loader
import pandas as pd
import simtk.openmm.app as app
import numpy as np
import simtk.openmm as mm
from simtk import unit as u
from openmmtools import hmc_integrators, testsystems
precision = "mixed"
sysname = "switchedaccuratewater"
system, positions, groups, temperature, timestep, langevin_timestep, testsystem = lb_loader.load(
sysname)
integrator = hmc_integrators.HMCIntegrator(temperature,
steps_per_hmc=25,
timestep=timestep)
context = lb_loader.build(system, integrator, positions, temperature)
mm.LocalEnergyMinimizer.minimize(context)
integrator.step(40000)
positions = context.getState(getPositions=True).getPositions()
print(integrator.acceptance_rate)
collision_rate = 1.0 / u.picoseconds
n_steps = 25
Neff_cutoff = 1E5
itype = "HMCIntegrator"
import pymbar
import lb_loader
import pandas as pd
import simtk.openmm.app as app
import numpy as np
import simtk.openmm as mm
from simtk import unit as u
from openmmtools import hmc_integrators, testsystems
sysname = "customsplitho"
system, positions, groups, temperature, timestep, langevin_timestep, testsystem, equil_steps, steps_per_hmc = lb_loader.load(
sysname)
positions, boxes = lb_loader.equilibrate(system,
temperature,
timestep,
positions,
steps=equil_steps,
minimize=True,
steps_per_hmc=steps_per_hmc)
E0 = (
3 / 2.
) * testsystem.n_particles * testsystems.kB * temperature / u.kilojoules_per_mole
integrator = hmc_integrators.XCHMCIntegrator(temperature,
steps_per_hmc=steps_per_hmc,
timestep=timestep)
context = lb_loader.build(system, integrator, positions, temperature)
context.getState(getEnergy=True).getPotentialEnergy()
integrator.step(3000)
context.getState(getEnergy=True).getPotentialEnergy()
def enumerate_experiments():
experiments = OrderedDict()
############################################################################
sysname = "switchedljbox"
system, positions, groups, temperature, timestep, langevin_timestep, testsystem, equil_steps, steps_per_hmc = lb_loader.load(sysname)
############################################################################
for timestep in [2.5 * u.femtoseconds, 5.0 * u.femtoseconds]:
collision_rate = 1.0 / u.picoseconds
integrator = mm.LangevinIntegrator(temperature, collision_rate, timestep)
prms = dict(sysname=sysname, timestep=timestep / u.femtoseconds, collision=lb_loader.fixunits(collision_rate))
expt = Experiment(integrator=integrator, sysname=sysname, prms=prms)
collision_rate = None
for timestep in [20.0 * u.femtoseconds]:
integrator = hmc_integrators.GHMCIntegrator(temperature=temperature, steps_per_hmc=steps_per_hmc, timestep=timestep, collision_rate=collision_rate)
prms = dict(sysname=sysname, timestep=timestep / u.femtoseconds, collision=lb_loader.fixunits(collision_rate))
expt = Experiment(integrator=integrator, sysname=sysname, prms=prms)
timestep = 35.0 * u.femtoseconds
extra_chances = 2
collision_rate = 1.0 / u.picoseconds
integrator = hmc_integrators.XCGHMCIntegrator(temperature=temperature, steps_per_hmc=steps_per_hmc, timestep=timestep, extra_chances=extra_chances, collision_rate=collision_rate)
itype = type(integrator).__name__
prms = dict(sysname=sysname, itype=itype, timestep=timestep / u.femtoseconds, collision=lb_loader.fixunits(collision_rate))
expt = Experiment(integrator=integrator, sysname=sysname, prms=prms)
return
collision_rate = None
for timestep in []: # [2.0 * u.femtoseconds]:
integrator = hmc_integrators.XCGHMCIntegrator(temperature=temperature, steps_per_hmc=steps_per_hmc, timestep=timestep, extra_chances=extra_chances, collision_rate=collision_rate)
itype = type(integrator).__name__
prms = dict(sysname=sysname, itype=itype, timestep=timestep / u.femtoseconds, collision=lb_loader.fixunits(collision_rate))
int_string = lb_loader.format_int_name(prms)
key = (sysname, int_string)
experiments[key] = integrator
############################################################################
sysname = "switchedaccurateflexiblewater"
system, positions, groups, temperature, timestep, langevin_timestep, testsystem, equil_steps, steps_per_hmc = lb_loader.load(sysname)
############################################################################
for timestep in [0.10 * u.femtoseconds, 0.15 * u.femtoseconds, 0.5 * u.femtoseconds]:
collision_rate = 1.0 / u.picoseconds
integrator = mm.LangevinIntegrator(temperature, collision_rate, timestep)
itype = type(integrator).__name__
prms = dict(sysname=sysname, itype=itype, timestep=timestep / u.femtoseconds, collision=lb_loader.fixunits(collision_rate))
int_string = lb_loader.format_int_name(prms)
key = (sysname, int_string)
experiments[key] = integrator
xcghmc_parms = dict(timestep=0.668 * u.femtoseconds, steps_per_hmc=10, extra_chances=1, collision_rate=None)
integrator = hmc_integrators.XCGHMCIntegrator(temperature=temperature, **xcghmc_parms)
itype = type(integrator).__name__
prms = dict(sysname=sysname, itype=itype, timestep=integrator.timestep / u.femtoseconds, collision=lb_loader.fixunits(None))
int_string = lb_loader.format_int_name(prms)
key = (sysname, int_string)
experiments[key] = integrator
# hyperopt determined optimal settings obtain ~113 effective ns / day
xcghmc_parms = dict(timestep=1.1868 * u.femtoseconds, steps_per_hmc=23, collision_rate=None, groups=((0, 1), (1, 4)))
integrator = hmc_integrators.GHMCRESPAIntegrator(temperature=temperature, **xcghmc_parms)
itype = type(integrator).__name__
prms = dict(sysname=sysname, itype=itype, timestep=integrator.timestep / u.femtoseconds, collision=lb_loader.fixunits(None))
int_string = lb_loader.format_int_name(prms)
key = (sysname, int_string)
experiments[key] = integrator
# Obtained by taking hyperopt optimal GHMCRespa parameters and adding 2 extra chances
xcghmc_parms = dict(timestep=1.1868 * u.femtoseconds, steps_per_hmc=23, collision_rate=None, extra_chances=2, groups=((0, 1), (1, 4)))
integrator = hmc_integrators.XCGHMCRESPAIntegrator(temperature=temperature, **xcghmc_parms)
itype = type(integrator).__name__
prms = dict(sysname=sysname, itype=itype, timestep=integrator.timestep / u.femtoseconds, collision=lb_loader.fixunits(None))
int_string = lb_loader.format_int_name(prms)
key = (sysname, int_string)
experiments[key] = integrator
# hyperopt determined optimal settings obtain ~79.8 effective ns/day
xcghmc_parms = dict(timestep=0.6791 * u.femtoseconds, steps_per_hmc=20, collision_rate=None)
integrator = hmc_integrators.GHMCIntegrator(temperature=temperature, **xcghmc_parms)
itype = type(integrator).__name__
prms = dict(sysname=sysname, itype=itype, timestep=integrator.timestep / u.femtoseconds, collision=lb_loader.fixunits(None))
int_string = lb_loader.format_int_name(prms)
key = (sysname, int_string)
experiments[key] = integrator
xcghmc_parms = dict(timestep=0.6791 * u.femtoseconds, steps_per_hmc=20, collision_rate=None)
xcghmc_parms.update(dict())
integrator = hmc_integrators.XCGHMCIntegrator(temperature=temperature, **xcghmc_parms)
itype = type(integrator).__name__
prms = dict(sysname=sysname, itype=itype, timestep=timestep / u.femtoseconds, collision=lb_loader.fixunits(collision_rate))
int_string = lb_loader.format_int_name(prms)
key = (sysname, int_string)
experiments[key] = integrator
############################################################################
sysname = "switchedaccuratebigflexiblewater"
system, positions, groups, temperature, timestep, langevin_timestep, testsystem, equil_steps, steps_per_hmc = lb_loader.load(sysname)
############################################################################
experiments = OrderedDict()
# hyperopt determined optimal settings obtain ~113 effective ns / day
xcghmc_parms = dict(timestep=0.256927 * u.femtoseconds, steps_per_hmc=24, collision_rate=None, groups=((0, 4), (1, 1)))
integrator = hmc_integrators.GHMCRESPAIntegrator(temperature=temperature, **xcghmc_parms)
itype = type(integrator).__name__
prms = dict(sysname=sysname, itype=itype, timestep=integrator.timestep / u.femtoseconds, collision=lb_loader.fixunits(None))
int_string = lb_loader.format_int_name(prms)
key = (sysname, int_string)
experiments[key] = integrator
def run(sysname, system_filename, state_filename):
system, positions, groups, temperature, timestep, langevin_timestep, testsystem, equil_steps, steps_per_hmc = lb_loader.load(
sysname)
positions, boxes, state = lb_loader.equilibrate(testsystem,
temperature,
langevin_timestep,
steps=equil_steps,
minimize=True)
pickle.dump(testsystem, open(system_filename, 'wb'))
serialized = mm.XmlSerializer.serialize(state)
lb_loader.write_file(state_filename, serialized)
def run(system_filename, state_filename, integrator_filename, sysname, Neff_cutoff, csv_filename, dcd_filename):
Neff_cutoff = float(Neff_cutoff)
system, positions, groups, temperature, timestep, langevin_timestep, testsystem, equil_steps, steps_per_hmc = lb_loader.load(sysname)
state = mm.XmlSerializer.deserialize(open(state_filename).read())
testsystem = pickle.load(open(system_filename, 'rb'))
integrator = pickle.load(open(integrator_filename, 'rb'))
itype = type(integrator).__name__
print(itype)
simulation = lb_loader.build(testsystem, integrator, temperature, state=state)
simulation.runForClockTime(1.0 * u.minutes)
output_frequency = 100 if "Langevin" in itype else 1
kineticEnergy = True if "MJHMC" in itype else False
simulation.reporters.append(app.StateDataReporter(csv_filename, output_frequency, step=True,
time=True, potentialEnergy=True, kineticEnergy=kineticEnergy,
temperature=True, density=True, elapsedTime=True))
simulation.reporters.append(app.DCDReporter(dcd_filename, output_frequency))
lb_loader.converge(simulation, csv_filename, Neff_cutoff)
import lb_loader
import pandas as pd
import simtk.openmm.app as app
import numpy as np
import simtk.openmm as mm
from simtk import unit as u
from openmmtools import hmc_integrators, testsystems
sysname = "ljbox"
system, positions, groups, temperature, timestep = lb_loader.load(sysname)
system.addForce(mm.AndersenThermostat(temperature, 1.0 / u.picoseconds))
integrator = mm.VerletIntegrator(timestep / 4.)
context = lb_loader.build(system, integrator, positions, temperature)
integrator.step(50000)
positions = context.getState(getPositions=True).getPositions()
collision_rate = 1.0 / u.picoseconds
n_steps = 25
Neff_cutoff = 2000.
grid = []
for itype in ["VerletIntegrator"]:
for timestep_factor in [1.0, 2.0, 4.0]:
d = dict(itype=itype, timestep=timestep / timestep_factor)
grid.append(d)
for settings in grid:
itype = settings.pop("itype")
import lb_loader
import simtk.openmm.app as app
import simtk.openmm as mm
from simtk import unit as u
from openmmtools import hmc_integrators, testsystems, integrators
from sys import stdout
platform_name = "CUDA"
platform = mm.Platform.getPlatformByName(platform_name)
properties = {'CudaPrecision': "mixed"}
precision = "mixed"
#sysname = "switchedaccurateflexiblewater"
sysname = "switchedaccuratewater"
system, positions, groups, temperature, timestep, langevin_timestep, testsystem, equil_steps, steps_per_hmc = lb_loader.load(sysname)
positions, boxes, state = lb_loader.equilibrate(testsystem, temperature, langevin_timestep, steps=equil_steps, minimize=True, use_hmc=False, precision=precision, platform_name=platform_name)
n_steps = 20000
temperature = 300. * u.kelvin
timestep = 1.75 * u.femtoseconds
for integrator in [integrators.PositionVerletIntegrator(timestep), integrators.VelocityVerletIntegrator(timestep)]:
intname = integrator.__class__.__name__
print("*" * 80)
print(sysname, intname)
csv_filename = "./verlet/%s_%s_%f.csv" % (sysname, intname, timestep / u.femtoseconds)
simulation = app.Simulation(testsystem.topology, testsystem.system, integrator, platform=platform, platformProperties=properties)
import lb_loader
import pandas as pd
import simtk.openmm.app as app
import numpy as np
import simtk.openmm as mm
from simtk import unit as u
from openmmtools import hmc_integrators, testsystems
pd.set_option('display.width', 1000)
collision_rate = 10000.0 / u.picoseconds
sysname = "water"
system, positions, groups, temperature, timestep = lb_loader.load(sysname)
integrator = mm.LangevinIntegrator(temperature, 1.0 / u.picoseconds, timestep / 4.)
context = lb_loader.build(system, integrator, positions, temperature)
integrator.step(10000)
positions = context.getState(getPositions=True).getPositions()
timestep = 1.0 * u.femtoseconds
extra_chances = 1
integrator = hmc_integrators.HMCIntegrator(temperature, steps_per_hmc=10, timestep=timestep)
#integrator = hmc_integrators.GHMCIntegrator(temperature, steps_per_hmc=10, timestep=timestep, collision_rate=1.0 / u.picoseconds)
#integrator = hmc_integrators.XCGHMCIntegrator(temperature, steps_per_hmc=10, timestep=timestep, collision_rate=1.0 / u.picoseconds, extra_chances=extra_chances, take_debug_steps=False)
context = lb_loader.build(system, integrator, positions, temperature)
integrator.step(400)
output = integrator.vstep(20)
integrator.effective_timestep
import lb_loader import pandas as pd import simtk.openmm.app as app import numpy as np import simtk.openmm as mm from simtk import unit as u from openmmtools import hmc_integrators, testsystems precision = "mixed" sysname = "switchedaccuratewater" system, positions, groups, temperature, timestep, langevin_timestep, testsystem = lb_loader.load(sysname) positions, boxes = lb_loader.equilibrate(system, temperature, timestep, positions, equil_steps, minimize=True) collision_rate = 1.0 / u.picoseconds n_steps = 25 Neff_cutoff = 1E5 itype = "LangevinIntegrator" langevin_timestep = 0.4 * u.femtoseconds integrator = mm.LangevinIntegrator(temperature, collision_rate, langevin_timestep) context = lb_loader.build(system, integrator, positions, temperature, precision=precision) filename = "./data/%s_%s_%s_%.3f_%d.csv" % (precision, sysname, itype, langevin_timestep / u.femtoseconds, collision_rate * u.picoseconds) print(filename) integrator.step(450000) data, start, g, Neff, mu, sigma, stderr = lb_loader.converge(context, n_steps=n_steps, Neff_cutoff=Neff_cutoff, filename=filename)
def run(sysname, system_filename, state_filename):
system, positions, groups, temperature, timestep, langevin_timestep, testsystem, equil_steps, steps_per_hmc = lb_loader.load(sysname)
positions, boxes, state = lb_loader.equilibrate(testsystem, temperature, langevin_timestep, steps=equil_steps, minimize=True)
pickle.dump(testsystem, open(system_filename, 'wb'))
serialized = mm.XmlSerializer.serialize(state)
lb_loader.write_file(state_filename, serialized)
def enumerate_experiments():
experiments = OrderedDict()
############################################################################
sysname = "switchedljbox"
system, positions, groups, temperature, timestep, langevin_timestep, testsystem, equil_steps, steps_per_hmc = lb_loader.load(
sysname)
############################################################################
for timestep in [2.5 * u.femtoseconds, 5.0 * u.femtoseconds]:
collision_rate = 1.0 / u.picoseconds
integrator = mm.LangevinIntegrator(temperature, collision_rate,
timestep)
prms = dict(sysname=sysname,
timestep=timestep / u.femtoseconds,
collision=lb_loader.fixunits(collision_rate))
expt = Experiment(integrator=integrator, sysname=sysname, prms=prms)
collision_rate = None
for timestep in [20.0 * u.femtoseconds]:
integrator = hmc_integrators.GHMCIntegrator(
temperature=temperature,
steps_per_hmc=steps_per_hmc,
timestep=timestep,
collision_rate=collision_rate)
prms = dict(sysname=sysname,
timestep=timestep / u.femtoseconds,
collision=lb_loader.fixunits(collision_rate))
expt = Experiment(integrator=integrator, sysname=sysname, prms=prms)
timestep = 35.0 * u.femtoseconds
extra_chances = 2
collision_rate = 1.0 / u.picoseconds
integrator = hmc_integrators.XCGHMCIntegrator(
temperature=temperature,
steps_per_hmc=steps_per_hmc,
timestep=timestep,
extra_chances=extra_chances,
collision_rate=collision_rate)
itype = type(integrator).__name__
prms = dict(sysname=sysname,
itype=itype,
timestep=timestep / u.femtoseconds,
collision=lb_loader.fixunits(collision_rate))
expt = Experiment(integrator=integrator, sysname=sysname, prms=prms)
return
collision_rate = None
for timestep in []: # [2.0 * u.femtoseconds]:
integrator = hmc_integrators.XCGHMCIntegrator(
temperature=temperature,
steps_per_hmc=steps_per_hmc,
timestep=timestep,
extra_chances=extra_chances,
collision_rate=collision_rate)
itype = type(integrator).__name__
prms = dict(sysname=sysname,
itype=itype,
timestep=timestep / u.femtoseconds,
collision=lb_loader.fixunits(collision_rate))
int_string = lb_loader.format_int_name(prms)
key = (sysname, int_string)
experiments[key] = integrator
############################################################################
sysname = "switchedaccurateflexiblewater"
system, positions, groups, temperature, timestep, langevin_timestep, testsystem, equil_steps, steps_per_hmc = lb_loader.load(
sysname)
############################################################################
for timestep in [
0.10 * u.femtoseconds, 0.15 * u.femtoseconds, 0.5 * u.femtoseconds
]:
collision_rate = 1.0 / u.picoseconds
integrator = mm.LangevinIntegrator(temperature, collision_rate,
timestep)
itype = type(integrator).__name__
prms = dict(sysname=sysname,
itype=itype,
timestep=timestep / u.femtoseconds,
collision=lb_loader.fixunits(collision_rate))
int_string = lb_loader.format_int_name(prms)
key = (sysname, int_string)
experiments[key] = integrator
xcghmc_parms = dict(timestep=0.668 * u.femtoseconds,
steps_per_hmc=10,
extra_chances=1,
collision_rate=None)
integrator = hmc_integrators.XCGHMCIntegrator(temperature=temperature,
**xcghmc_parms)
itype = type(integrator).__name__
prms = dict(sysname=sysname,
itype=itype,
timestep=integrator.timestep / u.femtoseconds,
collision=lb_loader.fixunits(None))
int_string = lb_loader.format_int_name(prms)
key = (sysname, int_string)
experiments[key] = integrator
# hyperopt determined optimal settings obtain ~113 effective ns / day
xcghmc_parms = dict(timestep=1.1868 * u.femtoseconds,
steps_per_hmc=23,
collision_rate=None,
groups=((0, 1), (1, 4)))
integrator = hmc_integrators.GHMCRESPAIntegrator(temperature=temperature,
**xcghmc_parms)
itype = type(integrator).__name__
prms = dict(sysname=sysname,
itype=itype,
timestep=integrator.timestep / u.femtoseconds,
collision=lb_loader.fixunits(None))
int_string = lb_loader.format_int_name(prms)
key = (sysname, int_string)
experiments[key] = integrator
# Obtained by taking hyperopt optimal GHMCRespa parameters and adding 2 extra chances
xcghmc_parms = dict(timestep=1.1868 * u.femtoseconds,
steps_per_hmc=23,
collision_rate=None,
extra_chances=2,
groups=((0, 1), (1, 4)))
integrator = hmc_integrators.XCGHMCRESPAIntegrator(temperature=temperature,
**xcghmc_parms)
itype = type(integrator).__name__
prms = dict(sysname=sysname,
itype=itype,
timestep=integrator.timestep / u.femtoseconds,
collision=lb_loader.fixunits(None))
int_string = lb_loader.format_int_name(prms)
key = (sysname, int_string)
experiments[key] = integrator
# hyperopt determined optimal settings obtain ~79.8 effective ns/day
xcghmc_parms = dict(timestep=0.6791 * u.femtoseconds,
steps_per_hmc=20,
collision_rate=None)
integrator = hmc_integrators.GHMCIntegrator(temperature=temperature,
**xcghmc_parms)
itype = type(integrator).__name__
prms = dict(sysname=sysname,
itype=itype,
timestep=integrator.timestep / u.femtoseconds,
collision=lb_loader.fixunits(None))
int_string = lb_loader.format_int_name(prms)
key = (sysname, int_string)
experiments[key] = integrator
xcghmc_parms = dict(timestep=0.6791 * u.femtoseconds,
steps_per_hmc=20,
collision_rate=None)
xcghmc_parms.update(dict())
integrator = hmc_integrators.XCGHMCIntegrator(temperature=temperature,
**xcghmc_parms)
itype = type(integrator).__name__
prms = dict(sysname=sysname,
itype=itype,
timestep=timestep / u.femtoseconds,
collision=lb_loader.fixunits(collision_rate))
int_string = lb_loader.format_int_name(prms)
key = (sysname, int_string)
experiments[key] = integrator
############################################################################
sysname = "switchedaccuratebigflexiblewater"
system, positions, groups, temperature, timestep, langevin_timestep, testsystem, equil_steps, steps_per_hmc = lb_loader.load(
sysname)
############################################################################
experiments = OrderedDict()
# hyperopt determined optimal settings obtain ~113 effective ns / day
xcghmc_parms = dict(timestep=0.256927 * u.femtoseconds,
steps_per_hmc=24,
collision_rate=None,
groups=((0, 4), (1, 1)))
integrator = hmc_integrators.GHMCRESPAIntegrator(temperature=temperature,
**xcghmc_parms)
itype = type(integrator).__name__
prms = dict(sysname=sysname,
itype=itype,
timestep=integrator.timestep / u.femtoseconds,
collision=lb_loader.fixunits(None))
int_string = lb_loader.format_int_name(prms)
key = (sysname, int_string)
experiments[key] = integrator
