def test_nose_hoover_integrator():
"""
Test Nose-Hoover thermostat by ensuring that a short run
conserves the system and bath energy to a reasonable tolerance.
The temperature could, in principle, be tested also but that would
require longer runs to guarantee stabilization.
"""
temperature = 298*unit.kelvin
testsystem = testsystems.WaterBox()
integrator = NoseHooverChainVelocityVerletIntegrator(temperature)
# Create Context and initialize positions.
context = openmm.Context(testsystem.system, integrator)
context.setPositions(testsystem.positions)
context.setVelocitiesToTemperature(temperature)
integrator.step(150) # Short equilibration
energies = []
for n in range(100):
integrator.step(1)
state = context.getState(getEnergy=True)
KE = state.getKineticEnergy().value_in_unit(unit.kilojoules_per_mole)
PE = state.getPotentialEnergy().value_in_unit(unit.kilojoules_per_mole)
bathKE = integrator.getGlobalVariableByName('bathKE')
bathPE = integrator.getGlobalVariableByName('bathPE')
conserved = KE + PE + bathKE + bathPE
energies.append(conserved)
# Compute maximum deviation from the mean for conserved energies
meanenergies = np.mean(energies)
maxdeviation = np.amax(np.abs(energies - meanenergies)/meanenergies)
assert maxdeviation < 1e-3
def tip3p():
# Create a TIP3P water box
from openmmtools import testsystems
testsystem = testsystems.WaterBox(box_edge=25.0 * unit.angstroms,
cutoff=9 * unit.angstroms,
model='tip3p',
switch_width=1.5 * unit.angstroms,
constrained=True,
dispersion_correction=True,
nonbondedMethod=app.PME,
ewaldErrorTolerance=1.0e-6)
testsystem_name = testsystem.__class__.__name__
fix_system(testsystem.system)
return [testsystem.system, testsystem.positions, testsystem_name]
def test_nose_hoover_integrator():
"""
Test Nose-Hoover thermostat by ensuring that a short run
conserves the system and bath energy to a reasonable tolerance.
Also test that the target temperature is rougly matched (+- 10 K).
"""
temperature = 298 * unit.kelvin
testsystem = testsystems.WaterBox()
num_dof = 3 * testsystem.system.getNumParticles(
) - testsystem.system.getNumConstraints()
integrator = NoseHooverChainVelocityVerletIntegrator(
testsystem.system, temperature)
# Create Context and initialize positions.
context = openmm.Context(testsystem.system, integrator)
context.setPositions(testsystem.positions)
context.setVelocitiesToTemperature(temperature)
integrator.step(200) # Short equilibration
energies = []
temperatures = []
for n in range(100):
integrator.step(1)
state = context.getState(getEnergy=True)
# temperature
kinE = state.getKineticEnergy()
temp = (2.0 * kinE /
(num_dof * unit.MOLAR_GAS_CONSTANT_R)).value_in_unit(
unit.kelvin)
temperatures.append(temp)
# total energy
KE = kinE.value_in_unit(unit.kilojoules_per_mole)
PE = state.getPotentialEnergy().value_in_unit(unit.kilojoules_per_mole)
bathKE = integrator.getGlobalVariableByName('bathKE')
bathPE = integrator.getGlobalVariableByName('bathPE')
conserved = KE + PE + bathKE + bathPE
energies.append(conserved)
# Compute maximum deviation from the mean for conserved energies
meanenergies = np.mean(energies)
maxdeviation = np.amax(np.abs(energies - meanenergies) / meanenergies)
assert maxdeviation < 1e-3
# Coarse check for target temperature
mean_temperature = np.mean(temperatures)
assert abs(mean_temperature -
temperature.value_in_unit(unit.kelvin)) < 10.0, mean_temperature
def setup_class(cls):
"""Create the thermodynamic states used in the test suite."""
water_test = testsystems.WaterBox(box_edge=2.0*unit.nanometer)
cls.water_300k = states.ThermodynamicState(water_test.system, 300*unit.kelvin)
cls.water_310k = states.ThermodynamicState(water_test.system, 310*unit.kelvin)
cls.water_310k_1atm = states.ThermodynamicState(water_test.system, 310*unit.kelvin,
1*unit.atmosphere)
cls.verlet_2fs = openmm.VerletIntegrator(2.0*unit.femtosecond)
cls.verlet_3fs = openmm.VerletIntegrator(3.0*unit.femtosecond)
cls.langevin_2fs_310k = openmm.LangevinIntegrator(310*unit.kelvin, 5.0/unit.picosecond,
2.0*unit.femtosecond)
cls.compatible_states = [cls.water_300k, cls.water_310k]
cls.compatible_integrators = [cls.verlet_2fs, cls.verlet_3fs]
cls.incompatible_states = [cls.water_310k, cls.water_310k_1atm]
cls.incompatible_integrators = [cls.verlet_2fs, cls.langevin_2fs_310k]
import numpy as np
import pandas as pd
import simtk.openmm as mm
from simtk import unit as u
from openmmtools import hmc_integrators, testsystems
steps_per_hmc = 12
collision_rate = 1.0 / u.picoseconds
n_steps = 5000
temperature = 300. * u.kelvin
#testsystem = testsystems.FlexibleWaterBox(box_edge=3.18 * u.nanometers) # Around 1060 molecules of water
testsystem = testsystems.WaterBox(box_edge=3.18 * u.nanometers) # Around 1060 molecules of water
system = testsystem.system
integrator = mm.LangevinIntegrator(temperature, 1.0 / u.picoseconds, 0.25 * u.femtoseconds)
context = mm.Context(testsystem.system, integrator)
context.setPositions(testsystem.positions)
context.setVelocitiesToTemperature(temperature)
integrator.step(5000)
positions = context.getState(getPositions=True).getPositions()
def test_hmc(timestep, steps_per_hmc, alpha):
timestep = timestep * u.femtoseconds
integrator = hmc_integrators.RampedHMCIntegrator(temperature, steps_per_hmc, timestep, max_boost=alpha)
context = mm.Context(system, integrator)
context.setPositions(positions)
context.setVelocitiesToTemperature(temperature)
integrator.step(n_steps)
return integrator.acceptance_rate
def load(sysname):
cutoff = 0.9 * u.nanometers
temperature = 300. * u.kelvin
langevin_timestep = 0.5 * u.femtoseconds
timestep = 2 * u.femtoseconds
equil_steps = 40000
groups = [(0, 1)]
steps_per_hmc = 25
if sysname == "chargedljbox":
testsystem, system, positions, timestep, langevin_timestep = load_lj(
charge=0.15 * u.elementary_charge)
if sysname == "chargedswitchedljbox":
testsystem, system, positions, timestep, langevin_timestep = load_lj(
charge=0.15 * u.elementary_charge,
switch_width=0.34 * u.nanometers)
if sysname == "chargedlongljbox":
testsystem, system, positions, timestep, langevin_timestep = load_lj(
cutoff=1.333 * u.nanometers, charge=0.15 * u.elementary_charge)
if sysname == "chargedswitchedlongljbox":
testsystem, system, positions, timestep, langevin_timestep = load_lj(
cutoff=1.333 * u.nanometers,
charge=0.15 * u.elementary_charge,
switch_width=0.34 * u.nanometers)
if sysname == "chargedswitchedaccuratelongljbox":
testsystem, system, positions, timestep, langevin_timestep = load_lj(
cutoff=1.333 * u.nanometers,
charge=0.15 * u.elementary_charge,
switch_width=0.34 * u.nanometers,
ewaldErrorTolerance=5E-5)
if sysname == "chargedswitchedaccurateljbox":
testsystem, system, positions, timestep, langevin_timestep = load_lj(
charge=0.15 * u.elementary_charge,
switch_width=0.34 * u.nanometers,
ewaldErrorTolerance=5E-5)
if sysname == "ljbox":
testsystem, system, positions, timestep, langevin_timestep = load_lj()
if sysname == "longljbox":
testsystem, system, positions, timestep, langevin_timestep = load_lj(
cutoff=1.333 * u.nanometers)
if sysname == "shortljbox":
testsystem, system, positions, timestep, langevin_timestep = load_lj(
cutoff=0.90 * u.nanometers)
if sysname == "shiftedljbox":
testsystem, system, positions, timestep, langevin_timestep = load_lj(
shift=True)
if sysname == "switchedljbox":
testsystem, system, positions, timestep, langevin_timestep = load_lj(
switch_width=0.34 * u.nanometers)
if sysname == "switchedshortljbox":
testsystem, system, positions, timestep, langevin_timestep = load_lj(
cutoff=0.90 * u.nanometers, switch_width=0.34 * u.nanometers)
if sysname == "cluster":
testsystem = testsystems.LennardJonesCluster(nx=8, ny=8, nz=8)
system, positions = testsystem.system, testsystem.positions
hmc_integrators.guess_force_groups(system, nonbonded=0)
groups = [(0, 1)]
temperature = 25. * u.kelvin
timestep = 40 * u.femtoseconds
if sysname == "shortbigcluster":
testsystem = testsystems.LennardJonesCluster(nx=20,
ny=20,
nz=20,
cutoff=0.75 *
u.nanometers)
system, positions = testsystem.system, testsystem.positions
hmc_integrators.guess_force_groups(system, nonbonded=0)
groups = [(0, 1)]
temperature = 25. * u.kelvin
timestep = 10 * u.femtoseconds
if sysname == "switchedshortbigcluster":
testsystem = testsystems.LennardJonesCluster(
nx=20,
ny=20,
nz=20,
cutoff=0.75 * u.nanometers,
switch_width=0.1 * u.nanometers)
system, positions = testsystem.system, testsystem.positions
hmc_integrators.guess_force_groups(system, nonbonded=0)
groups = [(0, 1)]
temperature = 25. * u.kelvin
timestep = 10 * u.femtoseconds
if sysname == "bigcluster":
testsystem = testsystems.LennardJonesCluster(nx=20,
ny=20,
nz=20,
cutoff=1.25 *
u.nanometers)
system, positions = testsystem.system, testsystem.positions
hmc_integrators.guess_force_groups(system, nonbonded=0)
groups = [(0, 1)]
temperature = 25. * u.kelvin
timestep = 10 * u.femtoseconds
if sysname == "shortcluster":
testsystem = testsystems.LennardJonesCluster(nx=8,
ny=8,
nz=8,
cutoff=0.75 *
u.nanometers)
system, positions = testsystem.system, testsystem.positions
hmc_integrators.guess_force_groups(system, nonbonded=0)
groups = [(0, 1)]
temperature = 25. * u.kelvin
timestep = 40 * u.femtoseconds
if sysname == "shortwater":
testsystem = testsystems.WaterBox(
box_edge=3.18 * u.nanometers,
cutoff=0.9 * u.nanometers,
switch_width=None) # Around 1060 molecules of water
system, positions = testsystem.system, testsystem.positions
if sysname == "shortswitchedwater":
testsystem = testsystems.WaterBox(
box_edge=3.18 * u.nanometers,
cutoff=0.9 * u.nanometers,
switch_width=3.0 * u.angstroms) # Around 1060 molecules of water
system, positions = testsystem.system, testsystem.positions
if sysname == "water":
testsystem = testsystems.WaterBox(
box_edge=3.18 * u.nanometers,
cutoff=1.1 * u.nanometers,
switch_width=None) # Around 1060 molecules of water
system, positions = testsystem.system, testsystem.positions
if sysname == "switchedwater":
testsystem = testsystems.WaterBox(
box_edge=3.18 * u.nanometers,
cutoff=1.1 * u.nanometers,
switch_width=3.0 * u.angstroms) # Around 1060 molecules of water
system, positions = testsystem.system, testsystem.positions
if sysname == "switchedaccuratewater":
testsystem = testsystems.WaterBox(
box_edge=3.18 * u.nanometers,
cutoff=1.1 * u.nanometers,
switch_width=3.0 * u.angstroms,
ewaldErrorTolerance=5E-5) # Around 1060 molecules of water
system, positions = testsystem.system, testsystem.positions
hmc_integrators.guess_force_groups(
system, nonbonded=0, fft=1, others=0) # We may want to try reduce
if sysname == "switchedaccurateflexiblewater":
testsystem = testsystems.WaterBox(
box_edge=3.18 * u.nanometers,
cutoff=1.1 * u.nanometers,
switch_width=3.0 * u.angstroms,
ewaldErrorTolerance=5E-5,
constrained=False) # Around 1060 molecules of water
system, positions = testsystem.system, testsystem.positions
# Using these groups for hyperopt-optimal RESPA integrators
#hmc_integrators.guess_force_groups(system, nonbonded=0, others=1, fft=0)
hmc_integrators.guess_force_groups(system,
nonbonded=1,
others=1,
fft=0)
equil_steps = 100000
langevin_timestep = 0.25 * u.femtoseconds
if sysname == "switchedaccuratebigflexiblewater":
testsystem = testsystems.WaterBox(
box_edge=10.0 * u.nanometers,
cutoff=1.1 * u.nanometers,
switch_width=3.0 * u.angstroms,
ewaldErrorTolerance=5E-5,
constrained=False) # Around 1060 molecules of water
system, positions = testsystem.system, testsystem.positions
# Using these groups for hyperopt-optimal RESPA integrators
hmc_integrators.guess_force_groups(system,
nonbonded=1,
others=0,
fft=1)
equil_steps = 100000
langevin_timestep = 0.1 * u.femtoseconds
if sysname == "switchedaccuratestiffflexiblewater":
testsystem = testsystems.WaterBox(
box_edge=3.18 * u.nanometers,
cutoff=1.1 * u.nanometers,
switch_width=3.0 * u.angstroms,
ewaldErrorTolerance=5E-5,
constrained=False) # Around 1060 molecules of water
system, positions = testsystem.system, testsystem.positions
# Using these groups for hyperopt-optimal RESPA integrators
#hmc_integrators.guess_force_groups(system, nonbonded=0, others=1, fft=0)
hmc_integrators.guess_force_groups(system,
nonbonded=1,
others=1,
fft=0)
equil_steps = 100000
langevin_timestep = 0.25 * u.femtoseconds
FACTOR = 10.0
# Make bonded terms stiffer to highlight RESPA advantage
for force in system.getForces():
if type(force) == mm.HarmonicBondForce:
for i in range(force.getNumBonds()):
(a0, a1, length, strength) = force.getBondParameters(i)
force.setBondParameters(i, a0, a1, length,
strength * FACTOR)
elif type(force) == mm.HarmonicAngleForce:
for i in range(force.getNumAngles()):
(a0, a1, a2, length,
strength) = force.getAngleParameters(i)
force.setAngleParameters(i, a0, a1, a2, length,
strength * FACTOR)
if sysname == "switchedaccuratenptwater":
testsystem = testsystems.WaterBox(
box_edge=3.18 * u.nanometers,
cutoff=1.1 * u.nanometers,
switch_width=3.0 * u.angstroms,
ewaldErrorTolerance=5E-5) # Around 1060 molecules of water
system, positions = testsystem.system, testsystem.positions
system.addForce(
mm.MonteCarloBarostat(1.0 * u.atmospheres, temperature, 1))
if sysname == "longswitchedwater":
testsystem = testsystems.WaterBox(
box_edge=3.18 * u.nanometers,
cutoff=1.5 * u.nanometers,
switch_width=3.0 * u.angstroms) # Around 1060 molecules of water
system, positions = testsystem.system, testsystem.positions
if sysname == "rfwater":
testsystem = testsystems.WaterBox(
box_edge=3.18 * u.nanometers,
cutoff=1.1 * u.nanometers,
nonbondedMethod=app.CutoffPeriodic,
switch_width=None) # Around 1060 molecules of water
system, positions = testsystem.system, testsystem.positions
if sysname == "switchedrfwater":
testsystem = testsystems.WaterBox(
box_edge=3.18 * u.nanometers,
cutoff=1.1 * u.nanometers,
nonbondedMethod=app.CutoffPeriodic,
switch_width=3.0 * u.angstroms) # Around 1060 molecules of water
system, positions = testsystem.system, testsystem.positions
if sysname == "longswitchedrfwater":
testsystem = testsystems.WaterBox(
box_edge=3.18 * u.nanometers,
cutoff=1.5 * u.nanometers,
nonbondedMethod=app.CutoffPeriodic,
switch_width=3.0 * u.angstroms) # Around 1060 molecules of water
system, positions = testsystem.system, testsystem.positions
if sysname == "density":
system, positions = load_lb(hydrogenMass=3.0 * u.amu)
hmc_integrators.guess_force_groups(system,
nonbonded=1,
fft=1,
others=0)
groups = [(0, 4), (1, 1)]
timestep = 2.0 * u.femtoseconds
if sysname == "dhfr":
testsystem = testsystems.DHFRExplicit(nonbondedCutoff=1.1 *
u.nanometers,
nonbondedMethod=app.PME,
switch_width=2.0 * u.angstroms,
ewaldErrorTolerance=5E-5)
system, positions = testsystem.system, testsystem.positions
hmc_integrators.guess_force_groups(system,
nonbonded=1,
fft=2,
others=0)
groups = [(0, 4), (1, 2), (2, 1)]
timestep = 0.75 * u.femtoseconds
equil_steps = 10000
if sysname == "src":
testsystem = testsystems.SrcExplicit(nonbondedCutoff=1.1 *
u.nanometers,
nonbondedMethod=app.PME,
switch_width=2.0 * u.angstroms,
ewaldErrorTolerance=5E-5)
system, positions = testsystem.system, testsystem.positions
hmc_integrators.guess_force_groups(system,
nonbonded=1,
fft=1,
others=0)
groups = [(0, 2), (1, 1)]
timestep = 0.25 * u.femtoseconds
equil_steps = 1000
if sysname == "ho":
K = 90.0 * u.kilocalories_per_mole / u.angstroms**2
mass = 39.948 * u.amu
timestep = np.sqrt(mass / K) * 0.4
testsystem = testsystems.HarmonicOscillatorArray()
system, positions = testsystem.system, testsystem.positions
groups = [(0, 1)]
if sysname == "customho":
timestep = 1000.0 * u.femtoseconds
testsystem = testsystems.CustomExternalForcesTestSystem()
system, positions = testsystem.system, testsystem.positions
groups = [(0, 1)]
if sysname == "customsplitho":
timestep = 1000.0 * u.femtoseconds
energy_expressions = ("0.75 * (x^2 + y^2 + z^2)",
"0.25 * (x^2 + y^2 + z^2)")
testsystem = testsystems.CustomExternalForcesTestSystem(
energy_expressions=energy_expressions)
system, positions = testsystem.system, testsystem.positions
groups = [(0, 2), (1, 1)]
if sysname == "alanine":
testsystem = testsystems.AlanineDipeptideImplicit()
system, positions = testsystem.system, testsystem.positions
groups = [(0, 2), (1, 1)]
timestep = 2.0 * u.femtoseconds
hmc_integrators.guess_force_groups(system, nonbonded=1, others=0)
#remove_cmm(system) # Unrolled shouldn't need this
equil_steps = 10000
if sysname == "alanineexplicit":
testsystem = testsystems.AlanineDipeptideExplicit(
cutoff=1.1 * u.nanometers,
switch_width=2 * u.angstrom,
ewaldErrorTolerance=5E-5)
system, positions = testsystem.system, testsystem.positions
#groups = [(0, 2), (1, 1), (2, 1)]
#groups = [(0, 2), (1, 1)]
timestep = 1.0 * u.femtoseconds
#hmc_integrators.guess_force_groups(system, nonbonded=1, others=0, fft=2)
#hmc_integrators.guess_force_groups(system, nonbonded=0, others=0, fft=1)
groups = [(0, 1), (1, 2)]
hmc_integrators.guess_force_groups(system,
nonbonded=0,
others=1,
fft=0)
#remove_cmm(system) # Unrolled doesn't need this
equil_steps = 4000
# guess force groups
if "ljbox" in sysname:
timestep = 25 * u.femtoseconds
temperature = 25. * u.kelvin
system, positions = testsystem.system, testsystem.positions
hmc_integrators.guess_force_groups(system, nonbonded=0, fft=1)
groups = [(0, 2), (1, 1)]
equil_steps = 10000
steps_per_hmc = 15
if sysname == "amoeba":
testsystem = testsystems.AMOEBAIonBox()
system, positions = testsystem.system, testsystem.positions
hmc_integrators.guess_force_groups(system,
nonbonded=0,
fft=1,
others=0)
return system, positions, groups, temperature, timestep, langevin_timestep, testsystem, equil_steps, steps_per_hmc
file1.write('%1.3f \t %1.3f\n\n'%(L_side, pme_cutoff))
for Method in [openmm.app.NoCutoff ,openmm.app.Ewald, openmm.app.PME]:
print(Method)
file1.write('\t' + str(Method) + '\n\n')
Ns = numpy.arange(200, 1200, 200)
file1.write('N\t\t time\n')
for N in Ns:
# print(N)
N_steps = int(N)
# Try: nonbondedMethod: NoCutoff, Ewald, PME
if str(Method) == "NoCutoff":
water_box = testsystems.WaterBox(box_edge=L_side*unit.nanometer, nonbondedMethod = Method)
# print(str(Method) + 'check')
else:
water_box = testsystems.WaterBox(box_edge=L_side*unit.nanometer, nonbondedMethod = Method, nonbondedCutoff=pme_cutoff*unit.nanometers, ewaldErrorTolerance = 0.001)
system = water_box.system
integrator = openmm.LangevinIntegrator(300*unit.kelvin, 1/unit.picosecond, 2*unit.femtoseconds)
simulation = openmm.app.simulation.Simulation(water_box.topology, system, integrator)
simulation.context.setPositions(water_box.positions)
simulation.reporters.append(openmm.app.StateDataReporter(stdout, N_steps, step = False, potentialEnergy = True))
# if N == 500:
# print("check!")
tic = time.time()
def test_ncmc_update_parameters_in_context(self):
"""
Testing that the protocol work is correctly calculated in cases when the parameters are updated using
context.updateParametersInContext() and the integrator is a compound integrator. The NCMC scheme tested below
is based on the one used by the saltswap and protons code-bases.
"""
from simtk.openmm import app
from openmmtools.constants import kB
size = 20.0
temperature = 298.0 * unit.kelvin
kT = kB * temperature
nonbonded_method = 'CutoffPeriodic'
platform_name = 'CPU'
timestep = 1. * unit.femtoseconds
collision_rate = 90. / unit.picoseconds
wbox = testsystems.WaterBox(box_edge=size*unit.angstrom, cutoff=9.*unit.angstrom, nonbondedMethod=getattr(app, nonbonded_method))
integrator = integrators.ExternalPerturbationLangevinIntegrator(splitting="V R O R V", temperature=temperature, timestep=timestep, collision_rate=collision_rate)
# Create context
platform = openmm.Platform.getPlatformByName(platform_name)
context = openmm.Context(wbox.system, integrator, platform)
context.setPositions(wbox.positions)
context.setPositions(wbox.positions)
context.setVelocitiesToTemperature(temperature)
def switchoff(force, context, frac=0.9):
force.setParticleParameters(0, charge=-0.834 * frac, sigma=0.3150752406575124*frac, epsilon=0.635968 * frac)
force.setParticleParameters(1, charge=0.417 * frac, sigma=0, epsilon=1 * frac)
force.setParticleParameters(2, charge=0.417 * frac, sigma=0, epsilon=1 * frac)
force.updateParametersInContext(context)
def switchon(force, context):
force.setParticleParameters(0, charge=-0.834, sigma=0.3150752406575124, epsilon=0.635968)
force.setParticleParameters(1, charge=0.417, sigma=0, epsilon=1)
force.setParticleParameters(2, charge=0.417, sigma=0, epsilon=1)
force.updateParametersInContext(context)
force = wbox.system.getForce(2) # Non-bonded force.
# Number of NCMC steps
nsteps = 20
niterations = 3
for i in range(niterations):
external_protocol_work = 0.0
integrator.reset_protocol_work()
integrator.step(1)
for step in range(nsteps):
fraction = float(step + 1) / float(nsteps)
initial_energy = context.getState(getEnergy=True).getPotentialEnergy()
switchoff(force, context, frac=fraction)
final_energy = context.getState(getEnergy=True).getPotentialEnergy()
external_protocol_work += (final_energy - initial_energy) / kT
integrator.step(1)
integrator_protocol_work = integrator.get_protocol_work(dimensionless=True)
assert abs(external_protocol_work - integrator_protocol_work) < 1.E-5
# Return to unperturbed state
switchon(force, context)
}
test_systems[
'TIP3P with reaction field, no charges, no switch, no dispersion correction'] = {
'test':
testsystems.DischargedWaterBox(dispersion_correction=False,
switch=False,
nonbondedMethod=app.CutoffPeriodic),
'ligand_atoms':
range(0, 3),
'receptor_atoms':
range(3, 6)
}
test_systems['TIP3P with reaction field, switch, no dispersion correction'] = {
'test':
testsystems.WaterBox(dispersion_correction=False,
switch=True,
nonbondedMethod=app.CutoffPeriodic),
'ligand_atoms':
range(0, 3),
'receptor_atoms':
range(3, 6)
}
test_systems['TIP3P with reaction field, no switch, dispersion correction'] = {
'test':
testsystems.WaterBox(dispersion_correction=True,
switch=False,
nonbondedMethod=app.CutoffPeriodic),
'ligand_atoms':
range(0, 3),
'receptor_atoms':
range(3, 6)
"""The total number of attempted HMC moves."""
return self.getGlobalVariableByName("ntrials")
@property
def acceptance_rate(self):
"""The acceptance rate: n_accept / n_trials."""
return self.n_accept / float(self.n_trials)
f = lambda x: (x.getPotentialEnergy(), x.getKineticEnergy(),
x.getKineticEnergy() + x.getPotentialEnergy())
temperature = 300. * u.kelvin
testsystem = testsystems.WaterBox(box_edge=10.0 * u.nanometers,
cutoff=1.1 * u.nanometers,
switch_width=3.0 * u.angstroms,
ewaldErrorTolerance=5E-5,
constrained=False)
timestep = 0.1 * u.femtoseconds
nsteps = 300
print("*" * 80)
print("force groups:")
for force in testsystem.system.getForces():
print(force, force.getForceGroup())
print("*" * 80)
print("Platform, integrator / acceptance rate, Enew")
for platform_name in ["CUDA", "OpenCL", "CPU"]:
platform = mm.Platform.getPlatformByName(platform_name)
