def objective(**kwargs):
groups = kwargs["groups"]
hmc_integrators.guess_force_groups(system,
others=groups[0],
nonbonded=groups[1],
fft=groups[2])
integrator = lb_loader.kw_to_int(**kwargs)
simulation = lb_loader.build(testsystem,
integrator,
temperature,
precision=precision,
platform_name=platform_name,
state=state)
integrator.reset_time()
integrator.step(n_steps)
new_state = simulation.context.getState(getPositions=True,
getParameters=True)
print("eff_ns_per_day=%f, eff_dt=%f" %
(integrator.effective_ns_per_day,
integrator.effective_timestep / u.femtoseconds))
results = dict(
n_steps=n_steps,
intname=integrator.__class__.__name__,
effective_ns_per_day=integrator.effective_ns_per_day,
acceptance_rate=integrator.acceptance_rate,
effective_timestep=integrator.effective_timestep / u.femtoseconds,
time_per_step=integrator.time_per_step,
)
print(results)
return results, new_state
def inner_objective(args):
steps_per_hmc, timestep = args
print("*" * 80)
print("steps=%d, timestep=%f, extra_chances=%d" % (steps_per_hmc, timestep, 0))
current_timestep = timestep * u.femtoseconds
steps_per_hmc = int(steps_per_hmc)
integrator = hmc_integrators.GHMCIntegrator(temperature, steps_per_hmc=steps_per_hmc, timestep=current_timestep, collision_rate=collision_rate)
simulation = lb_loader.build(testsystem, integrator, temperature, precision=precision, platform_name=platform_name)
simulation.integrator.step(n_steps)
return integrator, simulation # Have to pass simulation to keep it from being garbage collected
def inner_objective(args):
steps_per_hmc, timestep, extra_chances = args
print("steps=%d, timestep=%f, extra_chances=%d" % (steps_per_hmc, timestep, extra_chances))
current_timestep = timestep * u.femtoseconds
extra_chances = int(extra_chances)
steps_per_hmc = int(steps_per_hmc)
integrator = hmc_integrators.XCGHMCRESPAIntegrator(temperature, steps_per_hmc=steps_per_hmc, timestep=current_timestep, extra_chances=extra_chances, groups=groups)
simulation = lb_loader.build(testsystem, integrator, temperature, precision=precision, platform_name=platform_name)
integrator.reset_time()
integrator.step(n_steps)
return integrator, simulation # Have to pass simulation to keep it from being garbage collected
def inner_objective(args):
steps_per_hmc, timestep = args
print("*" * 80)
print("steps=%d, timestep=%f, extra_chances=%d" %
(steps_per_hmc, timestep, 0))
current_timestep = timestep * u.femtoseconds
steps_per_hmc = int(steps_per_hmc)
integrator = hmc_integrators.GHMCIntegrator(temperature,
steps_per_hmc=steps_per_hmc,
timestep=current_timestep,
collision_rate=collision_rate)
simulation = lb_loader.build(testsystem,
integrator,
temperature,
precision=precision,
platform_name=platform_name)
simulation.integrator.step(n_steps)
return integrator, simulation # Have to pass simulation to keep it from being garbage collected
def objective(**kwargs):
groups = kwargs["groups"]
hmc_integrators.guess_force_groups(system, others=groups[0], nonbonded=groups[1], fft=groups[2])
integrator = lb_loader.kw_to_int(**kwargs)
simulation = lb_loader.build(testsystem, integrator, temperature, precision=precision, platform_name=platform_name, state=state)
integrator.reset_time()
integrator.step(n_steps)
new_state = simulation.context.getState(getPositions=True, getParameters=True)
print("eff_ns_per_day=%f, eff_dt=%f" % (integrator.effective_ns_per_day, integrator.effective_timestep / u.femtoseconds))
results = dict(
n_steps=n_steps,
intname=integrator.__class__.__name__,
effective_ns_per_day=integrator.effective_ns_per_day,
acceptance_rate=integrator.acceptance_rate,
effective_timestep=integrator.effective_timestep / u.femtoseconds,
time_per_step=integrator.time_per_step,
)
print(results)
return results, new_state
def inner_objective(args):
steps_per_hmc, timestep, group0_iterations = args
print("steps=%d, timestep=%f, extra_chances=%d, grp = %d" %
(steps_per_hmc, timestep, 0, group0_iterations))
current_timestep = timestep * u.femtoseconds
steps_per_hmc = int(steps_per_hmc)
group0_iterations = int(group0_iterations)
groups = num_to_groups(group0_iterations)
integrator = hmc_integrators.GHMCRESPAIntegrator(
temperature,
steps_per_hmc=steps_per_hmc,
timestep=current_timestep,
groups=groups)
simulation = lb_loader.build(testsystem,
integrator,
temperature,
precision=precision,
platform_name=platform_name)
integrator.reset_time()
integrator.step(n_steps)
return integrator, simulation # Have to pass simulation to keep it from being garbage collected
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)
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()
integrator.acceptance_rate
positions = context.getState(getPositions=True).getPositions()
output = integrator.vstep(25)
data = []
for i in range(100000):
integrator.step(1)
energy = context.getState(
getEnergy=True).getPotentialEnergy() / u.kilojoules_per_mole
data.append(dict(accept=integrator.accept, energy=energy))
data = pd.DataFrame(data)
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"
integrator = hmc_integrators.HMCIntegrator(temperature,
steps_per_hmc=25,
timestep=timestep)
context = lb_loader.build(system,
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
properties = {'CudaPrecision': precision}
simulation = app.Simulation(topology, system, integrator, platform=platform, platformProperties=properties)
simulation.context.setPositions(positions)
simulation.context.setVelocitiesToTemperature(temperature)
hmc_integrators.guess_force_groups(system, nonbonded=1, others=0, fft=2)
del simulation, integrator
timestep = 2.0 * u.femtoseconds
#integrator = mm.LangevinIntegrator(temperature, 2.0 / u.picoseconds, timestep)
#integrator = mm.VerletIntegrator(timestep)
total_steps = 3000
extra_chances = 3
steps_per_hmc = 100
steps = total_steps
steps = total_steps / steps_per_hmc
#integrator = hmc_integrators.GHMCIntegrator(temperature, steps_per_hmc=steps_per_hmc, timestep=timestep)
integrator = hmc_integrators.XCGHMCIntegrator(temperature, steps_per_hmc=steps_per_hmc, timestep=timestep, extra_chances=extra_chances)
#integrator = integrators.VelocityVerletIntegrator(2.0 * u.femtoseconds)
simulation = lb_loader.build(testsystem, integrator, temperature, precision=precision)
integrator.reset_time()
import time
t0 = time.time()
integrator.step(steps)
dt = time.time() - t0
ns_per_day = (timestep / u.nanoseconds) * total_steps / dt * 60 * 60 * 24
dt, ns_per_day
integrator.ns_per_day
mm.MTSIntegrator(timestep, groups=((0, 1), (1, 1))), # 1
mm.MTSIntegrator(timestep, groups=((0, 2), (1, 1))), # 2
mm.MTSIntegrator(timestep, groups=((0, 3), (1, 1))), # 3
mm.MTSIntegrator(timestep, groups=((0, 4), (1, 1))), # 4
mm.MTSIntegrator(timestep, groups=((0, 5), (1, 1))), # 5
mm.MTSIntegrator(timestep, groups=((1, 1), (0, 1))), # 6
mm.MTSIntegrator(timestep, groups=((1, 3), (0, 1))), # 7
mm.MTSIntegrator(timestep, groups=((1, 2), (0, 1))), # 8
mm.MTSIntegrator(timestep, groups=((1, 4), (0, 1))), # 9
mm.MTSIntegrator(timestep, groups=((1, 5), (0, 1))), # 10
]
for (i, integrator) in enumerate(integrators):
print("*" * 80)
simulation = lb_loader.build(testsystem,
integrator,
temperature,
precision=precision,
platform_name=platform_name)
integrator.step(n_steps * 2) # Pre-equilibrate with chosen integrator
for k in range(n_iter):
print(i, k)
state1a = simulation.context.getState(getPositions=True,
getParameters=True,
getEnergy=True,
getVelocities=True)
old = f(state1a)
print("PE, KE, TOTAL")
print(old)
integrator.step(n_steps)
state1b = simulation.context.getState(getPositions=True,
getParameters=True,
hmc_integrators.guess_force_groups(system, nonbonded=1, others=0, fft=2)
del simulation, integrator
timestep = 2.0 * u.femtoseconds
#integrator = mm.LangevinIntegrator(temperature, 2.0 / u.picoseconds, timestep)
#integrator = mm.VerletIntegrator(timestep)
total_steps = 3000
extra_chances = 3
steps_per_hmc = 100
steps = total_steps
steps = total_steps / steps_per_hmc
#integrator = hmc_integrators.GHMCIntegrator(temperature, steps_per_hmc=steps_per_hmc, timestep=timestep)
integrator = hmc_integrators.XCGHMCIntegrator(temperature,
steps_per_hmc=steps_per_hmc,
timestep=timestep,
extra_chances=extra_chances)
#integrator = integrators.VelocityVerletIntegrator(2.0 * u.femtoseconds)
simulation = lb_loader.build(testsystem,
integrator,
temperature,
precision=precision)
integrator.reset_time()
import time
t0 = time.time()
integrator.step(steps)
dt = time.time() - t0
ns_per_day = (timestep / u.nanoseconds) * total_steps / dt * 60 * 60 * 24
dt, ns_per_day
integrator.ns_per_day
collision_rate = int_args["collision_rate"] groups = int_args["groups"] hmc_integrators.guess_force_groups(system, others=groups[0], nonbonded=groups[1], fft=groups[2]) steps = 1000 integrator = lb_loader.kw_to_int(**int_args) #integrator = integrators.HMCIntegrator(temperature=temperature, nsteps=steps_per_hmc, timestep=timestep) #integrator = hmc_integrators.GHMCIntegrator(temperature=temperature, steps_per_hmc=steps_per_hmc, timestep=timestep, collision_rate=collision_rate) #temperature = int_args["temperature"] #steps_per_hmc = int_args["steps_per_hmc"] #timestep = int_args["timestep"] groups = [(0, 1)] extra_chances = 1 #collision_rate = None integrator = hmc_integrators.GHMCIntegrator(temperature=temperature, steps_per_hmc=steps_per_hmc, timestep=timestep, collision_rate=collision_rate) #integrator = hmc_integrators.GHMCRESPAIntegrator(temperature, steps_per_hmc=steps_per_hmc, timestep=timestep, groups=groups) #integrator = hmc_integrators.XCGHMCRESPAIntegrator(temperature=temperature, steps_per_hmc=steps_per_hmc, timestep=timestep, extra_chances=extra_chances, groups=groups, collision_rate=collision_rate) #integrator = hmc_integrators.XCGHMCIntegrator(temperature=temperature, steps_per_hmc=steps_per_hmc, timestep=timestep, extra_chances=extra_chances, collision_rate=collision_rate) simulation = lb_loader.build(testsystem, integrator, temperature, precision=precision, platform_name=platform_name, state=state) integrator.step(steps) print(integrator) print(integrator.effective_timestep, integrator.effective_ns_per_day) print(integrator.acceptance_rate)
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)
