def test_alchemy():
import os
import simtk.unit as unit
import simtk.openmm as openmm
import numpy as np
import simtk.openmm.app as app
import alchemy
# Create SystemBuilder objects.
from openmmtools import testsystems
receptor_pdb_filename = testsystems.get_data_filename("data/T4-lysozyme-L99A-implicit/receptor.pdb")
ligand_mol2_filename = testsystems.get_data_filename("data/T4-lysozyme-L99A-implicit/ligand.tripos.mol2")
receptor = BiopolymerPDBSystemBuilder(receptor_pdb_filename, pH=7.0)
ligand = Mol2SystemBuilder(ligand_mol2_filename, charge=0)
complex = ComplexSystemBuilder(ligand, receptor, remove_ligand_overlap=True)
timestep = 2 * unit.femtoseconds # timestep
temperature = 300.0 * unit.kelvin # simulation temperature
collision_rate = 20.0 / unit.picoseconds # Langevin collision rate
minimization_tolerance = 10.0 * unit.kilojoules_per_mole / unit.nanometer
minimization_steps = 20
plat = "CPU"
i=2
platform = openmm.Platform.getPlatformByName(plat)
forcefield = app.ForceField
systembuilders = [ligand, receptor, complex]
receptor_atoms = complex.receptor_atoms
ligand_atoms = complex.ligand_atoms
factory = alchemy.AbsoluteAlchemicalFactory(systembuilders[i].system, ligand_atoms=ligand_atoms)
protocol = factory.defaultComplexProtocolImplicit()
systems = factory.createPerturbedSystems(protocol)
integrator_interacting = openmm.LangevinIntegrator(temperature, collision_rate, timestep)
#test an alchemical intermediate and an unperturbed system:
fully_interacting = app.Simulation(systembuilders[i].topology, systems[0], integrator_interacting, platform=plat)
fully_interacting.context.setPositions(systembuilders[i].positions)
fully_interacting.minimizeEnergy(tolerance=10*unit.kilojoule_per_mole)
fully_interacting.reporters.append(app.PDBReporter('fully_interacting.pdb', 10))
for j in range(10):
logger.info(str(j))
fully_interacting.step(100)
del fully_interacting
for p in range(1, len(systems)):
logger.info("now simulating " + str(p))
integrator_partialinteracting = openmm.LangevinIntegrator(temperature, collision_rate, timestep)
partially_interacting = app.Simulation(systembuilders[i].topology, systems[p], integrator_partialinteracting, platform=plat)
partially_interacting.context.setPositions(systembuilders[i].positions)
partially_interacting.minimizeEnergy(tolerance=10*unit.kilojoule_per_mole)
partially_interacting.reporters.append(app.PDBReporter('partial_interacting'+str(p)+'.pdb', 10))
for k in range(10):
logger.info(str(k))
partially_interacting.step(100)
del partially_interacting
def simulate(topology, system, positions, output_filename):
import simtk.openmm.app as app
timestep = 2.0 * unit.femtoseconds
collision_rate = 20.0 / unit.picoseconds
temperature = 298.0 * unit.kelvin
integrator = openmm.LangevinIntegrator(temperature, collision_rate,
timestep)
niterations = 1000
nsteps = 500
simulation = app.Simulation(topology, system, integrator)
simulation.context.setPositions(positions)
reporter = app.PDBReporter(output_filename, nsteps)
simulation.reporters.append(reporter)
# Write first frame.
state = simulation.context.getState(getPositions=True)
reporter.report(simulation, state)
print(" Minimizing...")
simulation.minimizeEnergy(maxIterations=50)
# Write first frame.
state = simulation.context.getState(getPositions=True)
reporter.report(simulation, state)
print(" Simulating...")
for iteration in range(niterations):
print(" Iteration %d / %d" % (iteration, niterations))
simulation.step(nsteps)
return
def equilibrate(self, ff_name, water_name):
input_pdb_filename = self.get_initial_pdb_filename(ff_name, water_name)
equil_pdb_filename = self.get_equil_pdb_filename(ff_name, water_name)
equil_dcd_filename = self.get_equil_dcd_filename(ff_name, water_name)
equil_protein_pdb_filename = self.get_equil_protein_pdb_filename(
ff_name, water_name)
utils.make_path(equil_pdb_filename)
if os.path.exists(equil_pdb_filename):
return
ff = app.ForceField('%s.xml' % ff_name, '%s.xml' % water_name)
pdb = app.PDBFile(input_pdb_filename)
modeller = app.Modeller(pdb.topology, pdb.positions)
modeller.addSolvent(ff,
model=water_mapping[water_name],
padding=self.padding,
ionicStrength=self.ionic_strength)
topology = modeller.getTopology()
positions = modeller.getPositions()
system = ff.createSystem(topology,
nonbondedMethod=app.PME,
nonbondedCutoff=self.cutoff,
constraints=app.HBonds)
integrator = mm.LangevinIntegrator(self.temperature,
self.equil_friction,
self.equil_timestep)
system.addForce(
mm.MonteCarloBarostat(self.pressure, self.temperature,
self.barostat_frequency))
simulation = app.Simulation(topology, system, integrator)
simulation.context.setPositions(positions)
print('Minimizing.')
simulation.minimizeEnergy()
simulation.context.setVelocitiesToTemperature(self.temperature)
print('Equilibrating.')
simulation.reporters.append(
app.PDBReporter(equil_pdb_filename, self.n_equil_steps - 1))
simulation.reporters.append(
app.DCDReporter(equil_dcd_filename, self.equil_output_frequency))
simulation.step(self.n_equil_steps)
del simulation
del system
traj = md.load(equil_dcd_filename, top=equil_pdb_filename)[-1]
traj.save(equil_pdb_filename)
top, bonds = traj.top.to_dataframe()
atom_indices = top.index[top.chainID == 0].values
traj.restrict_atoms(atom_indices)
traj.save(equil_protein_pdb_filename)
def simulate(inpcrd_filenames, prmtop_filenames, path, niterations=10000, implicit=True, gpu=True, niters=0):
"""
The program simulates three systems: the ligand alone, protein alone, and complex.
Input is a dict of files to the input coordinates (.inpcrd) and parameters (.prmtop)
as well as the number of iterations. One iteration is one picosecond.
Output is a dict of a list of the ennthalpies calculated using mmgbsa for each system.
"""
from simtk.openmm import app
import simtk.openmm as mm
from simtk import unit
phases = inpcrd_filenames.keys()
nsteps_per_iteration = 500 # 1 picosecond
enthalpies = dict()
for phase in phases:
print("on phase", phase)
enthalpies[phase] = np.zeros([niterations])
prmtop = app.AmberPrmtopFile(prmtop_filenames[phase])
inpcrd = app.AmberInpcrdFile(inpcrd_filenames[phase])
system = prmtop.createSystem(implicitSolvent=app.GBn2,
nonbondedMethod=app.CutoffNonPeriodic,
nonbondedCutoff=2.0*unit.nanometers,
constraints=app.HBonds)
integrator = mm.LangevinIntegrator(310.15*unit.kelvin, 1.0/unit.picoseconds, 2.0*unit.femtoseconds)
integrator.setConstraintTolerance(0.00001)
if gpu:
platform = 'CUDA'
else:
platform = 'CPU'
platform = mm.Platform.getPlatformByName(platform)
if gpu:
properties = {'CudaPrecision': 'mixed', 'CudaDeviceIndex' : '0'}
else:
properties = {}
simulation = app.Simulation(prmtop.topology, system, integrator, platform, properties)
simulation.context.setPositions(inpcrd.positions)
if phase == 'com':
simulation.reporters.append(app.PDBReporter(path + '/' + phase + '_output.pdb', 10000))
# Minimize & equilibrate
simulation.minimizeEnergy()
simulation.context.setVelocitiesToTemperature(310.15*unit.kelvin)
simulation.step(100)
# Run simulation
for iteration in range(niterations):
simulation.step(nsteps_per_iteration)
state = simulation.context.getState(getEnergy=True)
potential_energy = state.getPotentialEnergy()
enthalpies[phase][iteration] = potential_energy.value_in_unit(unit.kilojoules_per_mole)
del simulation
del system
del platform
return enthalpies
def run(self,
production_steps=200,
start='ala2_1stFrame.pdb',
production='ala2_production.pdb'): #### ?!!!!!!!!!!!!!!!!
#from __future__ import print_function
from simtk.openmm import app
import simtk.openmm as mm
from simtk import unit
from sys import stdout
nonbondedCutoff = 1.0 * unit.nanometers
timestep = 2.0 * unit.femtoseconds
temperature = 300 * unit.kelvin
#save_frequency = 100 #Every 100 steps, save the trajectory
save_frequency = 10 #Every 1 steps, save the trajectory
pdb = app.PDBFile(start)
forcefield = app.ForceField('amber99sb.xml', 'tip3p.xml')
ala2_model = app.Modeller(pdb.topology, pdb.positions)
#Hydrogens will be constrained after equilibrating
system = forcefield.createSystem(ala2_model.topology,
nonbondedMethod=app.PME,
nonbondedCutoff=nonbondedCutoff,
constraints=app.HBonds,
rigidWater=True,
ewaldErrorTolerance=0.0005)
system.addForce(mm.MonteCarloBarostat(
1 * unit.bar, temperature,
100)) #Apply Monte Carlo Pressure changes in 100 timesteps
integrator = mm.LangevinIntegrator(temperature, 1.0 / unit.picoseconds,
timestep)
integrator.setConstraintTolerance(0.00001)
platform = mm.Platform.getPlatformByName('CPU')
simulation = app.Simulation(ala2_model.topology, system, integrator,
platform)
simulation.context.setPositions(ala2_model.positions)
simulation.context.setVelocitiesToTemperature(temperature)
simulation.reporters.append(app.PDBReporter(production,
save_frequency))
#simulation.reporters.append(app.StateDataReporter('stateReporter_constantPressure.txt', 1000, step=True,
# totalEnergy=True, temperature=True, volume=True, progress=True, remainingTime=True,
# speed=True, totalSteps=production_steps, separator='\t'))
print('Running Production...')
simulation.step(production_steps)
print('Done!')
import mdtraj as md
trj = md.load(production)
return trj
def testXTCreporter(self):
output_PDB = "tests/data/test_xtcreporter.pdb"
output_XTC = "tests/data/test_xtcreporter.xtc"
top_PDB = "tests/data/top_xtcreporter.pdb"
PLATFORM = mm.Platform_getPlatformByName(str('CPU'))
prmtop = app.AmberPrmtopFile("tests/data/complex.prmtop")
inpcrd = app.AmberInpcrdFile("tests/data/complex.inpcrd")
system = prmtop.createSystem(nonbondedMethod=app.PME,
nonbondedCutoff=9 * unit.angstroms,
constraints=app.HBonds)
system.addForce(
mm.AndersenThermostat(300 * unit.kelvin, 1 / unit.picosecond))
integrator = mm.VerletIntegrator(2 * unit.femtoseconds)
force = mm.CustomExternalForce(str("k*((x-x0)^2+(y-y0)^2+(z-z0)^2)"))
force.addGlobalParameter(
str("k"), 5.0 * unit.kilocalories_per_mole / unit.angstroms**2)
force.addPerParticleParameter(str("x0"))
force.addPerParticleParameter(str("y0"))
force.addPerParticleParameter(str("z0"))
for j, atom in enumerate(prmtop.topology.atoms()):
if (atom.name in ('CA', 'C', 'N', 'O') and atom.residue.name !=
"HOH") or (atom.residue.name == "BEN"
and atom.element.symbol != "H"):
force.addParticle(
j, inpcrd.positions[j].value_in_unit(unit.nanometers))
system.addForce(force)
simulation = app.Simulation(prmtop.topology, system, integrator,
PLATFORM)
if inpcrd.boxVectors is not None:
simulation.context.setPeriodicBoxVectors(*inpcrd.boxVectors)
simulation.context.setPositions(inpcrd.positions)
simulation.minimizeEnergy(maxIterations=10)
print("Minimization ended")
xtcReporter = XTCReporter(output_XTC, 1)
simulation.reporters.append(app.PDBReporter(output_PDB, 1))
simulation.reporters.append(xtcReporter)
simulation.step(10)
# the XTCReporter does not close the file, so opening the file again
# without exiting the function causes problems to the mdtraj reader
xtcReporter.close()
t_xtc = md.load(str(output_XTC), top=top_PDB)
t_pdb = md.load(output_PDB)
self.assertEqual(t_pdb.top, t_xtc.top)
self.assertEqual(np.sum(np.abs(t_pdb.xyz - t_xtc.xyz) > 1e-3), 0)
os.remove(output_PDB)
os.remove(output_XTC)
normal_pairs.append(site_no)
excep_pairs = np.reshape(excep_pairs, (len(excep_pairs) // 2, 2))
normal_pairs = np.reshape(normal_pairs, (len(normal_pairs) // 2, 2))
system = opls_lj(system)
system.addForce(MonteCarloBarostat(1 * unit.bar, TEMP))
integrator = LangevinIntegrator(TEMP, 5 / unit.picosecond,
0.001 * unit.picoseconds)
simulation = app.Simulation(modeller.topology, system, integrator)
simulation.context.setPositions(modeller.positions)
# simulation.context.computeVirtualSites()
print('MINIMIZATION STARTED')
simulation.minimizeEnergy()
# print('Energy at Minima is %3.3f kcal/mol' % (energy._value * KcalPerKJ))
print('MINIMIZATION DONE')
simulation.reporters.append(app.PDBReporter('output.pdb', 1000))
simulation.reporters.append(
app.StateDataReporter('liquid.txt',
1000,
step=True,
potentialEnergy=True,
temperature=True,
density=True))
simulation.step(3000000)
np_equ_pos = simulation.context.getState(getPositions=True).getPositions()
app.PDBFile.writeFile(simulation.topology, np_equ_pos,
open('NPT_EQ_FINAL.pdb', 'w'))
state = simulation.context.getState(getEnergy=True)
# print(state.getPotentialEnergy())
modeller = app.Modeller(pdb.topology, pdb.positions)
modeller.addSolvent(ff, model=base_waters[water_name], padding=padding)
topology = modeller.getTopology()
positions = modeller.getPositions()
system = ff.createSystem(topology,
nonbondedMethod=app.PME,
nonbondedCutoff=cutoff,
constraints=app.HBonds)
integrator = mm.LangevinIntegrator(temperature, friction, timestep)
system.addForce(
mm.MonteCarloBarostat(pressure, temperature, barostat_frequency))
simulation = app.Simulation(topology, system, integrator)
simulation.context.setPositions(positions)
print('Minimizing...')
simulation.minimizeEnergy()
simulation.context.setVelocitiesToTemperature(temperature)
print('Running.')
simulation.reporters.append(
app.PDBReporter(output_pdb, equilibrate_output_frequency))
simulation.reporters.append(
app.DCDReporter(output_dcd, equilibrate_output_frequency))
simulation.step(n_equil_steps)
del simulation
del system
t = md.load(output_dcd, top=output_pdb)
t.save(output_pdb)
platform = mm.Platform.getPlatformByName('CUDA')
properties = {'CudaPrecision': 'mixed'}
simulation = app.Simulation(pdb.topology, system, integrator, platform,
properties)
simulation.context.setPositions(pdb.positions)
#print('Minimizing...')
#simulation.minimizeEnergy()
#simulation.context.setVelocitiesToTemperature(88.9407*unit.kelvin)
#print('Equilibrating...')
#simulation.step(1000)
simulation.reporters.append(app.DCDReporter('argon_cluster.dcd', 10))
simulation.reporters.append(app.PDBReporter('argon_cluster_out.pdb', 100000))
simulation.reporters.append(
app.StateDataReporter(stdout,
1000,
step=True,
time=True,
potentialEnergy=True,
kineticEnergy=True,
temperature=True,
volume=True,
density=True,
speed=True,
separator='\t'))
print('Running Production...')
simulation.step(20000)
def production(system, topology, ensemble, temperature, timestep,
collision_rate, n_steps, nsteps_out,
firstframe_name, log_name, traj_name, final_state_name,
n_equil_steps=1000, ini_positions=None, ini_state_name=None,
use_switch=False, r_switch=None, pressure=None, minimize=False,
cuda=False, gpu_idxs=None, more_reporters=[], dynamics="Langevin",
use_platform=None):
if use_switch:
# set switching function on nonbonded forces
for i in range(system.getNumForces()):
force = system.getForce(i)
if force.__repr__().find("NonbondedForce") > -1:
force.setUseSwitchingFunction(True)
if r_switch is None:
raise IOError("Need to input r_switch if use_switch = True")
else:
force.setSwitchingDistance(r_switch/unit.nanometer)
if ensemble == "NVE":
integrator = omm.VerletIntegrator(timestep)
else:
if dynamics == "Langevin":
integrator = omm.LangevinIntegrator(temperature, collision_rate, timestep)
elif dynamics == "Brownian":
integrator = omm.BrownianIntegrator(temperature, collision_rate, timestep)
else:
raise IOError("dynamics must be Langevin or Brownian")
if ensemble == "NPT":
if pressure is None:
raise ValueError("If ensemble is NPT need to specficy pressure")
system.addForce(omm.MonteCarloBarostat(pressure, temperature))
if not use_platform is None:
if use_platform == "CUDA":
platform = omm.Platform.getPlatformByName('CUDA')
if gpu_idxs is None:
properties = {'DeviceIndex': '0'}
else:
properties = {'DeviceIndex': gpu_idxs}
simulation = app.Simulation(topology, system, integrator, platform, properties)
elif use_platform == "CPU":
platform = omm.Platform.getPlatformByName("CPU")
simulation = app.Simulation(topology, system, integrator, platform)
else:
raise ValueError("use_platform needs to be CUDA or CPU or not specfied")
else:
simulation = app.Simulation(topology, system, integrator)
if not ini_positions is None:
# set initial positions and box dimensions
simulation.context.setPositions(ini_positions)
#simulation.context.setPeriodicBoxVectors()
elif not ini_position_file is None:
simulation.loadState(ini_state_name)
else:
raise ValueError("Need to specify initial positions somehow!")
if minimize:
simulation.minimizeEnergy(tolerance=energy_minimization_tol)
# initial equilibration
simulation.step(n_equil_steps)
# save the first frame minimized
simulation.reporters.append(app.PDBReporter(firstframe_name, 1))
simulation.step(1)
simulation.reporters.pop(0)
# record coordinates
simulation.reporters.append(app.DCDReporter(traj_name, nsteps_out))
simulation.reporters.append(app.StateDataReporter(log_name, nsteps_out,
step=True, potentialEnergy=True, kineticEnergy=True, temperature=True,
density=True, volume=True))
# add user-defined reporters for e.g. forces or velocities
if len(more_reporters) > 0:
for i in range(len(more_reporters)):
simulation.reporters.append(more_reporters[i])
# run simulation!
simulation.step(n_steps)
# save final state. positions, box vectors.
simulation.saveState(final_state_name)
pdb = app.PDBFile(pdb_filename)
modeller = app.Modeller(pdb.topology, pdb.positions)
modeller.addSolvent(ff, model=base_waters[water_name], padding=padding)
topology = modeller.getTopology()
positions = modeller.getPositions()
system = ff.createSystem(topology, nonbondedMethod=app.PME, nonbondedCutoff=cutoff, constraints=app.HBonds)
integrator = mm.LangevinIntegrator(temperature, friction, timestep)
system.addForce(mm.MonteCarloBarostat(pressure, temperature, barostat_frequency))
simulation = app.Simulation(topology, system, integrator)
simulation.context.setPositions(positions)
print('Minimizing...')
simulation.minimizeEnergy()
simulation.context.setVelocitiesToTemperature(temperature)
print('Running.')
simulation.reporters.append(app.PDBReporter(output_pdb, equilibrate_output_frequency))
simulation.reporters.append(app.DCDReporter(output_dcd, equilibrate_output_frequency))
simulation.step(n_equil_steps)
del simulation
del system
t = md.load(output_dcd, top=output_pdb)
t.save(output_pdb)
def main(
paramfile='params.in',
overrides={},
quiktest=False,
deviceid=None,
progressreport=True,
soluteRes=[0],
lambdaLJ=1.0,
lambdaQ=1.0
): #simtime=2.0, T=298.0, NPT=True, LJcut=10.0, tail=True, useLJPME=False, rigidH2O=True, device=0, quiktest=False):
# === PARSE === #
args = mdparse.SimulationOptions(paramfile, overrides)
# Files
gromacs.GROMACS_TOPDIR = args.topdir
top_file = args.topfile
box_file = args.grofile
defines = {}
cont = args.cont
args.force_active('chkxml',
val='chk_{:02n}.xml'.format(cont),
msg='first one')
args.force_active('chkpdb',
val='chk_{:02n}.pdb'.format(cont),
msg='first one')
if cont > 0:
args.force_active('incoord',
val='chk_{:02n}.xml'.format(cont - 1),
msg='continuing')
args.force_active('outpdb',
val='output_{:02n}.pdb'.format(cont),
msg='continuing')
args.force_active('outnetcdf',
val='output_{:02n}.nc'.format(cont),
msg='continuing')
args.force_active('logfile',
val='thermo.log_{:02n}'.format(cont),
msg='continuing')
args.force_active('outdcd',
val='output_{:02n}.dcd'.format(cont),
msg='continuing')
incoord = args.incoord
out_pdb = args.outpdb
out_netcdf = args.outnetcdf
out_dcd = args.outdcd
molecTopology = 'topology.pdb'
out_nowater = 'output_nowater.nc'
out_nowater_dcd = 'output_nowater.dcd'
logfile = args.logfile
checkpointxml = args.chkxml
checkpointpdb = args.chkpdb
checkpointchk = 'chk_{:02n}.chk'.format(cont)
# Parameters
#Temp = args.temperature #K
#Pressure = 1 #bar
#barostatfreq = 25 #time steps
#fric = args.collision_rate #1/ps
dt = args.timestep #fs
if args.use_fs_interval:
reportfreq = int(args.report_interval / dt)
netcdffreq = int(args.netcdf_report_interval / dt) #5e4
dcdfreq = int(args.dcd_report_interval / dt)
pdbfreq = int(args.pdb_report_interval / dt)
checkfreq = int(args.checkpoint_interval / dt)
#simtime = int( simtime ) #nanoseconds; make sure division is whole... no remainders...
blocksteps = int(args.block_interval /
dt) #1e6, steps per block of simulation
nblocks = args.nblocks #aiming for 1 block is 1ns
else:
reportfreq = args.report_interval
netcdffreq = args.netcdf_report_interval
dcdfreq = args.dcd_report_interval
pdbfreq = args.pdb_report_interval
checkfreq = args.checkpoint_interval
blocksteps = args.block_interval
nblocks = args.nblocks
if quiktest == True:
reportfreq = 1
blocksteps = 10
nblocks = 2
# === Start Making System === #
start = time.time()
top = gromacs.GromacsTopologyFile(top_file, defines=defines)
gro = gromacs.GromacsGroFile.parse(box_file)
top.box = gro.box
logger.info("Took {}s to create topology".format(time.time() - start))
print(top)
constr = {
None: None,
"None": None,
"HBonds": app.HBonds,
"HAngles": app.HAngles,
"AllBonds": app.AllBonds
}[args.constraints]
start = time.time()
system = top.createSystem(nonbondedMethod=app.PME,
ewaldErrorTolerance=args.ewald_error_tolerance,
nonbondedCutoff=args.nonbonded_cutoff *
u.nanometers,
rigidWater=args.rigid_water,
constraints=constr)
logger.info("Took {}s to create system".format(time.time() - start))
nbm = {
"NoCutoff": mm.NonbondedForce.NoCutoff,
"CutoffNonPeriodic": mm.NonbondedForce.CutoffNonPeriodic,
"Ewald": mm.NonbondedForce.Ewald,
"PME": mm.NonbondedForce.PME,
"LJPME": mm.NonbondedForce.LJPME
}[args.nonbonded_method]
ftmp = [
f for ii, f in enumerate(system.getForces())
if isinstance(f, mm.NonbondedForce)
]
fnb = ftmp[0]
fnb.setNonbondedMethod(nbm)
logger.info("Nonbonded method ({},{})".format(args.nonbonded_method,
fnb.getNonbondedMethod()))
if (not args.dispersion_correction) or (args.nonbonded_method == "LJPME"):
logger.info("Turning off tail correction...")
fnb.setUseDispersionCorrection(False)
logger.info("Check dispersion correction flag: {}".format(
fnb.getUseDispersionCorrection()))
# --- execute custom forcefield code ---
"""
if customff:
logger.info("Using customff: [{}]".format(customff))
with open(customff,'r') as f:
ffcode = f.read()
exec(ffcode,globals(),locals()) #python 3, need to pass in globals to allow exec to modify them (i.e. the system object)
#print(sys.path)
#sys.path.insert(1,'.')
#exec("import {}".format(".".join(customff.split(".")[:-1])))
else:
logger.info("--- No custom ff code provided ---")
fExts=[f for f in system.getForces() if isinstance(f,mm.CustomExternalForce)]
logger.info("External forces added: {}".format(fExts))
"""
soluteIndices = []
soluteResidues = soluteRes #list of residues to alchemify. modified s.t. soluteRes is already a list
#parmed gromacs topology
for ir, res in enumerate(top.residues):
if ir in soluteResidues:
for atom in res.atoms:
soluteIndices.append(atom.idx)
print("Solute residue: {}".format(
[top.residues[ir].atoms for ir in soluteResidues]))
print("Solute Indices: {}".format(soluteIndices))
#if using openmm topology. unfortunately don't know how to convert from parmed to openmm#:
#topology = parmed.openmm.load_topology(top.topology)
#print(type(topology))
#for ir,res in topology.residues():
# if ir in soluteResidues:
# for atom in res.atoms:
# soluteIndices.append(atom.index)
alch = alchemifyIons.alchemist(system, lambdaLJ, lambdaQ)
alch.setupSolute(soluteIndices)
print(system.getForces())
# === Integrator, Barostat, Additional Constraints === #
integrator = set_thermo(system, args)
if not hasattr(args, 'constraints') or (str(args.constraints) == "None"
and args.rigidwater == False):
args.deactivate('constraint_tolerance',
"There are no constraints in this system")
else:
logger.info("Setting constraint tolerance to %.3e" %
args.constraint_tolerance)
integrator.setConstraintTolerance(args.constraint_tolerance)
# === Make Platform === #
logger.info("Setting Platform to %s" % str(args.platform))
try:
platform = mm.Platform.getPlatformByName(args.platform)
except:
logger.info(
"Warning: %s platform not found, going to Reference platform \x1b[91m(slow)\x1b[0m"
% args.platform)
args.force_active('platform', "Reference",
"The %s platform was not found." % args.platform)
platform = mm.Platform.getPlatformByName("Reference")
if deviceid is not None or deviceid >= 0:
args.force_active('device',
deviceid,
msg="Using cmdline-input deviceid")
if 'device' in args.ActiveOptions and (platform.getName() == "OpenCL"
or platform.getName() == "CUDA"):
device = str(args.device)
# The device may be set using an environment variable or the input file.
#if 'CUDA_DEVICE' in os.environ.keys(): #os.environ.has_key('CUDA_DEVICE'):
# device = os.environ.get('CUDA_DEVICE',str(args.device))
#elif 'CUDA_DEVICE_INDEX' in os.environ.keys(): #os.environ.has_key('CUDA_DEVICE_INDEX'):
# device = os.environ.get('CUDA_DEVICE_INDEX',str(args.device))
#else:
# device = str(args.device)
if device != None:
logger.info("Setting Device to %s" % str(device))
#platform.setPropertyDefaultValue("CudaDevice", device)
if platform.getName() == "CUDA":
platform.setPropertyDefaultValue("CudaDeviceIndex", device)
elif platform.getName() == "OpenCL":
print("set OpenCL device to {}".format(device))
platform.setPropertyDefaultValue("OpenCLDeviceIndex", device)
else:
logger.info("Using the default (fastest) device")
else:
logger.info(
"Using the default (fastest) device, or not using CUDA nor OpenCL")
if "Precision" in platform.getPropertyNames() and (
platform.getName() == "OpenCL" or platform.getName() == "CUDA"):
platform.setPropertyDefaultValue("Precision", args.cuda_precision)
else:
logger.info("Not setting precision")
args.deactivate(
"cuda_precision",
msg="Platform does not support setting cuda_precision.")
# === Create Simulation === #
logger.info("Creating the Simulation object")
start = time.time()
# Get the number of forces and set each force to a different force group number.
nfrc = system.getNumForces()
if args.integrator != 'mtsvvvr':
for i in range(nfrc):
system.getForce(i).setForceGroup(i)
'''
for i in range(nfrc):
# Set vdW switching function manually.
f = system.getForce(i)
if f.__class__.__name__ == 'NonbondedForce':
#f.setUseSwitchingFunction(False)
#f.setSwitchingDistance(1.0*u.nanometers)
if 'vdw_switch' in args.ActiveOptions and args.vdw_switch:
f.setUseSwitchingFunction(True)
f.setSwitchingDistance(args.switch_distance)
'''
#create simulation object
if args.platform != None:
simulation = app.Simulation(top.topology, system, integrator, platform)
else:
simulation = app.Simulation(top.topology, system, integrator)
topomm = mdtraj.Topology.from_openmm(simulation.topology)
logger.info("System topology: {}".format(topomm))
#print platform we're using
mdparse.printcool_dictionary(
{
i: simulation.context.getPlatform().getPropertyValue(
simulation.context, i)
for i in simulation.context.getPlatform().getPropertyNames()
},
title="Platform %s has properties:" %
simulation.context.getPlatform().getName())
logger.info("--== PME parameters ==--")
ftmp = [
f for ii, f in enumerate(simulation.system.getForces())
if isinstance(f, mm.NonbondedForce)
]
fnb = ftmp[0]
if fnb.getNonbondedMethod() == 4: #check for PME
PMEparam = fnb.getPMEParametersInContext(simulation.context)
logger.info(fnb.getPMEParametersInContext(simulation.context))
if fnb.getNonbondedMethod() == 5: #check for LJPME
PMEparam = fnb.getLJPMEParametersInContext(simulation.context)
logger.info(fnb.getLJPMEParametersInContext(simulation.context))
#nmeshx = int(PMEparam[1]*1.5)
#nmeshy = int(PMEparam[2]*1.5)
#nmeshz = int(PMEparam[3]*1.5)
#fnb.setPMEParameters(PMEparam[0],nmeshx,nmeshy,nmeshz)
#logger.info(fnb.getPMEParametersInContext(simulation.context))
# Print out some more information about the system
logger.info("--== System Information ==--")
logger.info("Number of particles : %i" %
simulation.context.getSystem().getNumParticles())
logger.info("Number of constraints : %i" %
simulation.context.getSystem().getNumConstraints())
for f in simulation.context.getSystem().getForces():
if f.__class__.__name__ == 'NonbondedForce':
method_names = [
"NoCutoff", "CutoffNonPeriodic", "CutoffPeriodic", "Ewald",
"PME", "LJPME"
]
logger.info("Nonbonded method : %s" %
method_names[f.getNonbondedMethod()])
logger.info("Number of particles : %i" % f.getNumParticles())
logger.info("Number of exceptions : %i" % f.getNumExceptions())
if f.getNonbondedMethod() > 0:
logger.info("Nonbonded cutoff : %.3f nm" %
(f.getCutoffDistance() / u.nanometer))
if f.getNonbondedMethod() >= 3:
logger.info("Ewald error tolerance : %.3e" %
(f.getEwaldErrorTolerance()))
logger.info("LJ switching function : %i" %
f.getUseSwitchingFunction())
if f.getUseSwitchingFunction():
logger.info("LJ switching distance : %.3f nm" %
(f.getSwitchingDistance() / u.nanometer))
# Print the sample input file here.
for line in args.record():
print(line)
print("Took {}s to make and setup simulation object".format(time.time() -
start))
#============================#
#| Initialize & Eq/Warm-Up |#
#============================#
p = simulation.context.getPlatform()
if p.getName() == "CUDA" or p.getName() == "OpenCL":
print("simulation platform: {}".format(p.getName()))
print(p.getPropertyNames())
print(p.getPropertyValue(simulation.context, 'DeviceName'))
print("Device Index: {}".format(
p.getPropertyValue(simulation.context, 'DeviceIndex')))
if os.path.exists(args.restart_filename) and args.read_restart:
print("Restarting simulation from the restart file.")
print("Currently is filler")
else:
# Set initial positions.
if incoord.split(".")[-1] == "pdb":
pdb = app.PDBFile(incoord) #pmd.load_file(incoord)
simulation.context.setPositions(pdb.positions)
print('Set positions from pdb, {}'.format(incoord))
molecTopology = incoord
elif incoord.split(".")[-1] == "xyz":
traj = mdtraj.load(incoord,
top=mdtraj.Topology.from_openmm(
simulation.topology))
simulation.context.setPositions(traj.openmm_positions(0))
elif incoord.split(".")[-1] == "xml":
simulation.loadState(incoord)
print('Set positions from xml, {}'.format(incoord))
else:
logger.info("Error, can't handle input coordinate filetype")
if args.constraint_tolerance > 0.0:
simulation.context.applyConstraints(
args.constraint_tolerance
) #applies constraints in current frame.
logger.info("Initial potential energy is: {}".format(
simulation.context.getState(getEnergy=True).getPotentialEnergy()))
if args.integrator != 'mtsvvvr':
eda = mdparse.EnergyDecomposition(simulation)
eda_kcal = OrderedDict([(i, "%10.4f" % (j / 4.184))
for i, j in eda.items()])
mdparse.printcool_dictionary(
eda_kcal, title="Energy Decomposition (kcal/mol)")
# Minimize the energy.
if args.minimize:
logger.info("Minimization start, the energy is: {}".format(
simulation.context.getState(
getEnergy=True).getPotentialEnergy()))
simulation.minimizeEnergy()
logger.info("Minimization done, the energy is {}".format(
simulation.context.getState(
getEnergy=True).getPotentialEnergy()))
positions = simulation.context.getState(
getPositions=True).getPositions()
logger.info("Minimized geometry is written to 'minimized.pdb'")
app.PDBFile.writeModel(simulation.topology, positions,
open('minimized.pdb', 'w'))
# Assign velocities.
if args.gentemp > 0.0:
logger.info(
"Generating velocities corresponding to Maxwell distribution at %.2f K"
% args.gentemp)
simulation.context.setVelocitiesToTemperature(args.gentemp *
u.kelvin)
# Equilibrate.
logger.info("--== Equilibrating (%i steps, %.2f ps) ==--" %
(args.equilibrate, args.equilibrate * args.timestep *
u.femtosecond / u.picosecond))
if args.report_interval > 0:
# Append the ProgressReport for equilibration run.
simulation.reporters.append(
mdparse.ProgressReport(args, sys.stdout, args.report_interval,
simulation, args.equilibrate))
simulation.reporters[-1].t00 = time.time()
logger.info("Progress will be reported every %i steps" %
args.report_interval)
# This command actually does all of the computation.
simulation.step(args.equilibrate)
if args.report_interval > 0:
# Get rid of the ProgressReport because we'll make a new one.
simulation.reporters.pop()
first = args.equilibrate
#============================#
#| Production MD simulation |#
#============================#
logger.info(
"--== Production (%i blocks, %i steps total, %.2f ps total) ==--" %
(nblocks, nblocks * blocksteps,
nblocks * blocksteps * args.timestep * u.femtosecond / u.picosecond))
#===========================================#
#| Add reporters for production simulation |#
#===========================================#
print("===== registering reporters and runnning =====")
if args.report_interval > 0:
logger.info("Thermo and Progress will be reported every %i steps" %
args.report_interval)
#simulation.reporters.append(ProgressReport(sys.stdout, args.report_interval, simulation, args.production, first))
mdparse.bak(logfile)
simulation.reporters.append(
app.StateDataReporter(logfile,
reportfreq,
step=True,
potentialEnergy=True,
kineticEnergy=True,
temperature=True,
volume=True,
density=True,
speed=True))
#simulation.reporters.append(app.StateDataReporter(stdout, reportfreq, step=True,
# potentialEnergy=True, kineticEnergy=True, temperature=True, volume=True, density=True, speed=True))
if progressreport:
simulation.reporters.append(
mdparse.ProgressReport(args,
sys.stdout,
reportfreq,
simulation,
nblocks * blocksteps,
first=args.equilibrate))
Prog = simulation.reporters[-1]
if args.pdb_report_interval > 0:
mdparse.bak(out_pdb)
logger.info("PDB Reporter will write to %s every %i steps" %
(out_pdb, pdbfreq))
simulation.reporters.append(app.PDBReporter(out_pdb, pdbfreq))
if args.netcdf_report_interval > 0:
mdparse.bak(out_netcdf)
logger.info("netcdf Reporter will write to %s every %i steps" %
(out_netcdf, netcdffreq))
simulation.reporters.append(
NetCDFReporter(out_netcdf,
netcdffreq,
crds=True,
vels=args.netcdf_vels,
frcs=args.netcdf_frcs))
'''
mdparse.bak(out_nowater)
logger.info("netcdf Reporter will write a no-water coordinate file %s every %i steps" %(out_nowater,netcdffreq))
#toptraj = mdtraj.load(molecTopology)
#top = toptraj.top
top = mdtraj.Topology.from_openmm(simulation.topology)
sel = [atom.index for residue in top.residues for atom in residue.atoms if (residue.name!="SOL") and (residue.name!="HOH")]
simulation.reporters.append(mdtraj.reporters.NetCDFReporter(out_nowater, netcdffreq, atomSubset = sel))
'''
if args.dcd_report_interval > 0:
mdparse.bak(out_dcd)
logger.info("dcd Reporter will write to %s every %i steps" %
(out_dcd, dcdfreq))
simulation.reporters.append(
mdtraj.reporters.DCDReporter(out_dcd, dcdfreq))
'''
mdparse.bak(out_nowater_dcd)
logger.info("dcd Reporter will write a no-water coordinate file %s every %i steps" %(out_nowater_dcd, dcdfreq))
#toptraj = mdtraj.load(molecTopology)
#top = toptraj.top
top = mdtraj.Topology.from_openmm(simulation.topology)
sel = [atom.index for residue in top.residues for atom in residue.atoms if (residue.name!="SOL") and (residue.name!="HOH")]
simulation.reporters.append(mdtraj.reporters.DCDReporter(out_nowater_dcd, dcdfreq, atomSubset = sel))
#write out a nowater.pdb as topology input
top2 = top.subset(sel)
xyz0 = np.zeros([len(sel),3])
traj2 = mdtraj.Trajectory(xyz0,topology=top2)
traj2.save('output_nowater_top.pdb')
top2omm = top2.to_openmm()
'''
if args.checkpoint_interval > 0:
simulation.reporters.append(
app.CheckpointReporter(checkpointchk, checkfreq))
#simulation.reporters.append(app.DCDReporter(out_dcd, writefreq))
#simulation.reporters.append(mdtraj.reporters.HDF5Reporter(out_hdf5, writefreq, velocities=True))
#============================#
#| Finally Run! |#
#============================#
t1 = time.time()
if progressreport:
Prog.t00 = t1
#simulation.step(args.production)
for iblock in range(0, nblocks):
logger.info("Starting block {}".format(iblock))
start = time.time()
simulation.step(blocksteps)
end = time.time()
logger.info('Took {} seconds for block {}'.format(end - start, iblock))
simulation.saveState(checkpointxml)
positions = simulation.context.getState(
getPositions=True, enforcePeriodicBox=True).getPositions()
app.PDBFile.writeFile(simulation.topology, positions,
open(checkpointpdb, 'w'))
def run_openmm_simulation(sim, n_steps=500000):
sim.minimizeEnergy(maxIterations=50000)
sim.step(n_steps)
pdbreporter = app.PDBReporter('final_frame.pdb', 1)
pdbreporter.report(sim, sim.context.getState(-1))
system.addForce(mm.MonteCarloBarostat(
1 * unit.bar, temperature,
100)) #Apply Monte Carlo Pressure changes in 100 timesteps
integrator = mm.LangevinIntegrator(temperature, 1.0 / unit.picoseconds,
timestep)
integrator.setConstraintTolerance(0.00001)
platform = mm.Platform.getPlatformByName('CPU')
simulation = app.Simulation(ala2_model.topology, system, integrator, platform)
simulation.context.setPositions(ala2_model.positions)
simulation.context.setVelocitiesToTemperature(temperature)
simulation.reporters.append(
app.PDBReporter('ala2_production.pdb', save_frequency))
simulation.reporters.append(
app.StateDataReporter('stateReporter_constantPressure.txt',
1000,
step=True,
totalEnergy=True,
temperature=True,
volume=True,
progress=True,
remainingTime=True,
speed=True,
totalSteps=production_steps,
separator='\t'))
print('Running Production...')
simulation.step(production_steps)
which_water = 'tip3p-fb.xml'
ff = app.ForceField(which_forcefield, which_water)
pdb = app.PDBFile("./%s_fixed.pdb" % code)
output_pdb = "./equil.pdb"
modeller = app.Modeller(pdb.topology, pdb.positions)
modeller.addSolvent(ff, padding=padding, ionicStrength=ionicStrength)
topology = modeller.topology
positions = modeller.positions
system = ff.createSystem(topology,
nonbondedMethod=app.PME,
nonbondedCutoff=cutoff,
constraints=app.HBonds)
integrator = mm.LangevinIntegrator(temperature, friction,
equilibration_timestep)
system.addForce(
mm.MonteCarloBarostat(pressure, temperature, barostat_frequency))
simulation = app.Simulation(topology, system, integrator)
simulation.context.setPositions(positions)
print('Minimizing...')
simulation.minimizeEnergy()
simulation.context.setVelocitiesToTemperature(temperature)
print('Running.')
simulation.reporters.append(app.PDBReporter(output_pdb, n_equil_steps - 1))
simulation.step(n_equil_steps)
"Ekin_Amber(kJ/mol)", "SBM_Q", "Q", "dev"
]) + "\n")
progress_file.write(",".join(
map(str, [
simulation.currentStep, epot_sbm, epot_amber, ekin_sbm, ekin_amber,
sbm_Q,
best_hummer_q(md.load(pdbname), native)[-1], deviation
])) + "\n")
#print ("Step:%i, Epot(SBM/Amber): %s/%s,SBM_Q:%f, Q:%f, dev:%f"%(0,epot_sbm,epot_amber, sbm_Q , best_hummer_q(md.load(pdbname), native), deviation) )
simulation.context.setVelocitiesToTemperature(temperature * unit.kelvin)
if verbose: print('Equilibrating...')
simulation.step(1000)
pdb_reporter = app.PDBReporter(pdbname[:-4] + '_trajectory%s.pdb' % sim_string,
5000)
simulation.reporters.append(pdb_reporter)
simulation.reporters.append(
app.StateDataReporter(pdbname[:-4] + "_data%s.csv" % sim_string,
10000,
step=True,
potentialEnergy=True,
kineticEnergy=True,
temperature=True,
volume=True,
density=True,
progress=True,
remainingTime=True,
speed=True,
totalSteps=20000000,
def main(targetVol, tol=1e-4, paramfile='params.in', overrides={}, quiktest=False, deviceid=None, progressreport=True): #simtime=2.0, T=298.0, NPT=True, LJcut=10.0, tail=True, useLJPME=False, rigidH2O=True, device=0, quiktest=False):
logger.info("This protocol runs NPT until a target volume is achieved, with given tolerance.")
logger.info("Make sure you prescribe pressure and barsostat freq!")
# === PARSE === #
args = mdparse.SimulationOptions(paramfile, overrides)
# === forced parameters special to this protocol === #
args.force_active('cont', val=-1, msg="targetVolume protocol, don't use continue flag")
args.force_active('equilibrate', val=args.nbarostat*5, msg="targetVolume protocol, just minor warmup")
args.force_active('grofile', val="targetVolume.gro", msg="default input gro file with box size for targetVolumeProtocol")
if 'incoord' in overrides:
args.force_active('incoord', val=overrides['incoord'], msg="user-supplied incoord overrides that in parameter file")
if 'pressure' in overrides:
args.force_active('pressure', val=overrides['pressure'], msg="user-supplied pressure overrides that in parameter file")
if 'nbarostat' in overrides:
args.force_active('nbarostat', val=overrides['nbarostat'], msg="user-supplied nbarostat overrides that in parameter file")
if args.pressure <= 0.0:
logger.info("WARNING: parameter file did not have valid pressure, using default 1.0 bar and nbarostat=25")
args.force_active('pressure', val=1.0, msg="Parameter file did not have valid pressure, using default 1.0bar")
args.force_active('nbarostat', val=25, msg="Parameter file did not have valid nbarostat, using default 25")
elif args.nbarostat <= 0:
logger.info("WARNING: parameter file has invalid nbarostat, using default 25")
args.force_active('nbarostat', val=25, msg="Parameter file did not have valid nbarostat, using default 25")
if args.temperature <= 0.0:
logger.info("NPT must have valid thermostat, but temperature not supplied, using default 298K")
args.force_active('nbarostat', val=298.0, msg="NPT needs thermostat, but temperature invalid. using default 298.0K")
args.force_active('use_fs_interval', val=False, msg="target Vol protocol based on nbarostat time step intervals")
args.force_active('report_interval', val=10*args.nbarostat, msg="target Vol protocol based on nbarostat time step intervals")
args.force_active('pdb_report_interval', val=0, msg="don't keep track of pdb")
args.force_active('netcdf_report_interval', val=0, msg="don't keep trajectory")
args.force_active('checkpoint_interval', val=0, msg="don't write .chk files")
args.force_active('block_interval', val=10*args.nbarostat, msg="target Vol protocol based on nbarostat intervals")
args.force_active('nblocks', val = 5e4, msg="cap the number of barostat moves to try")
args.deactivate('outpdb', "not writing pdb trajectory")
args.deactivate('outnetcdf', "not writing netcdf trajectory")
#args.force_active('outnetcdf', val="targetVolume.nc", "target Volume trajectory writes")
args.force_active('logfile', val="targetVolume.log", msg="target Volume protocol log")
args.force_active('chkxml', val="targetVolume.xml", msg="target Volume protocol xml")
args.force_active('chkpdb', val="targetVolume.pdb", msg="target Volume protocol pdb")
# === Files === #
gromacs.GROMACS_TOPDIR = args.topdir
top_file = args.topfile
box_file = args.grofile
defines = {}
cont = args.cont
'''
args.force_active('chkxml',val='chk_{:02n}.xml'.format(cont),msg='first one')
args.force_active('chkpdb',val='chk_{:02n}.pdb'.format(cont),msg='first one')
if cont > 0:
args.force_active('incoord',val='chk_{:02n}.xml'.format(cont-1),msg='continuing')
args.force_active('outpdb',val='output_{:02n}.pdb'.format(cont),msg='continuing')
args.force_active('outnetcdf',val='output_{:02n}.nc'.format(cont),msg='continuing')
args.force_active('logfile',val='thermo.log_{:02n}'.format(cont),msg='continuing')
'''
incoord = args.incoord
out_pdb = args.outpdb
out_netcdf = args.outnetcdf
logfile = args.logfile
checkpointxml = args.chkxml
checkpointpdb = args.chkpdb
checkpointchk = 'chk_{:02n}.chk'.format(cont)
# Parameters
#Temp = args.temperature #K
#Pressure = 1 #bar
#barostatfreq = 25 #time steps
#fric = args.collision_rate #1/ps
dt = args.timestep #fs
if args.use_fs_interval:
reportfreq = int(args.report_interval/dt)
netcdffreq = int(args.netcdf_report_interval/dt) #5e4
pdbfreq = int(args.pdb_report_interval/dt)
checkfreq = int(args.checkpoint_interval/dt)
#simtime = int( simtime ) #nanoseconds; make sure division is whole... no remainders...
blocksteps = int(args.block_interval/dt) #1e6, steps per block of simulation
nblocks = args.nblocks #aiming for 1 block is 1ns
else:
reportfreq = args.report_interval
netcdffreq = args.netcdf_report_interval
pdbfreq = args.pdb_report_interval
checkfreq = args.checkpoint_interval
blocksteps = args.block_interval
nblocks = args.nblocks
if quiktest==True:
reportfreq = 1
blocksteps = 10
nblocks = 2
# === Start Making System === #
top = gromacs.GromacsTopologyFile(top_file, defines=defines)
gro = gromacs.GromacsGroFile.parse(box_file)
top.box = gro.box
constr = {None: None, "None":None,"HBonds":app.HBonds,"HAngles":app.HAngles,"AllBonds":app.AllBonds}[args.constraints]
system = top.createSystem(nonbondedMethod=app.PME, ewaldErrorTolerance = args.ewald_error_tolerance,
nonbondedCutoff=args.nonbonded_cutoff*u.nanometers,
rigidWater = args.rigid_water, constraints = constr)
nbm = {"NoCutoff":mm.NonbondedForce.NoCutoff, "CutoffNonPeriodic":mm.NonbondedForce.CutoffNonPeriodic,
"Ewald":mm.NonbondedForce.Ewald, "PME":mm.NonbondedForce.PME, "LJPME":mm.NonbondedForce.LJPME}[args.nonbonded_method]
ftmp = [f for ii, f in enumerate(system.getForces()) if isinstance(f,mm.NonbondedForce)]
fnb = ftmp[0]
fnb.setNonbondedMethod(nbm)
logger.info("Nonbonded method ({},{})".format(args.nonbonded_method, fnb.getNonbondedMethod()) )
if (not args.dispersion_correction) or (args.nonbonded_method=="LJPME"):
logger.info("Turning off tail correction...")
fnb.setUseDispersionCorrection(False)
logger.info("Check dispersion flag: {}".format(fnb.getUseDispersionCorrection()) )
# === Integrator, Barostat, Additional Constraints === #
integrator = set_thermo(system,args)
if not hasattr(args,'constraints') or (str(args.constraints) == "None" and args.rigidwater == False):
args.deactivate('constraint_tolerance',"There are no constraints in this system")
else:
logger.info("Setting constraint tolerance to %.3e" % args.constraint_tolerance)
integrator.setConstraintTolerance(args.constraint_tolerance)
# === Make Platform === #
logger.info("Setting Platform to %s" % str(args.platform))
try:
platform = mm.Platform.getPlatformByName(args.platform)
except:
logger.info("Warning: %s platform not found, going to Reference platform \x1b[91m(slow)\x1b[0m" % args.platform)
args.force_active('platform',"Reference","The %s platform was not found." % args.platform)
platform = mm.Platform.getPlatformByName("Reference")
if deviceid is not None or deviceid>=0:
args.force_active('device',deviceid,msg="Using cmdline-input deviceid")
if 'device' in args.ActiveOptions and (platform.getName()=="OpenCL" or platform.getName()=="CUDA"):
device = str(args.device)
# The device may be set using an environment variable or the input file.
#if 'CUDA_DEVICE' in os.environ.keys(): #os.environ.has_key('CUDA_DEVICE'):
# device = os.environ.get('CUDA_DEVICE',str(args.device))
#elif 'CUDA_DEVICE_INDEX' in os.environ.keys(): #os.environ.has_key('CUDA_DEVICE_INDEX'):
# device = os.environ.get('CUDA_DEVICE_INDEX',str(args.device))
#else:
# device = str(args.device)
if device != None:
logger.info("Setting Device to %s" % str(device))
#platform.setPropertyDefaultValue("CudaDevice", device)
platform.setPropertyDefaultValue("CudaDeviceIndex", device)
#platform.setPropertyDefaultValue("OpenCLDeviceIndex", device)
else:
logger.info("Using the default (fastest) device")
else:
logger.info("Using the default (fastest) device, or not using CUDA nor OpenCL")
if "CudaPrecision" in platform.getPropertyNames() and (platform.getName()=="OpenCL" or platform.getName()=="CUDA"):
platform.setPropertyDefaultValue("CudaPrecision", args.cuda_precision)
else:
logger.info("Not setting precision")
args.deactivate("cuda_precision",msg="Platform does not support setting cuda_precision.")
# === Create Simulation === #
logger.info("Creating the Simulation object")
# Get the number of forces and set each force to a different force group number.
nfrc = system.getNumForces()
if args.integrator != 'mtsvvvr':
for i in range(nfrc):
system.getForce(i).setForceGroup(i)
'''
for i in range(nfrc):
# Set vdW switching function manually.
f = system.getForce(i)
if f.__class__.__name__ == 'NonbondedForce':
if 'vdw_switch' in args.ActiveOptions and args.vdw_switch:
f.setUseSwitchingFunction(True)
f.setSwitchingDistance(args.switch_distance)
'''
#create simulation object
if args.platform != None:
simulation = app.Simulation(top.topology, system, integrator, platform)
else:
simulation = app.Simulation(top.topology, system, integrator)
#print platform we're using
mdparse.printcool_dictionary({i:simulation.context.getPlatform().getPropertyValue(simulation.context,i) for i in simulation.context.getPlatform().getPropertyNames()},title="Platform %s has properties:" % simulation.context.getPlatform().getName())
# Print out some more information about the system
logger.info("--== System Information ==--")
logger.info("Number of particles : %i" % simulation.context.getSystem().getNumParticles())
logger.info("Number of constraints : %i" % simulation.context.getSystem().getNumConstraints())
for f in simulation.context.getSystem().getForces():
if f.__class__.__name__ == 'NonbondedForce':
method_names = ["NoCutoff", "CutoffNonPeriodic", "CutoffPeriodic", "Ewald", "PME", "LJPME"]
logger.info("Nonbonded method : %s" % method_names[f.getNonbondedMethod()])
logger.info("Number of particles : %i" % f.getNumParticles())
logger.info("Number of exceptions : %i" % f.getNumExceptions())
if f.getNonbondedMethod() > 0:
logger.info("Nonbonded cutoff : %.3f nm" % (f.getCutoffDistance() / u.nanometer))
if f.getNonbondedMethod() >= 3:
logger.info("Ewald error tolerance : %.3e" % (f.getEwaldErrorTolerance()))
logger.info("LJ switching function : %i" % f.getUseSwitchingFunction())
if f.getUseSwitchingFunction():
logger.info("LJ switching distance : %.3f nm" % (f.getSwitchingDistance() / u.nanometer))
# Print the sample input file here.
for line in args.record():
print(line)
#============================#
#| Initialize & Eq/Warm-Up |#
#============================#
p = simulation.context.getPlatform()
if p.getName()=="CUDA" or p.getName()=="OpenCL":
print("simulation platform: {}".format(p.getName()) )
print(p.getPropertyNames())
print(p.getPropertyValue(simulation.context,'DeviceName'))
print("Device Index: {}".format(p.getPropertyValue(simulation.context,'DeviceIndex')))
if os.path.exists(args.restart_filename) and args.read_restart:
print("Restarting simulation from the restart file.")
print("Currently is filler")
else:
# Set initial positions.
if incoord.split(".")[1]=="pdb":
pdb = pmd.load_file(incoord)
simulation.context.setPositions(pdb.positions)
elif incoord.split(".")[1]=="xml":
simulation.loadState(incoord)
else:
logger.info("Error, can't handle input coordinate filetype")
simulation.context.applyConstraints(args.constraint_tolerance) #applies constraints in current frame.
logger.info("Initial potential energy is: {}".format(simulation.context.getState(getEnergy=True).getPotentialEnergy()) )
if args.integrator != 'mtsvvvr':
eda = mdparse.EnergyDecomposition(simulation)
eda_kcal = OrderedDict([(i, "%10.4f" % (j/4.184)) for i, j in eda.items()])
mdparse.printcool_dictionary(eda_kcal, title="Energy Decomposition (kcal/mol)")
# Minimize the energy.
if args.minimize:
logger.info("Minimization start, the energy is:", simulation.context.getState(getEnergy=True).getPotentialEnergy())
simulation.minimizeEnergy()
logger.info("Minimization done, the energy is", simulation.context.getState(getEnergy=True).getPotentialEnergy())
positions = simulation.context.getState(getPositions=True).getPositions()
logger.info("Minimized geometry is written to 'minimized.pdb'")
app.PDBFile.writeModel(simulation.topology, positions, open('minimized.pdb','w'))
# Assign velocities.
if args.gentemp > 0.0:
logger.info("Generating velocities corresponding to Maxwell distribution at %.2f K" % args.gentemp)
simulation.context.setVelocitiesToTemperature(args.gentemp * u.kelvin)
# Equilibrate.
logger.info("--== Equilibrating (%i steps, %.2f ps) ==--" % (args.equilibrate, args.equilibrate * args.timestep * u.femtosecond / u.picosecond))
if args.report_interval > 0:
# Append the ProgressReport for equilibration run.
simulation.reporters.append(mdparse.ProgressReport(args, sys.stdout, args.report_interval, simulation, args.equilibrate))
simulation.reporters[-1].t00 = time.time()
logger.info("Progress will be reported every %i steps" % args.report_interval)
# This command actually does all of the computation.
simulation.step(args.equilibrate)
if args.report_interval > 0:
# Get rid of the ProgressReport because we'll make a new one.
simulation.reporters.pop()
first = args.equilibrate
#============================#
#| Production MD simulation |#
#============================#
logger.info("--== Production (%i blocks, %i steps total, %.2f ps total) ==--" % (nblocks, nblocks*blocksteps, nblocks*blocksteps * args.timestep * u.femtosecond / u.picosecond))
#===========================================#
#| Add reporters for production simulation |#
#===========================================#
print("===== registering reporters and runnning =====")
if args.report_interval > 0:
logger.info("Thermo and Progress will be reported every %i steps" % args.report_interval)
#simulation.reporters.append(ProgressReport(sys.stdout, args.report_interval, simulation, args.production, first))
mdparse.bak(logfile)
simulation.reporters.append(app.StateDataReporter(logfile, reportfreq, step=True,
potentialEnergy=True, kineticEnergy=True, temperature=True, volume=True, density=True, speed=True))
#simulation.reporters.append(app.StateDataReporter(stdout, reportfreq, step=True,
# potentialEnergy=True, kineticEnergy=True, temperature=True, volume=True, density=True, speed=True))
if progressreport:
simulation.reporters.append(mdparse.ProgressReport(args, sys.stdout, reportfreq, simulation, nblocks*blocksteps, first=args.equilibrate))
Prog = simulation.reporters[-1]
if args.pdb_report_interval > 0:
mdparse.bak(out_pdb)
logger.info("PDB Reporter will write to %s every %i steps" % (out_pdb, pdbfreq))
simulation.reporters.append(app.PDBReporter(out_pdb, pdbfreq))
if args.netcdf_report_interval > 0:
mdparse.bak(out_netcdf)
logger.info("netcdf Reporter will write to %s every %i steps" %(out_netcdf, netcdffreq))
simulation.reporters.append(NetCDFReporter(out_netcdf, netcdffreq, crds=True, vels=args.netcdf_vels, frcs=args.netcdf_frcs))
if args.checkpoint_interval > 0:
simulation.reporters.append(app.CheckpointReporter(checkpointchk, checkfreq))
#simulation.reporters.append(app.DCDReporter(out_dcd, writefreq))
#simulation.reporters.append(mdtraj.reporters.HDF5Reporter(out_hdf5, writefreq, velocities=True))
#============================#
#| Finally Run! |#
#============================#
t1 = time.time()
if progressreport:
Prog.t00 = t1
#simulation.step(args.production)
if simulation.topology.getUnitCellDimensions() != None :
box_vectors = simulation.context.getState().getPeriodicBoxVectors()
volume = mdparse.compute_volume(box_vectors) / u.nanometer**3
iblock = 0
err = abs(volume - targetVol)/targetVol
while err > tol and iblock < nblocks:
logger.info("Starting block {}".format(iblock))
start = time.time()
simulation.step(blocksteps)
end = time.time()
logger.info('Took {} seconds for block {}'.format(end-start,iblock))
if simulation.topology.getUnitCellDimensions() != None :
box_vectors = simulation.context.getState().getPeriodicBoxVectors()
volume = mdparse.compute_volume(box_vectors) / u.nanometer**3
print("Volume is {}, targeting {}".format(volume, targetVol))
with open("finalL.txt",'w') as f:
f.write("{}".format(volume**(1.0/3.0)))
err = abs(volume - targetVol)/targetVol
iblock = iblock+1
#avoid frequent writes, only write at the end
simulation.saveState(checkpointxml)
positions = simulation.context.getState(getPositions=True, enforcePeriodicBox=True).getPositions()
app.PDBFile.writeFile(simulation.topology, positions, open(checkpointpdb, 'w'))
#platform = mm.Platform.getPlatformByName('CUDA')
#properties = {'CudaPrecision': 'mixed'}
simulation = app.Simulation(pdb.topology, system, integrator, platform,
properties)
simulation.context.setPositions(pdb.positions)
print('Minimizing...')
simulation.minimizeEnergy()
simulation.context.setVelocitiesToTemperature(300 * unit.kelvin)
print('Equilibrating...')
simulation.step(100)
simulation.reporters.append(app.DCDReporter('trajectory.dcd', 1000))
simulation.reporters.append(app.PDBReporter('trajectory.pdb', 1000))
simulation.reporters.append(
app.StateDataReporter(stdout,
1000,
step=True,
potentialEnergy=True,
kineticEnergy=True,
totalEnergy=True,
temperature=True,
progress=True,
remainingTime=True,
speed=True,
totalSteps=1000,
separator='\t'))
print('Running Production...')
#Outputs progress to command line
simulation.reporters.append(
app.StateDataReporter(sys.stdout,
skipSteps,
step=True,
potentialEnergy=True,
temperature=True,
progress=True,
remainingTime=True,
speed=True,
totalSteps=steps,
separator='\t'))
#Saves trajectory to .pdb file that can be opened in VMD
simulation.reporters.append(app.PDBReporter('trajectory.pdb', skipSteps))
#Saves trajectory file to binary format
simulation.reporters.append(
mdtraj.reporters.HDF5Reporter('water2.h5', skipSteps))
#Performs the simulation
simulation.step(steps)
#Close binary trajectory
simulation.reporters[2].close()
#Read the output file
output_file = mdtraj.formats.HDF5TrajectoryFile('water2.h5')
data = output_file.read()
positions = data.coordinates
potE = data.potentialEnergy
a = md.load(output_name)
a = a.center_coordinates()
a.unitcell_lengths = pbc_lengths
a.unitcell_vectors = pbc_vectors
a.unitcell_angles = pbc_angles
edit_length = a.unitcell_lengths * (2. / 4.)
#edit_length = a.unitcell_lengths
atom_coords = a.xyz
print(atom_coords)
added_length = np.tile(edit_length, (a.n_atoms, 1))
atom_coords = atom_coords + added_length
print(atom_coords)
a.xyz = atom_coords
a.save(output_name)
#model.addSolvent(forcefield, padding=0.4 * u.nanometer)
#system = forcefield.createSystem(model.topology, nonbondedMethod=app.PME, nonbondedCutoff=1.0 * u.nanometers, constraints=app.HAngles)
if 0:
integrator = mm.LangevinIntegrator(temperature, friction, timestep)
simulation = app.Simulation(model.topology, system, integrator)
simulation.context.setPositions(model.positions)
#simulation.minimizeEnergy(tolerance=2.0)
simulation.reporters.append(app.PDBReporter("simulation.pdb", 250))
print("running")
simulation.step(2500)
system = prmtop.createSystem(nonbondedMethod=app.PME, nonbondedCutoff=9*u.angstrom, constraints=app.HBonds, hydrogenMass=None)
# Set the COM Removal to something sensible
for i in range(system.getNumForces()):
if (type(system.getForce(i)) == mm.CMMotionRemover):
system.getForce(i).setFrequency(1000)
applyHarmonicPositionalRestraints(system, 1.0, inpcrd, Chunk_Heavy_Atoms)
applyLigandChunkRestraint(system, 1.0, 10.0, 2*u.angstrom, 3*u.angstrom, 4*u.angstrom, keyInteraction)
simulation = app.Simulation(prmtop.topology, system, integrator, platform, platformProperties)
simulation.context.setPositions(positions)
simulation.reporters.append(app.StateDataReporter("heating.csv", 1000, step=True, time=True, totalEnergy=True, kineticEnergy=True, potentialEnergy=True,
temperature=True, density=True, progress=True, totalSteps=100000, speed=True))
simulation.reporters.append(app.PDBReporter('heating.pdb', 1000))
simulation.step(100000) #
# Save the positions and velocities
positions = simulation.context.getState(getPositions=True).getPositions()
velocities = simulation.context.getState(getVelocities=True).getVelocities()
#clear reporters
simulation.reporters = []
##########################
# Equlibration - density #
##########################
integrator = mm.LangevinIntegrator(temperature, equil_friction, equil_timestep)
system.addForce(
mm.MonteCarloBarostat(pressure, temperature, barostat_frequency))
simulation = app.Simulation(topology, system, integrator, platform=platform)
simulation.context.setPositions(positions)
print('Minimizing...')
simulation.minimizeEnergy()
simulation.context.setVelocitiesToTemperature(temperature)
print('Equilibrating...')
simulation.step(discard_steps) # Don't even save the first XXX ps
simulation.reporters.append(app.DCDReporter(dcd_filename, output_frequency))
simulation.reporters.append(app.PDBReporter(out_pdb_filename, n_steps - 1))
simulation.reporters.append(
app.StateDataReporter(open(log_filename, 'w'),
output_frequency,
step=True,
time=True,
speed=True))
simulation.step(n_steps)
del simulation
del system
t = md.load(dcd_filename, top=out_pdb_filename)
t0 = t[-1]
t0.unitcell_lengths = t.unitcell_lengths.mean(0)
t0.save(out_pdb_filename)
[system, positions, topology
] = [testsystem.system, testsystem.positions, testsystem.topology]
# Get NonbondedForce objects for system copy.
force = _findForces(system, 'NonbondedForce', first_only=True)
# Turn off standard particle interactions.
zero_charge = 0.0 * unit.elementary_charge
unit_sigma = 1.0 * unit.angstroms
zero_epsilon = 0.0 * unit.kilocalories_per_mole
for atom in topology.atoms():
[charge, sigma, epsilon] = force.getParticleParameters(atom.index)
force.setParticleParameters(atom.index, zero_charge, unit_sigma,
zero_epsilon)
timestep = 2.0 * unit.femtoseconds
collision_rate = 5.0 / unit.picoseconds
temperature = 298.0 * unit.kelvin
integrator = openmm.LangevinIntegrator(temperature, collision_rate,
timestep)
niterations = 1000
nsteps = 500
output_filename = 'output.pdb'
simulation = app.Simulation(topology, system, integrator)
simulation.context.setPositions(positions)
simulation.minimizeEnergy(maxIterations=500)
simulation.reporters.append(app.PDBReporter(output_filename, nsteps))
simulation.step(niterations * nsteps)
simulation.context.setPositions(pdbfile.positions)
# Report total system mass
total_mass = 0.0 * unit.amu
for index in range(system.getNumParticles()):
total_mass += system.getParticleMass(index)
print('System mass: %s' % str(total_mass))
# Minimize energy
print('Minimizing energy...')
simulation.minimizeEnergy()
# Append reporters
print('Creating reporters...')
simulation.reporters.append(
app.PDBReporter(output_pdbfile, nsteps_per_snapshot))
simulation.reporters.append(
app.StateDataReporter(density_outfile,
nsteps_per_density,
step=True,
time=True,
speed=True,
density=True,
volume=True,
potentialEnergy=True,
temperature=True))
# Run the simulation
print('Running the simulation for %d steps...' % nsteps)
simulation.step(nsteps)
print("Creating integrator")
integrator = mm.LangevinIntegrator(temp, 1.0 / u.picoseconds, timestep)
print("Creating Simulation")
sim = app.Simulation(top.topology, system, integrator, platform, properties)
print("Setting context")
sim.context.setPositions(top.positions)
sim.reporters.append(
app.StateDataReporter(open('thermo.log', 'a'),
1000,
step=True,
time=True,
potentialEnergy=True,
temperature=True,
volume=True,
speed=True))
sim.reporters.append(app.DCDReporter('trajectory.dcd', 2500))
sim.reporters.append(app.CheckpointReporter('trajectory.chk', 2500))
# Load the checkpoint
#with open('my_checkpoint.chk', 'rb') as f:
# sim.context.loadCheckpoint(f.read())
print("Running MD")
remaining_time = sim_time - sim.context.getState(-1).getTime()
remaining_steps = int(round(remaining_time / timestep))
sim.step(remaining_steps)
pdbreporter = app.PDBReporter('trajectory.pdb', 5000)
pdbreporter.report(sim, sim.context.getState(-1))
def openmm_system(self):
"""Initialise the OpenMM system we will use to evaluate the energies."""
# load the initial coords into the system and initialise
pdb = app.PDBFile(self.pdb)
# count the amount of atoms in the structure
for atom in pdb.topology.atoms():
self.natoms += 1
# must use a custom version of the tip3p water moddel
forcefield = app.ForceField(self.xml, 'tip3p_opls.xml')
self.modeller = app.Modeller(
pdb.topology,
pdb.positions) # set the intial positions from the pdb
# Now we need to solvate the system
self.modeller.addSolvent(forcefield,
model='tip3p',
padding=1 * unit.nanometer)
# write out the solvated system coords
app.PDBFile.writeFile(self.modeller.topology, self.modeller.positions,
open('output.pdb', 'w'))
# now we create the system and add the lj correction
self.system = forcefield.createSystem(self.modeller.topology,
nonbondedMethod=app.PME,
constraints=None,
nonbondedCutoff=1.1 *
unit.nanometer)
if self.opls:
self.opls_lj()
# set control parameters
temperature = 298.15 * unit.kelvin
integrator = mm.LangevinIntegrator(temperature, 5 / unit.picoseconds,
0.001 * unit.picoseconds)
# add preasure to the system
self.system.addForce(
mm.MonteCarloBarostat(1 * unit.bar, 300 * unit.kelvin))
# create the simulation context
self.simulation = app.Simulation(self.modeller.topology, self.system,
integrator)
# set the positions to the solvated system
self.simulation.context.setPositions(self.modeller.positions)
# get the energy of the sytem
print(
self.simulation.context.getState(
getEnergy=True).getPotentialEnergy())
# check the energy break down
struct = pmd.load_file('output.pdb')
ecomps = (pmd.openmm.energy_decomposition_system(struct, self.system))
tot_ene = 0.0
for i in range(0, len(ecomps)):
tot_ene += ecomps[i][1]
print(ecomps[i][0], ecomps[i][1])
print('Total-energy %6.6f' % tot_ene)
# serialize the system
serialized_system = mm.XmlSerializer.serialize(self.system)
outfile = open('test.xml', 'w')
outfile.write(serialized_system)
outfile.close()
# now minimize the system
self.simulation.minimizeEnergy(maxIterations=100)
# now run the simulation
self.simulation.reporters.append(app.PDBReporter('run.pdb', 1000))
self.simulation.reporters.append(
app.StateDataReporter('run.txt',
1000,
step=True,
potentialEnergy=True,
temperature=True))
self.simulation.step(100000)
mass,
Ts, [hc_hb, hc_a, hc_d],
'0.5*Ks*(s_hc - (hc_hb + hc_a + hc_d)/3)^2',
Ks=Ks,
sigma=sigma,
periodic=False)
ufed = ufedmm.UnifiedFreeEnergyDynamics([s_hc], temp, height,
deposition_period)
ufedmm.serialize(ufed, 'ufed_object.yml')
integrator = ufedmm.GeodesicLangevinIntegrator(temp, gamma, dt)
integrator.setRandomNumberSeed(seed)
platform = openmm.Platform.getPlatformByName(args.platform)
simulation = ufed.simulation(pdb.topology, system, integrator, platform)
simulation.context.setPositions(pdb.positions)
simulation.minimizeEnergy(tolerance=0.1 * unit.kilojoules_per_mole)
positions = simulation.context.getState(getPositions=True).getPositions()
app.PDBFile.writeFile(pdb.topology, positions, open('minimized.pdb', 'w'))
simulation.context.setVelocitiesToTemperature(temp, seed)
output = ufedmm.Tee(stdout, 'output.csv')
simulation.reporters += [
ufedmm.StateDataReporter(output,
100,
step=True,
multipleTemperatures=True,
variables=True,
speed=True),
app.PDBReporter('output.pdb', 200)
]
simulation.step(nsteps)
