def add_barostat(system, model):
"""
Add a barostat to the system object to maintain constant
simulation pressure.
"""
if model.openmm_settings.barostat:
barostat = openmm.MonteCarloBarostat(
model.openmm_settings.barostat.target_pressure,
model.openmm_settings.barostat.target_temperature,
model.openmm_settings.barostat.frequency)
system.addForce(barostat)
return
def _configure_amber_explicit(
top_file: PathLike,
dt_ps: float,
temperature_kelvin: float,
heat_bath_friction_coef: float,
platform: "openmm.Platform",
platform_properties: dict,
explicit_barostat: str,
) -> "app.Simulation":
top = app.AmberPrmtopFile(str(top_file))
system = top.createSystem(
nonbondedMethod=app.PME,
nonbondedCutoff=1.0 * u.nanometer,
constraints=app.HBonds,
)
# Congfigure integrator
integrator = openmm.LangevinIntegrator(
temperature_kelvin * u.kelvin,
heat_bath_friction_coef / u.picosecond,
dt_ps * u.picosecond,
)
if explicit_barostat == "MonteCarloBarostat":
system.addForce(
openmm.MonteCarloBarostat(1 * u.bar,
temperature_kelvin * u.kelvin))
elif explicit_barostat == "MonteCarloAnisotropicBarostat":
system.addForce(
openmm.MonteCarloAnisotropicBarostat(
(1, 1, 1) * u.bar, temperature_kelvin * u.kelvin, False, False,
True))
else:
raise ValueError(
f"Invalid explicit_barostat option: {explicit_barostat}")
sim = app.Simulation(top.topology, system, integrator, platform,
platform_properties)
return sim
def _equil_NPT_OpenMM_protocol_0(topology,
positions,
temperature=300.0 * _unit.kelvin,
pressure=1.0 * _unit.atmosphere,
time=1.0 * _unit.nanosecond,
forcefield=None,
verbose=True,
progress_bar=True):
import numpy as np
import openmm.app as app
import openmm as mm
from openmmtools.integrators import LangevinIntegrator, GeodesicBAOABIntegrator
if progress_bar:
from tqdm import tqdm
else:
def tqdm(arg):
return arg
#item needs to be openmm.modeller
forcefield = app.ForceField("amber99sbildn.xml", "tip3p.xml")
topology = item.topology
positions = item.positions
system = forcefield_generator.createSystem(topology,
contraints=app.HBonds,
nonbondedMethod=app.PME,
nonbondedCutoff=1.0 *
_unit.nanometers,
rigidWater=True,
ewaldErrorTolerance=0.0005)
## Thermodynamic State
kB = _unit.BOLTZMANN_CONSTANT_kB * _unit.AVOGADRO_CONSTANT_NA
temperature = temperature
pressure = pressure
## Barostat
barostat_frequency = 25 # steps
barostat = mm.MonteCarloBarostat(pressure, temperature, barostat_frequency)
system.addForce(barostat)
## Integrator
friction = 1.0 / _unit.picosecond
step_size = 2.0 * _unit.femtoseconds
integrator = LangevinIntegrator(temperature, friction, step_size)
integrator.setConstraintTolerance(0.00001)
## Platform
platform = mm.Platform.getPlatformByName('CUDA')
properties = {'CudaPrecision': 'mixed'}
## Simulation
simulation = app.Simulation(topology, system, integrator, platform,
properties)
simulation.context.setPositions(positions)
simulation.context.setVelocitiesToTemperature(temperature)
time_equilibration = time
time_iteration = 0.2 * _unit.picoseconds
number_iterations = int(time_equilibration / time_iteration)
steps_iteration = int(time_iteration / step_size)
steps_equilibration = number_iterations * steps_iteration
## Reporters
net_mass, n_degrees_of_freedom = m3t.get(system,
net_mass=True,
n_degrees_of_freedom=True)
niters = number_iterations
data = dict()
data['time'] = _unit.Quantity(np.zeros([niters], np.float64),
_unit.picoseconds)
data['potential'] = _unit.Quantity(np.zeros([niters], np.float64),
_unit.kilocalories_per_mole)
data['kinetic'] = _unit.Quantity(np.zeros([niters], np.float64),
_unit.kilocalories_per_mole)
data['volume'] = _unit.Quantity(np.zeros([niters], np.float64),
_unit.angstroms**3)
data['density'] = _unit.Quantity(np.zeros([niters], np.float64),
_unit.gram / _unit.centimeters**3)
data['kinetic_temperature'] = unit.Quantity(np.zeros([niters], np.float64),
_unit.kelvin)
for iteration in tqdm(range(number_iterations)):
integrator.step(steps_iteration)
state = simulation.context.getState(getEnergy=True)
time = state.getTime()
potential_energy = state.getPotentialEnergy()
kinetic_energy = state.getKineticEnergy()
volume = state.getPeriodicBoxVolume()
density = (net_mass / volume).in_units_of(unit.gram /
unit.centimeter**3)
kinetic_temperature = (2.0 * kinetic_energy /
kB / n_degrees_of_freedom).in_units_of(
unit.kelvin) # (1/2) ndof * kB * T = KE
data['time'][iteration] = time
data['potential'] = potential_energy
data['kinetic'] = kinetic_energy
data['volume'] = volume
data['density'] = density
data['kinetic_temperature'] = kinetic_temperature
final_state = simulation.context.getState(getPositions=True,
getVelocities=True)
final_positions = final_state.getPositions()
final_velocities = final_state.getVelocities()
return final_positions, final_velocities, data
def runOneTest(testName, options):
"""Perform a single benchmarking simulation."""
explicit = (testName not in ('gbsa', 'amoebagk'))
amoeba = (testName in ('amoebagk', 'amoebapme'))
apoa1 = testName.startswith('apoa1')
amber = (testName.startswith('amber'))
hydrogenMass = None
print()
if amoeba:
print('Test: %s (epsilon=%g)' % (testName, options.epsilon))
elif testName == 'pme':
print('Test: pme (cutoff=%g)' % options.cutoff)
else:
print('Test: %s' % testName)
print('Ensemble: %s' % options.ensemble)
platform = mm.Platform.getPlatformByName(options.platform)
# Create the System.
temperature = 300 * unit.kelvin
if explicit:
friction = 1 * (1 / unit.picoseconds)
else:
friction = 91 * (1 / unit.picoseconds)
if amoeba:
constraints = None
epsilon = float(options.epsilon)
if explicit:
ff = app.ForceField('amoeba2009.xml')
pdb = app.PDBFile('5dfr_solv-cube_equil.pdb')
cutoff = 0.7 * unit.nanometers
vdwCutoff = 0.9 * unit.nanometers
system = ff.createSystem(pdb.topology,
nonbondedMethod=app.PME,
nonbondedCutoff=cutoff,
vdwCutoff=vdwCutoff,
constraints=constraints,
ewaldErrorTolerance=0.00075,
mutualInducedTargetEpsilon=epsilon,
polarization=options.polarization)
else:
ff = app.ForceField('amoeba2009.xml', 'amoeba2009_gk.xml')
pdb = app.PDBFile('5dfr_minimized.pdb')
cutoff = 2.0 * unit.nanometers
vdwCutoff = 1.2 * unit.nanometers
system = ff.createSystem(pdb.topology,
nonbondedMethod=app.NoCutoff,
constraints=constraints,
mutualInducedTargetEpsilon=epsilon,
polarization=options.polarization)
for f in system.getForces():
if isinstance(f, mm.AmoebaMultipoleForce) or isinstance(
f, mm.AmoebaVdwForce) or isinstance(
f, mm.AmoebaGeneralizedKirkwoodForce) or isinstance(
f, mm.AmoebaWcaDispersionForce):
f.setForceGroup(1)
dt = 0.002 * unit.picoseconds
if options.ensemble == 'NVE':
integ = mm.MTSIntegrator(dt, [(0, 2), (1, 1)])
else:
integ = mm.MTSLangevinIntegrator(temperature, friction, dt,
[(0, 2), (1, 1)])
positions = pdb.positions
elif amber:
dirname = downloadAmberSuite()
names = {
'amber20-dhfr': 'JAC',
'amber20-factorix': 'FactorIX',
'amber20-cellulose': 'Cellulose',
'amber20-stmv': 'STMV'
}
fileName = names[testName]
prmtop = app.AmberPrmtopFile(
os.path.join(dirname, f'PME/Topologies/{fileName}.prmtop'))
inpcrd = app.AmberInpcrdFile(
os.path.join(dirname, f'PME/Coordinates/{fileName}.inpcrd'))
topology = prmtop.topology
positions = inpcrd.positions
dt = 0.004 * unit.picoseconds
method = app.PME
cutoff = options.cutoff
constraints = app.HBonds
system = prmtop.createSystem(nonbondedMethod=method,
nonbondedCutoff=cutoff,
constraints=constraints)
if options.ensemble == 'NVE':
integ = mm.VerletIntegrator(dt)
else:
integ = mm.LangevinMiddleIntegrator(temperature, friction, dt)
else:
if apoa1:
ff = app.ForceField('amber14/protein.ff14SB.xml',
'amber14/lipid17.xml', 'amber14/tip3p.xml')
pdb = app.PDBFile('apoa1.pdb')
if testName == 'apoa1pme':
method = app.PME
cutoff = options.cutoff
elif testName == 'apoa1ljpme':
method = app.LJPME
cutoff = options.cutoff
else:
method = app.CutoffPeriodic
cutoff = 1 * unit.nanometers
hydrogenMass = 1.5 * unit.amu
elif explicit:
ff = app.ForceField('amber99sb.xml', 'tip3p.xml')
pdb = app.PDBFile('5dfr_solv-cube_equil.pdb')
if testName == 'pme':
method = app.PME
cutoff = options.cutoff
else:
method = app.CutoffPeriodic
cutoff = 1 * unit.nanometers
else:
ff = app.ForceField('amber99sb.xml', 'amber99_obc.xml')
pdb = app.PDBFile('5dfr_minimized.pdb')
method = app.CutoffNonPeriodic
cutoff = 2 * unit.nanometers
if options.heavy:
dt = 0.005 * unit.picoseconds
constraints = app.AllBonds
hydrogenMass = 4 * unit.amu
if options.ensemble == 'NVE':
integ = mm.VerletIntegrator(dt)
else:
integ = mm.LangevinIntegrator(temperature, friction, dt)
else:
dt = 0.004 * unit.picoseconds
constraints = app.HBonds
if options.ensemble == 'NVE':
integ = mm.VerletIntegrator(dt)
else:
integ = mm.LangevinMiddleIntegrator(temperature, friction, dt)
positions = pdb.positions
system = ff.createSystem(pdb.topology,
nonbondedMethod=method,
nonbondedCutoff=cutoff,
constraints=constraints,
hydrogenMass=hydrogenMass)
if options.ensemble == 'NPT':
system.addForce(mm.MonteCarloBarostat(1 * unit.bar, temperature, 100))
print('Step Size: %g fs' % dt.value_in_unit(unit.femtoseconds))
properties = {}
initialSteps = 5
if options.device is not None and platform.getName() in ('CUDA', 'OpenCL'):
properties['DeviceIndex'] = options.device
if ',' in options.device or ' ' in options.device:
initialSteps = 250
if options.precision is not None and platform.getName() in ('CUDA',
'OpenCL'):
properties['Precision'] = options.precision
# Run the simulation.
integ.setConstraintTolerance(1e-5)
if len(properties) > 0:
context = mm.Context(system, integ, platform, properties)
else:
context = mm.Context(system, integ, platform)
context.setPositions(positions)
if amber:
if inpcrd.boxVectors is not None:
context.setPeriodicBoxVectors(*inpcrd.boxVectors)
mm.LocalEnergyMinimizer.minimize(
context, 100 * unit.kilojoules_per_mole / unit.nanometer)
context.setVelocitiesToTemperature(temperature)
steps = 20
while True:
time = timeIntegration(context, steps, initialSteps)
if time >= 0.5 * options.seconds:
break
if time < 0.5:
steps = int(
steps * 1.0 / time
) # Integrate enough steps to get a reasonable estimate for how many we'll need.
else:
steps = int(steps * options.seconds / time)
print('Integrated %d steps in %g seconds' % (steps, time))
print('%g ns/day' %
(dt * steps * 86400 / time).value_in_unit(unit.nanoseconds))