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