Python equilibrateの例

コード例 #1

ファイル: serialize_system.py プロジェクト: kyleabeauchamp/HMCNotes

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)

コード例 #2

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)

コード例 #3

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()
integrator.acceptance_rate

コード例 #4

ファイル: test_position_verlet.py プロジェクト: kyleabeauchamp/HMCNotes

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)
    simulation.context.setPositions(testsystem.positions)

コード例 #5

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,

コード例 #6

ファイル: benchmark_integrators.py プロジェクト: kyleabeauchamp/HMCNotes

import time
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, integrators

precision = "mixed"

sysname = "dhfr"

system, positions, groups, temperature, timestep, langevin_timestep, testsystem, equil_steps, steps_per_hmc = lb_loader.load(sysname)
positions, boxes = lb_loader.equilibrate(testsystem, temperature, timestep, steps=equil_steps, minimize=True, use_hmc=False)

hmc_integrators.guess_force_groups(system, nonbonded=1, others=0, fft=2)


timestep = 2.0 * u.femtoseconds
#integrator = mm.LangevinIntegrator(temperature, 2.0 / u.picoseconds, timestep)
total_steps = 3000
extra_chances = 3
steps_per_hmc = 100
steps = total_steps

steps = total_steps / steps_per_hmc
integrator = hmc_integrators.XCGHMCIntegrator(temperature=temperature, steps_per_hmc=steps_per_hmc, timestep=timestep, extra_chances=extra_chances)
simulation = lb_loader.build(testsystem, integrator, temperature, precision=precision)

integrator.reset_time()

コード例 #7

ファイル: run_samples_grid_ljbox.py プロジェクト: kyleabeauchamp/HMCNotes

    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

walltime = 9.0 * u.hours
sysname = "switchedljbox"

system, positions, groups, temperature, timestep, langevin_timestep, testsystem, equil_steps, steps_per_hmc = lb_loader.load(sysname)
positions, boxes = lb_loader.equilibrate(testsystem, temperature, timestep, steps=equil_steps, minimize=True)

for fmt_string, integrator in get_grid(sysname, temperature, timestep, langevin_timestep, groups).items():
    itype = type(integrator).__name__
    print("%s    %s" % (fmt_string, itype))

    csv_filename = "./data/%s.csv" % fmt_string
    pdb_filename = "./data/%s.pdb" % fmt_string
    dcd_filename = "./data/%s.dcd" % fmt_string


    simulation = lb_loader.build(testsystem, integrator, temperature)
    simulation.step(5)

    output_frequency = 100 if "Langevin" in itype else 2
    kineticEnergy = True if "MJHMC" in itype else False

コード例 #8

                timestep=integrator.timestep / u.femtoseconds,
                collision=lb_loader.fixunits(None))
    fmt_string = lb_loader.format_name(prms)
    #integrators[fmt_string] = integrator

    return integrators


walltime = 48.0 * u.hours
sysname = "switchedaccurateflexiblewater"

system, positions, groups, temperature, timestep, langevin_timestep, testsystem, equil_steps, steps_per_hmc = lb_loader.load(
    sysname)
positions, boxes = lb_loader.equilibrate(testsystem,
                                         temperature,
                                         langevin_timestep,
                                         steps=equil_steps,
                                         minimize=True)

for fmt_string, integrator in get_grid(sysname, temperature, timestep,
                                       langevin_timestep, groups).items():
    itype = type(integrator).__name__
    print("%s    %s" % (fmt_string, itype))

    csv_filename = "./data/%s.csv" % fmt_string
    pdb_filename = "./data/%s.pdb" % fmt_string
    dcd_filename = "./data/%s.dcd" % fmt_string

    simulation = lb_loader.build(testsystem, integrator, temperature)
    simulation.step(5)

コード例 #9

ファイル: debug_xhmc.py プロジェクト: kyleabeauchamp/HMCNotes

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