def equilibrate(testsystem,
temperature,
timestep,
steps=40000,
npt=False,
minimize=True,
steps_per_hmc=25,
use_hmc=False,
platform_name=PLATFORM,
precision=PRECISION):
system, topology, positions = testsystem.system, testsystem.topology, testsystem.positions
if npt:
barostat_index = system.addForce(
mm.MonteCarloBarostat(1.0 * u.atmospheres, temperature, 1))
print(system.getDefaultPeriodicBoxVectors())
if use_hmc:
integrator = hmc_integrators.GHMCIntegrator(
temperature=temperature,
steps_per_hmc=steps_per_hmc,
timestep=timestep)
else:
integrator = mm.LangevinIntegrator(temperature, 2.0 / u.picoseconds,
timestep)
simulation = build(testsystem,
integrator,
temperature,
platform_name=platform_name,
precision=precision)
if minimize:
simulation.minimizeEnergy()
integrator.step(steps)
state = simulation.context.getState(getPositions=True, getParameters=True)
positions = state.getPositions()
boxes = state.getPeriodicBoxVectors()
if use_hmc:
print(integrator.acceptance_rate)
if npt:
system.removeForce(barostat_index)
system.setDefaultPeriodicBoxVectors(*boxes) # Doesn't hurt to reset boxes
testsystem.positions = positions
return positions, boxes, 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 kw_to_int(**kwargs):
steps_per_hmc = kwargs["steps_per_hmc"]
timestep = kwargs["timestep"]
group0_iterations = kwargs["group0_iterations"]
temperature = kwargs["temperature"]
print("*" * 80)
print("steps=%d, timestep=%f, extra_chances=%d, group0_iterations=%d" %
(steps_per_hmc, timestep, 0, group0_iterations))
timestep = timestep * u.femtoseconds
steps_per_hmc = int(steps_per_hmc)
group0_iterations = int(group0_iterations)
n_groups = max(
kwargs["groups"]
) + 1 # 1 group means group number = 0, assumes zero index and ordering
groups = num_to_groups(group0_iterations, n_groups)
print(n_groups)
print(groups)
if kwargs["group0_iterations"] == 0 and kwargs["extra_chances"] == 0:
integrator = hmc_integrators.GHMCIntegrator(
temperature, steps_per_hmc=steps_per_hmc, timestep=timestep)
elif kwargs["group0_iterations"] > 0 and kwargs["extra_chances"] > 0:
integrator = hmc_integrators.XCGHMCRESPAIntegrator(
temperature,
steps_per_hmc=steps_per_hmc,
timestep=timestep,
groups=groups)
elif kwargs["group0_iterations"] > 0 and kwargs["extra_chances"] == 0:
integrator = hmc_integrators.GHMCRESPAIntegrator(
temperature,
steps_per_hmc=steps_per_hmc,
timestep=timestep,
groups=groups)
elif kwargs["group0_iterations"] == 0 and kwargs["extra_chances"] > 0:
integrator = hmc_integrators.XCGHMCIntegrator(
temperature,
steps_per_hmc=steps_per_hmc,
timestep=timestep,
groups=groups)
return integrator
def get_grid(sysname, temperature, timestep, langevin_timestep, groups, steps_per_hmc=100, extra_chances=5):
integrators = OrderedDict()
for timestep in [1.0 * langevin_timestep, 4.0 * langevin_timestep]:
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))
fmt_string = lb_loader.format_name(prms)
integrators[fmt_string] = integrator
collision_rate = None
for timestep in [timestep, 20 * u.femtoseconds]:
integrator = hmc_integrators.GHMCIntegrator(temperature=temperature, steps_per_hmc=steps_per_hmc, timestep=timestep, collision_rate=collision_rate)
itype = type(integrator).__name__
prms = dict(sysname=sysname, itype=itype, timestep=timestep / u.femtoseconds, collision=lb_loader.fixunits(collision_rate))
fmt_string = lb_loader.format_name(prms)
integrators[fmt_string] = integrator
collision_rate = None
for timestep in [timestep]:
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))
fmt_string = lb_loader.format_name(prms)
integrators[fmt_string] = integrator
xcghmc_parms = dict(timestep=32.235339 * u.femtoseconds, steps_per_hmc=16, 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))
fmt_string = lb_loader.format_name(prms)
integrators[fmt_string] = integrator
return integrators
return data
timestep = 75 * u.femtoseconds # LJ Cluster
n_iter = 100000
data = {}
integrator = mm.LangevinIntegrator(temperature, 1.0 / u.picoseconds, timestep)
context = mm.Context(system, integrator)
context.setPositions(positions)
context.setVelocitiesToTemperature(temperature)
data["langevin"] = pd.DataFrame(sample(context, n_iter=n_iter, n_steps=20))
integrator = hmc_integrators.GHMCIntegrator(temperature,
steps_per_hmc=10,
timestep=timestep,
collision_rate=collision_rate)
context = mm.Context(system, integrator)
context.setPositions(positions)
context.setVelocitiesToTemperature(temperature)
data["ghmc"] = pd.DataFrame(sample(context, n_iter=n_iter, n_steps=1))
integrator = hmc_integrators.GHMCIntegrator(temperature,
steps_per_hmc=10,
timestep=timestep,
collision_rate=1.0 / u.picoseconds)
context = mm.Context(system, integrator)
context.setPositions(positions)
context.setVelocitiesToTemperature(temperature)
steps_per_hmc = 5
k_max = 4
integrator = hmc_integrators.XHMCIntegrator(temperature, steps_per_hmc,
timestep, collision_rate, k_max)
context = mm.Context(system, integrator)
context.setPositions(positions)
context.setVelocitiesToTemperature(temperature)
integrator.step(10)
data = integrator.vstep(50)
data.Enew[data.a == 1].mean(), data.Enew[
data.a == 1].std(), data.Enew[data.a == 1].std() / sum(data.a == 1)**0.5
state = context.getState(getEnergy=True)
energy = state.getPotentialEnergy() + state.getKineticEnergy()
energy, state.getPotentialEnergy(), state.getKineticEnergy()
#columns = ["a", "flip", "deltaE"] + ["T%d" % i for i in range(4)] + ["pe%d" % i for i in range(4)] + ["ke%d" % i for i in range(4)]
#data[columns]
integrator = hmc_integrators.GHMCIntegrator(temperature, steps_per_hmc,
timestep, collision_rate)
context = mm.Context(system, integrator)
context.setPositions(positions)
context.setVelocitiesToTemperature(temperature)
integrator.step(10)
data = integrator.vstep(50)
data["a"] = data.accept
data.Enew[data.a == 1].mean(), data.Enew[
data.a == 1].std(), data.Enew[data.a == 1].std() / sum(data.a == 1)**0.5
print(hydrogenMass)
positions = pdb.positions
system = forcefield.createSystem(pdb.topology, nonbondedMethod=app.PME, nonbondedCutoff=1.0*u.nanometers, hydrogenMass=hydrogenMass * u.amu, rigidWater=False)
integrator = mm.LangevinIntegrator(temperature, 1.0 / u.picoseconds, 0.25 * u.femtoseconds)
context = mm.Context(system, integrator)
context.setPositions(positions)
context.setVelocitiesToTemperature(temperature)
integrator.step(100)
positions = context.getState(getPositions=True).getPositions()
collision_rate = 1.0 / u.picoseconds
timestep = 0.5 * u.femtoseconds
steps_per_hmc = 12
integrator = hmc_integrators.GHMCIntegrator(temperature, steps_per_hmc, timestep)
context = mm.Context(system, integrator)
context.setPositions(positions)
context.setVelocitiesToTemperature(temperature)
integrator.step(1)
integrator.step(n_steps)
integrator = hmc_integrators.GHMCIntegrator(temperature, steps_per_hmc, timestep)
context = mm.Context(system, integrator)
context.setPositions(positions)
context.setVelocitiesToTemperature(temperature)
integrator.step(1)
integrator.step(n_steps)
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