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, 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)