def main():
print("Reading the PSF file");
# Read the PSF file
psf = app.CharmmPsfFile('g1_25mm.psf');
boxsize = 5 # Boxsize in nm
psf.setBox(boxsize*nanometer, boxsize*nanometer, boxsize*nanometer);
print("Reading the pdb file")
pdb = app.PDBFile('g1_25mm.pdb');
# Load the parameter set
lib = 'toppar/'
#params = app.CharmmParameterSet('toppar/top_all36_cgenff.rtf','toppar/par_all36_cgenff.prm','toppar/cgenff3.0.1/top_all36_cgenff.rtf','toppar/cgenff3.0.1/par_all36_cgenff.prm','g1_new.str','toppar_water_ions.str')
params = app.CharmmParameterSet('toppar/cgenff3.0.1/top_all36_cgenff.rtf','toppar/cgenff3.0.1/par_all36_cgenff.prm','g1_new.str','toppar_water_ions.str')
#platform = openmm.Platform.getPlatformByName('CUDA');
platform = openmm.Platform.getPlatformByName('Reference');
# Creating the system
system = psf.createSystem(params,
nonbondedMethod=app.PME,
nonbondedCutoff=1.2*nanometer,
switchDistance=1.0*nanometer,
ewaldErrorTolerance= 0.0001,
constraints=app.HBonds);
# Thermostat @ 298 K
system.addForce(openmm.AndersenThermostat(298*kelvin, 1/picosecond))
# adding the barostat for now
system.addForce(openmm.MonteCarloBarostat(1*bar, 298*kelvin));
integrator = openmm.VerletIntegrator(0.001*picoseconds)
simulation = app.Simulation(psf.topology, system, integrator, platform)
simulation.context.setPositions(pdb.getPositions())
simulation.minimizeEnergy(maxIterations = 500)
#nsavcrd = 10000 # save coordinates every 10 ps
#nstep = 2000000 # write dcd files every 2 ps
#nprint = 2000 # report every 2 ps
nsavcrd = 10 # save coordinates every 10 ps
nstep = 200 # write dcd files every 2 ps
nprint = 20 # report every 2 ps
firstDcdStep = nsavcrd ;
# Reporters
dcd = app.DCDReporter('g1_new.dcd', nsavcrd)
dcd._dcd = app.DCDFile(dcd._out, simulation.topology, simulation.integrator.getStepSize(), firstDcdStep, nsavcrd)
simulation.reporters.append(dcd)
simulation.reporters.append(app.StateDataReporter('g1_new.out', nprint, step=True, kineticEnergy=True, potentialEnergy=True, totalEnergy=True, temperature=True, volume=True, speed=True))
simulation.step(nstep)
simulation.reporters.pop()
simulation.reporters.pop()
dcd._out.close()
def main():
print("Reading the PSF file");
# Read the PSF file
psf = app.CharmmPsfFile('holo_neutr.psf');
boxsize = 4.895883 # Boxsize in nm
psf.setBox(boxsize*nanometer, boxsize*nanometer, boxsize*nanometer);
print("Reading the pdb file")
pdb = app.PDBFile('holo_neutr.pdb')
# Load the parameter set
lib = 'toppar/'
params = app.CharmmParameterSet(
'toppar/cgenff3.0.1/top_all36_cgenff.rtf',
'toppar/cgenff3.0.1/par_all36_cgenff.prm',
'g1_new.str','oah_groups.str',
'toppar_water_ions.str'
)
platform = openmm.Platform.getPlatformByName('CUDA');
#isPeriodic = False
#isShortSim = False
isShortSim = True
isPeriodic = False
#if not isPeriodic :
# isShortSim = True;
# Creating the system
if (isPeriodic) :
system = psf.createSystem(params,
nonbondedMethod=app.PME,
nonbondedCutoff=1.2*nanometer,
switchDistance=1.0*nanometer,
ewaldErrorTolerance= 0.0001,
constraints=app.HBonds
);
else :
system = psf.createSystem(params,
# nonbondedMethod=app.PME,
nonbondedCutoff=1.2*nanometer,
switchDistance=1.0*nanometer,
ewaldErrorTolerance= 0.0001,
constraints=app.HBonds
);
#Retrieve the nonbonded force
forces = { force.__class__.__name__ : for force in system.getForces()}:
nbforce = forces['NonbondedForce']
def equilibrateSystem(pdbfile, psffile, outpdb, numsteps=30000, minimplatform='CPU', equilplatform='CUDA', device=0,
temp=300, minimize=500000, minimizetol=100, charmmfolder=None):
pdb = Molecule(pdbfile)
watcoo = pdb.get('coords', 'water')
celld = unit.Quantity((watcoo.max(axis=0) - watcoo.min(axis=0)).squeeze(), unit=unit.angstrom)
psf = app.CharmmPsfFile(psffile)
pdb = app.PDBFile(pdbfile)
psf.setBox(celld[0], celld[1], celld[2])
params = readCharmmParameters(charmmfolder, defaultCharmmFiles)
system = psf.createSystem(params, nonbondedMethod=app.PME,
nonbondedCutoff=1*unit.nanometer,
constraints=app.HBonds)
system.addForce(mm.MonteCarloBarostat(1*unit.atmospheres, temp*unit.kelvin, 25))
platform, prop = getPlatform(minimplatform, device)
integrator = mm.LangevinIntegrator(temp*unit.kelvin, 1/unit.picosecond, 0.002*unit.picoseconds)
simulation = app.Simulation(psf.topology, system, integrator, platform, prop)
simulation.context.setPositions(pdb.positions)
# Perform minimization
printEnergies(simulation, 'Energy before minimization')
simulation.minimizeEnergy(tolerance=minimizetol*unit.kilojoule/unit.mole, maxIterations=minimize)
printEnergies(simulation, 'Energy after minimization')
# Copy coordinates from miminization context to equilibration context
state = simulation.context.getState(getPositions=True)
pos = state.getPositions()
# Set up the equilibration simulation
platform, prop = getPlatform(equilplatform, device)
integrator = mm.LangevinIntegrator(temp*unit.kelvin, 1/unit.picosecond, 0.002*unit.picoseconds)
simulation = app.Simulation(psf.topology, system, integrator, platform, prop)
simulation.context.setPositions(pos)
# Generate initial velocities
simulation.context.setVelocitiesToTemperature(temp)
from htmd.membranebuilder.pdbreporter import PDBReporter
from htmd.membranebuilder.dcdreporter import DCDReporter
simulation.reporters.append(PDBReporter(outpdb, numsteps, enforcePeriodicBox=False))
simulation.reporters.append(app.StateDataReporter(stdout, int(numsteps/10), step=True,
potentialEnergy=True, kineticEnergy=True, totalEnergy=True, temperature=True,
progress=True, speed=True, remainingTime=True, totalSteps=numsteps, separator='\t'))
simulation.step(numsteps)
def _load_charmm_structure(inp):
# Load Structure
psffile = app.CharmmPsfFile(inp.topology)
pdbfile = app.PDBFile(inp.coordinates)
params = _read_charmm_params(inp.param_file)
# Determine dimensions in z
coords = pdbfile.positions
min_crds = coords[0][2] / unit.nanometer
max_crds = coords[0][2] / unit.nanometer
for coord in coords:
min_crds = min(min_crds, coord[2] / unit.nanometer)
max_crds = max(max_crds, coord[2] / unit.nanometer)
box_length_z = max_crds - min_crds
# Set PBC box
psffile.setBox(
inp.Box_xlen * unit.angstrom,
inp.Box_ylen * unit.angstrom,
box_length_z * unit.nanometer,
)
return psffile, pdbfile, params
# output paths
json_top_filename = "sEH_TPPU_system.top.json"
omm_state_filename = "initial_openmm_state.pkl"
# normalize the paths
charmm_psf_path = osp.join(inputs_dir, charmm_psf_filename)
pdb_path = osp.join(inputs_dir, starting_coords_pdb)
charmm_param_paths = [osp.join(inputs_dir, filename) for filename
in charmm_param_files]
json_top_path = osp.join(inputs_dir, json_top_filename)
omm_state_path = osp.join(inputs_dir, omm_state_filename)
# load the charmm file for the topology
psf = omma.CharmmPsfFile(charmm_psf_path)
# load the coordinates
pdb = mdj.load_pdb(pdb_path)
# convert the mdtraj topology to a json one
top_str = mdtraj_to_json_topology(pdb.topology)
# write the JSON topology out
with open(json_top_path, mode='w') as json_wf:
json_wf.write(top_str)
# to use charmm forcefields get your parameters
params = omma.CharmmParameterSet(*charmm_param_paths)
def compare_energies(system_name,
pdb_filename,
psf_filename,
ffxml_filenames,
toppar_filenames,
box_vectors_filename=None,
system_kwargs=None,
tolerance=1e-5,
units=u.kilojoules_per_mole,
write_serialized_xml=False):
"""
Compare energies between (pdb, psf, toppar) loaded via ParmEd and (pdb, ffxml) loaded by OpenMM ForceField
Parameters
----------
system_name : str
Name of the test system
pdb_filename : str
Name of PDB file that should contain CRYST entry and PDB format compliant CONECT records for HETATM residues.
psf_filename : str
CHARMM PSF file
ffxml_filenames : list of str
List of OpenMM ffxml files
toppar_filenames : list of CHARMM toppar filenames to load into CharmmParameterSet
List of CHARMM toppar files
box_vectors_filename : str, optional, default=None
If specified, read box vectors from a file like step2.1_waterbox.prm
system_kwargs : dict, optional, default=None
Keyword arguments to pass to CharmmPsfFile.createSystem() and ForceField.CreateSystem() when constructing System objects for energy comparison
tolerance : float, optional, default=1e-5
Relative energy discrepancy tolerance
units : simtk.unit.Unit
Unit to use for energy comparison
write_serialized_xml : bool, optional, default=False
If True, will write out serialized System XML files for OpenMM systems to aid debugging.
"""
is_periodic = False
if (system_kwargs is not None) and ('nonbondedMethod'
in system_kwargs) and (
system_kwargs['nonbondedMethod']
in [app.CutoffPeriodic, app.PME]):
is_periodic = True
# Load PDB file
pdbfile = app.PDBFile(pdb_filename)
# Read box vectors
if box_vectors_filename:
box_vectors = read_box_vectors(box_vectors_filename)
pdbfile.topology.setPeriodicBoxVectors(box_vectors)
else:
box_vectors = pdbfile.topology.getPeriodicBoxVectors()
# Load CHARMM system through OpenMM
openmm_toppar = app.CharmmParameterSet(*toppar_filenames)
openmm_psf = app.CharmmPsfFile(psf_filename)
# Set box vectors
if is_periodic:
openmm_psf.setBox(box_vectors[0][0], box_vectors[1][1],
box_vectors[2][2])
openmm_system = openmm_psf.createSystem(openmm_toppar, **system_kwargs)
openmm_structure = openmm.load_topology(openmm_psf.topology,
openmm_system,
xyz=pdbfile.positions)
#openmm_energies = openmm.energy_decomposition_system(openmm_structure, openmm_system, nrg=units)
#print('OpenMM CHARMM loader energy components : %s' % str(openmm_energies))
openmm_total_energy = compute_potential(openmm_system,
pdbfile.positions) / units
# Load CHARMM system through ParmEd
parmed_toppar = CharmmParameterSet(*toppar_filenames)
parmed_structure = CharmmPsfFile(psf_filename)
#structure.load_parameters(toppar)
parmed_structure.positions = pdbfile.positions
# Set box vectors
if is_periodic:
parmed_structure.box = (box_vectors[0][0] / u.angstroms,
box_vectors[1][1] / u.angstroms,
box_vectors[2][2] / u.angstroms, 90, 90, 90)
parmed_system = parmed_structure.createSystem(parmed_toppar,
**system_kwargs)
#parmed_energies = openmm.energy_decomposition_system(parmed_structure, parmed_system, nrg=units)
#print('ParmEd CHARMM loader energy components : %s' % str(parmed_energies))
parmed_total_energy = compute_potential(parmed_system,
pdbfile.positions) / units
# Delete H-H bonds from waters and retreive updated topology and positions
modeller = app.Modeller(openmm_psf.topology, pdbfile.positions)
hhbonds = [
b for b in modeller.topology.bonds()
if b[0].element == app.element.hydrogen
and b[1].element == app.element.hydrogen
]
modeller.delete(hhbonds)
ffxml_topology = modeller.topology
# OpenMM system with ffxml
ff = app.ForceField(*ffxml_filenames)
ffxml_system = ff.createSystem(ffxml_topology, **system_kwargs)
ffxml_structure = openmm.load_topology(ffxml_topology,
ffxml_system,
xyz=pdbfile.positions)
#ffxml_energies = openmm.energy_decomposition_system(ffxml_structure, ffxml_system, nrg=units)
#print('ffxml energy components : %s' % str(ffxml_energies))
ffxml_total_energy = compute_potential(ffxml_system,
pdbfile.positions) / units
write_serialized_xml = True # DEBUG
if write_serialized_xml:
print('Writing serialized XML files...')
write_serialized_system(system_name + '.charmm.system.xml',
openmm_system)
write_serialized_system(system_name + '.parmed.system.xml',
parmed_system)
write_serialized_system(system_name + '.openmm.system.xml',
ffxml_system)
print('-' * 100)
print('')
print('OpenMM CHARMM reader total energy: %14.3f' % openmm_total_energy)
print('ParmEd CHARMM reader total energy: %14.3f' % parmed_total_energy)
print('OPENMM ffxml total energy: %14.3f' % ffxml_total_energy)
print('TOTAL ERROR: %14.3f' %
(ffxml_total_energy - openmm_total_energy))
print('')
print('-' * 100)
# TODO : Automate comparison
return
# calc rel energies and assert
rel_energies = []
for i, j in zip(ffxml_energies, parmed_energies):
if i[0] != j[0]:
raise Exception('Mismatch in energy tuples naming.')
if abs(i[1]) > NEARLYZERO:
rel_energies.append((i[0], abs((i[1] - j[1]) / i[1])))
else:
if abs(j[1]) > NEARLYZERO:
raise AssertionError(
'One of the CHARMM %s energies (%s) for %s is zero, '
'while the corresponding OpenMM energy is non-zero' %
(system_name, i[0], ffxml))
rel_energies.append((i[0], 0))
dihedrals_done = False
for i in rel_energies:
if i[0] != 'PeriodicTorsionForce':
if i[1] > tolerance:
raise AssertionError(
'%s energies (%s, %f) outside of allowed tolerance (%f) for %s'
% (system_name, i[0], i[1], tolerance, ffxml))
else:
if not dihedrals_done:
if i[1] > tolerance:
raise AssertionError(
'%s energies (%s, %f) outside of allowed tolerance (%f) for %s'
% (system_name, i[0], i[1], tolerance, ffxml))
dihedrals_done = True
else: #impropers
if i[1] > improper_tolerance:
raise AssertionError(
'%s energies (%s-impropers, %f) outside of allowed tolerance (%f) for %s'
% (system_name, i[0], i[1], improper_tolerance, ffxml))
# logging
if not no_log:
charmm_energies_log = dict()
omm_energies_log = dict()
rel_energies_log = dict()
charmm_energies_log['ffxml_name'] = ffxml
charmm_energies_log['test_system'] = system_name
charmm_energies_log['data_type'] = 'CHARMM'
charmm_energies_log['units'] = units
omm_energies_log['ffxml_name'] = ffxml
omm_energies_log['test_system'] = system_name
omm_energies_log['data_type'] = 'OpenMM'
omm_energies_log['units'] = units
rel_energies_log['ffxml_name'] = ffxml
rel_energies_log['test_system'] = system_name
rel_energies_log['data_type'] = 'abs((CHARMM-OpenMM)/CHARMM)'
dihedrals_done = False
for item in amber_energies:
if item[0] == 'PeriodicTorsionForce' and not dihedrals_done:
charmm_energies_log['PeriodicTorsionForce_dihedrals'] = item[1]
dihedrals_done = True
elif item[0] == 'PeriodicTorsionForce' and dihedrals_done:
charmm_energies_log['PeriodicTorsionForce_impropers'] = item[1]
elif item[0] == 'CMMotionRemover':
continue
else:
charmm_energies_log[item[0]] = item[1]
dihedrals_done = False
for item in omm_energies:
if item[0] == 'PeriodicTorsionForce' and not dihedrals_done:
omm_energies_log['PeriodicTorsionForce_dihedrals'] = item[1]
dihedrals_done = True
elif item[0] == 'PeriodicTorsionForce' and dihedrals_done:
omm_energies_log['PeriodicTorsionForce_impropers'] = item[1]
elif item[0] == 'CMMotionRemover':
continue
else:
omm_energies_log[item[0]] = item[1]
dihedrals_done = False
for item in rel_energies:
if item[0] == 'PeriodicTorsionForce' and not dihedrals_done:
rel_energies_log['PeriodicTorsionForce_dihedrals'] = item[1]
dihedrals_done = True
elif item[0] == 'PeriodicTorsionForce' and dihedrals_done:
rel_energies_log['PeriodicTorsionForce_impropers'] = item[1]
elif item[0] == 'CMMotionRemover':
continue
else:
rel_energies_log[item[0]] = item[1]
logger.log(charmm_energies_log)
logger.log(omm_energies_log)
logger.log(rel_energies_log)
Therefore, we will prepare our MD molecular system as an OpenMM System.
When we prepare the OpenMM system, we will add a CustomTorsionForce so
that we can add biasing potentials to the system in the following umbrella
sampling.
'''
import simtk.openmm.app as omm_app
import simtk.openmm as omm
import simtk.unit as unit
import math
import os
import numpy as np
from sys import exit
## read psf and pdb file of butane
psf = omm_app.CharmmPsfFile('./data/butane.psf')
pdb = omm_app.PDBFile('./data/butane.pdb')
## read CHARMM force field for butane
params = omm_app.CharmmParameterSet('./data/top_all35_ethers.rtf',
'./data/par_all35_ethers.prm')
## create a OpenMM system based on psf of butane and CHARMM force field
system = psf.createSystem(params, nonbondedMethod=omm_app.NoCutoff)
## add a harmonic biasing potential on butane dihedral to the OpenMM system
bias_torsion = omm.CustomTorsionForce(
"0.5*K*dtheta^2; dtheta = min(diff, 2*Pi-diff); diff = abs(theta - theta0)"
)
bias_torsion.addGlobalParameter("Pi", math.pi)
bias_torsion.addGlobalParameter("K", 1.0)
When we prepare the OpenMM system, we will add two CustomTorsionForces so
that we can add biasing potentials to the system in the following umbrella
sampling.
'''
import simtk.openmm.app as omm_app
import simtk.openmm as omm
import simtk.unit as unit
import math
## read CHARMM force field for proteins
charmm_toppar = omm_app.CharmmParameterSet("./data/top_all36_prot.rtf",
"./data/par_all36_prot.prm")
## read psf and pdb file of dialanine
psf = omm_app.CharmmPsfFile("./output/dialanine.psf")
pdb = omm_app.PDBFile('./data/dialanine.pdb')
## create a OpenMM system based on psf of dialanine and CHARMM force field
system = psf.createSystem(charmm_toppar, nonbondedMethod=omm_app.NoCutoff)
## add harmonic biasing potentials on two dihedrals of dialanine (psi, phi) in the OpenMM system
## for dihedral psi
bias_torsion_psi = omm.CustomTorsionForce(
"0.5*k_psi*dtheta^2; dtheta = min(tmp, 2*pi-tmp); tmp = abs(theta - psi)")
bias_torsion_psi.addGlobalParameter("pi", math.pi)
bias_torsion_psi.addGlobalParameter("k_psi", 1.0)
bias_torsion_psi.addGlobalParameter("psi", 0.0)
## 4, 6, 8, 14 are indices of the atoms of the torsion psi
bias_torsion_psi.addTorsion(4, 6, 8, 14)
for line in lines:
tokens = line.split()
if tokens[1] == 'A':
a = float(tokens[3]) * u.angstroms
if tokens[1] == 'B':
b = float(tokens[3]) * u.angstroms
if tokens[1] == 'C':
c = float(tokens[3]) * u.angstroms
if tokens[1] == 'FFTX':
fftx = int(tokens[3])
if tokens[1] == 'FFTY':
ffty = int(tokens[3])
if tokens[1] == 'FFTZ':
fftz = int(tokens[3])
psf = app.CharmmPsfFile(os.path.join(prefix, 'step3_pbcsetup.psf'))
# Taken from output of CHARMM run
psf.setBox(a, b, c)
crd = app.CharmmCrdFile(os.path.join(prefix, 'step3_pbcsetup.crd'))
params = app.CharmmParameterSet(
os.path.join(prefix, 'toppar/par_all36_prot.prm'),
os.path.join(prefix, 'toppar/par_all36_na.prm'),
os.path.join(prefix, 'toppar/toppar_water_ions.str'))
system = psf.createSystem(params,
nonbondedMethod=app.PME,
nonbondedCutoff=12 * u.angstroms,
switchDistance=10 * u.angstroms)
for force in system.getForces():
if isinstance(force, mm.CustomNonbondedForce):
import simtk.openmm as mm
import simtk.openmm.app as app
from simtk import unit
# input topology, psf, and force field files generated from CHARMM-GUI Solution Builder
print('Parsing system topology')
topology = app.CharmmPsfFile('step3_charmm2omm.psf')
parameters = app.CharmmParameterSet('top_all36_prot.rtf',\
'par_all36_prot.prm' ,'toppar_water_ions.str')
print('Parsing system coordinates')
# for using PBC in OpenMM, we need to make sure that
# the origin of the sytem is at (0,0,0)
# and that the extremum of the system is at (Lx, Ly, Lz)
coord = app.PDBFile('step3_pbcsetup.pdb')
# translate the coordinates, we'll use numpy here.
import numpy as np
xyz = np.array(coord.positions/unit.nanometer)
xyz[:,0] -= np.amin(xyz[:,0])
xyz[:,1] -= np.amin(xyz[:,1])
xyz[:,2] -= np.amin(xyz[:,2])
coord.positions = xyz*unit.nanometer
print('Constructing sytem')
# set periodic box vectors
topology.setBox(7.5*unit.nanometer, 7.5*unit.nanometer, 7.5*unit.nanometer)
# use PME for long-range electrostatics, cutoff for short-range interactions
# constrain H-bonds with RATTLE, constrain water with SETTLE
system = topology.createSystem(parameters, nonbondedMethod=app.PME,
nonbondedCutoff=1.2*unit.nanometers, constraints=app.HBonds, rigidWater=True,
ewaldErrorTolerance=0.0005)
def main():
print("Reading the PSF file")
# Read the PSF file
#psf = app.CharmmPsfFile('g1_25mm.psf');
psf = app.CharmmPsfFile('holo_neutr.psf')
boxsize = 4.895883 # Boxsize in nm
psf.setBox(boxsize * nanometer, boxsize * nanometer, boxsize * nanometer)
print("Reading the pdb file")
#pdb = app.PDBFile('g1_25mm.pdb');
#pdb = app.PDBFile('md_298k_100ns.pdb')
pdb = app.PDBFile('holo_neutr.pdb')
# Load the parameter set
lib = 'toppar/'
#params = app.CharmmParameterSet('toppar/top_all36_cgenff.rtf','toppar/par_all36_cgenff.prm','toppar/cgenff3.0.1/top_all36_cgenff.rtf','toppar/cgenff3.0.1/par_all36_cgenff.prm','g1_new.str','toppar_water_ions.str')
#params = app.CharmmParameterSet('toppar/cgenff3.0.1/top_all36_cgenff.rtf','toppar/cgenff3.0.1/par_all36_cgenff.prm','g1_new.str','toppar_water_ions.str')
params = app.CharmmParameterSet('toppar/cgenff3.0.1/top_all36_cgenff.rtf',
'toppar/cgenff3.0.1/par_all36_cgenff.prm',
'g1_new.str', 'oah_groups.str',
'toppar_water_ions.str')
platform = openmm.Platform.getPlatformByName('CUDA')
isShortSim = False
#isShortSim = True
isPeriodic = True
#isPeriodic = False
#if not isPeriodic :
# isShortSim = True;
# Creating the system
if (isPeriodic):
print("PME is being used")
system = psf.createSystem(params,
nonbondedMethod=app.PME,
nonbondedCutoff=1.2 * nanometer,
switchDistance=1.0 * nanometer,
ewaldErrorTolerance=0.0001,
constraints=app.HBonds)
else:
print("PME is not being used")
system = psf.createSystem(
params,
# nonbondedMethod=app.PME,
nonbondedCutoff=1.2 * nanometer,
switchDistance=1.0 * nanometer,
ewaldErrorTolerance=0.0001,
constraints=app.HBonds)
#for force in system.getForces():
# print(force, force.usesPeriodicBoundaryConditions())
# Thermostat @ 298 K
#system.addForce(openmm.AndersenThermostat(298*kelvin, 1/picosecond))
# adding the barostat for now
#system.addForce(openmm.MonteCarloBarostat(1*bar, 298*kelvin));
# adding positional restriants
if isPeriodic:
force = openmm.CustomExternalForce(
"k*periodicdistance(x, y, z, x0, y0, z0)^2")
else:
force = openmm.CustomExternalForce("k*((x-x0)^2+(y-y0)^2+(z-z0)^2)")
#force = openmm.CustomExternalForce("k*periodicdistance(x, y, z, x0, y0, z0)^2");
force.addGlobalParameter("k", 0.1 * kilocalories_per_mole / angstroms**2)
force.addPerParticleParameter("x0")
force.addPerParticleParameter("y0")
force.addPerParticleParameter("z0")
topology = pdb.getTopology()
positions = pdb.getPositions()
#for atom in topology.atoms():
# print(atom)
host = []
guest = []
for res in topology.residues():
if res.name == 'OAH':
for atom in res.atoms():
host.append(atom.index)
force.addParticle(atom.index, positions[atom.index])
#force.addParticle(atom.index, (0, 0, 0)*nanometers)
if res.name == 'GOA':
for atom in res.atoms():
guest.append(atom.index)
system.addForce(force)
print("Does customExternalForce use periodic boundary condition : ",
force.usesPeriodicBoundaryConditions())
# adding restraint between the host and guest
# this will be inside the umbrella sampling loop
host_guest_centroid_force = openmm.CustomCentroidBondForce(
2, "0.5*k*(distance(g1,g2)-d0)^2")
host_guest_centroid_force.addGlobalParameter(
"k", 10.0 * kilocalories_per_mole / angstroms**2)
#d0_global_parameter_index = force.addGlobalParameter("d0", 2.0*angstroms);
#d0_perBond_parameter_index = force.addPerBondParameter("d0", 2.0*angstroms);
d0_perBond_parameter_index = host_guest_centroid_force.addPerBondParameter(
"d0")
group1 = host_guest_centroid_force.addGroup(host)
group2 = host_guest_centroid_force.addGroup(guest)
host_guest_bond = host_guest_centroid_force.addBond([group1, group2])
host_guest_centroid_force.setBondParameters(host_guest_bond,
[group1, group2],
[20 * angstroms])
system.addForce(host_guest_centroid_force)
#sys.exit(0)
"""
# Restrain along z axis
# adding positional restriants
if isPeriodic :
z_force = openmm.CustomExternalForce("k*periodicdistance(x, x0)^2");
else :
z_force = openmm.CustomExternalForce("k*((x-x0)^2+(y-y0)^2)");
#force = openmm.CustomExternalForce("k*periodicdistance(x, y, z, x0, y0, z0)^2");
z_force.addGlobalParameter("k", 0.1*kilocalories_per_mole/angstroms**2);
z_force.addPerParticleParameter("x0");
z_force.addPerParticleParameter("y0");
for res in topology.residues():
if res.name == 'GOA' :
for atom in res.atoms():
pos = list(positions[atom.index])
print(pos[2])
z_force.addParticle(atom.index, [pos[0], pos[1]])
system.addForce(z_force)
"""
# langevin integrator
integrator = openmm.LangevinIntegrator(
298 * kelvin, # Temperature
1.0 / picoseconds, # Friction coefficient
0.001 * picoseconds # Time step
)
#integrator = openmm.VerletIntegrator(0.001*picoseconds);
simulation = app.Simulation(psf.topology, system, integrator, platform)
simulation.context.setPositions(pdb.getPositions())
#currentState = simulation.context.getState(getPositions=True)
#pdbr = app.PDBReporter("pdbreport.pdb",1);
#pdbr.report(simulation, currentState)
print("Minimizing...")
simulation.minimizeEnergy(maxIterations=2000)
print("Equilibrating...")
simulation.context.setVelocitiesToTemperature(298 * kelvin)
#currentState = simulation.context.getState(getPositions=True)
#pdbr = app.PDBReporter("pdbreport_after_min.pdb",1);
#pdbr.report(simulation, currentState)
#pdbr = app.PDBReporter("pdbreport_after_step1.pdb",1);
nsavcrd = 10000 # save coordinates every 10 ps
nprint = 2000 # report every 2 ps
if isShortSim:
nstep = 20000 # run the simulation for 0.2ns
else:
nstep = 2000000 # run the simulation for 2ns
firstDcdStep = nsavcrd
# Reporters
dcdReportInterval = 10000 # save coordinates every 10 ps
dcd = app.DCDReporter('umb_3.dcd', dcdReportInterval)
dcd._dcd = app.DCDFile(dcd._out, simulation.topology,
simulation.integrator.getStepSize(), firstDcdStep,
nsavcrd)
stateReporter = app.StateDataReporter('umb_3.out',
nprint,
step=True,
kineticEnergy=True,
potentialEnergy=True,
totalEnergy=True,
temperature=True,
volume=True,
speed=True)
simulation.reporters.append(dcd)
simulation.reporters.append(stateReporter)
#simulation.reporters.append(pdbr);
#simulation.reporters.append(app.StateDataReporter('umb.out', nprint, step=True, kineticEnergy=True, potentialEnergy=True, totalEnergy=True, temperature=True, volume=True, speed=True))
# Run the simulation
print("Simulation begins ...")
#simulation.step(1)
#sys.exit(0)
for i in range(15):
print("Simulation for umbrella : ", i)
host_guest_centroid_force.setBondParameters(host_guest_bond,
[group1, group2],
[(5 + 3 * i) * angstroms])
#force.setGlobalParameterDefaultValue(d0_global_parameter_index, (2+i)*angstroms)
host_guest_centroid_force.updateParametersInContext(simulation.context)
print("host guest bond parameters",
host_guest_centroid_force.getBondParameters(host_guest_bond))
#serialized = openmm.XmlSerializer.serialize(simulation.system)
#of = open("serial_sim_"+str(i)+".xml",'w');
#of.write(serialized);
#of.close();
#simulation.saveState("state_"+str(i)+".xml");
simulation.step(nstep)
simulation.reporters.pop()
simulation.reporters.pop()
dcd._out.close()
#!/usr/bin/env python
# coding: utf-8
# imports
import sys
from simtk import openmm, unit
from simtk.openmm import app
import numpy as np
import mdtraj
# load files
psf = app.CharmmPsfFile('init.psf')
pdbfile = app.PDBFile('init.pdb')
params = app.CharmmParameterSet('toppar/top_all36_prot.rtf',
'toppar/par_all36m_prot.prm',
'toppar/toppar_water_ions.str')
positions = pdbfile.getPositions(asNumpy=True)
# system
psf.setBox(39.0 * unit.angstroms, 39.0 * unit.angstroms, 39.0 * unit.angstroms)
system = psf.createSystem(params,
nonbondedMethod=app.PME,
nonbondedCutoff=1.2 * unit.nanometers,
implicitSolvent=None,
constraints=app.HBonds,
rigidWater=True,
verbose=True,
ewaldErrorTolerance=0.0005)
barostat = openmm.MonteCarloBarostat(1.0 * unit.bar, 300.0 * unit.kelvin)
box3 = np.array([0.00, 0.00, lattc])
temp = 298.15
if ftype == 'drude':
dtemp = 1.0
timestep = 0.001
paralib = '/pubhome/qyfu02/lck_drude/run1/drude_toppar_2018_10/'
if ftype == 'c36':
timestep = 0.002
paralib = '/home/qiuzy/paralib/charmm/toppar_c36_jul17/'
# Read PSF File
psf = app.CharmmPsfFile(chfpre + '.psf')
psf.setBox(latta, lattb, lattc, 90.00 * degree, 90.00 * degree, 90.00 * degree)
# crd = app.CharmmCrdFile(chfpre+'.crd')
crd = PDBFile(chfpre + '.pdb')
# Load the parameter set.
if ftype == 'drude':
params = app.CharmmParameterSet(paralib +
'toppar_drude_master_protein_2013f.str')
if ftype == 'c36':
params = app.CharmmParameterSet(paralib + 'top_all36_prot.rtf',
paralib + 'par_all36_prot.prm',
paralib + 'toppar_water_ions.str')
# Instantiate the system
platform = mm.Platform.getPlatformByName('CUDA')
# Jing Huang ([email protected]) from simtk import openmm as mm from simtk.openmm import app from simtk.unit import * from sys import stdout, exit, stderr from subprocess import call start = int(sys.argv[1]) # the number of dcd's to run stop = int(sys.argv[2]) # the number of dcd's to stop jobname = 'csptm.c36m' prefix = '/tmp/' # temporary directory to write dcd # Read the CHARMM PSF file psf = app.CharmmPsfFile('csptm.psf') boxsize = 6.9 # boxsize in nanometer psf.setBox(boxsize * nanometer, boxsize * nanometer, boxsize * nanometer) # Get the coordinates from the CHARMM crd file crd = app.CharmmCrdFile('csptm.crd') # pdb = app.PDBFile('csptm.pdb') # in case a pdb file instead of crd is used # Load the parameter set. lib = 'toppar/' # path of force field topology and parameter files params = app.CharmmParameterSet(lib + 'top_all36_prot.rtf', lib + 'par_all36m_prot.prm', lib + 'toppar_water_ions.str') # params = app.CharmmParameterSet(lib+'top_all36_prot.rtf', lib+'par_all36m_prot.prm', lib+'toppar_n010water_ions.str') # in case alternative water model is used to sample more extended states of IDPs
def init_openmm(self, integrator_params=None, create_system_params=None):
"""
Method that initiates OpenMM by creating
Parameters
----------
integrator_params : dict
Keyword arguments passed to the simtk.openmm.openmm.LangevinIntegrator
create_system_params : dict
Keyword arguments passed to simtk.openmm.app.amberprmtopfile.createSystem
Returns
-------
system : simtk.openmm.openmm.System
OpenMM system created.
"""
from simtk.openmm import XmlSerializer
assert self.topology_format is not None, "No topology format was provided."
assert self.crd_format is not None, "No coordinate format was provided."
if self.topology_format.upper() in ["AMBER", "GROMACS", "CHARMM"]:
assert self.top_file is not None, "Topology format is {} but no topology file was provided.".format(
self.topology_format)
else:
raise NotImplementedError(
"Topology format {} is not known.".format(
self.topology_format))
assert self.crd_file is not None, "create_system flag is True but no crd_file was provided."
if self.platform_name is None:
logging.info("No platform set. Will use reference.")
self.platform_name = "Reference"
else:
assert self.platform_name in [
"Reference", "CPU", "OpenCL", "CUDA"
], """create_system flag is True but no
correct platform was provided."""
# Read topology
if self.topology_format.upper() == "AMBER":
if self.topology is None:
top = app.AmberPrmtopFile(self.top_file)
self.topology = top.topology
elif self.topology_format.upper() == "GROMACS":
if self.topology is None:
top = app.GromacsTopFile(self.top_file)
self.topology = top.topology
elif self.topology_format.upper() == "CHARMM":
if self.topology is None:
top = app.CharmmPsfFile(self.top_file)
self.topology = top.topology
charmm_params = app.CharmmParameterSet('charmm.rtf',
self.charmm_param_file)
else:
raise NotImplementedError(
"Topology format {} is not currently supported.".format(
self.topology_format))
# Read coordinate file
if self.crd_format.upper() == "AMBER":
crd = app.AmberInpcrdFile(self.crd_file)
elif self.crd_format.upper() == "GROMACS":
crd = app.GromacsGroFile(self.crd_file)
elif self.crd_format.upper() == "CHARMM":
crd = app.CharmmCrdFile(self.crd_file)
elif self.crd_format.upper() == "PDB":
crd = app.PDBFile(self.crd_file)
else:
raise NotImplementedError(
"Coordinate format {} is not currently supported.".format(
self.crd_format))
if self.system is None:
if self.xml_file is None:
assert create_system_params is not None, "No settings to create the system were provided."
logging.info("Creating OpenMM System from {} file.".format(
self.topology_format))
if self.topology_format.upper() == "CHARMM":
self.system = top.createSystem(charmm_params,
**create_system_params)
else:
self.system = top.createSystem(**create_system_params)
else:
logging.info("Creating OpenMM System from XML file.")
xml_file = open(self.xml_file)
self.system = XmlSerializer.deserializeSystem(xml_file.read())
xml_file.close()
if self.integrator is None:
assert integrator_params is not None, "No settings to create the integrator were provided."
self.integrator = openmm.LangevinIntegrator(
integrator_params['temperature'],
integrator_params["frictionCoeff"],
integrator_params["stepSize"])
logging.info("Creating OpenMM integrator.")
if self.platform is None:
self.platform = openmm.Platform.getPlatformByName(
self.platform_name)
logging.info("Creating OpenMM platform.")
if self.context is None:
self.context = openmm.Context(self.system, self.integrator,
self.platform)
logging.info("Creating OpenMM Context.")
# Set positions in context
self.context.setPositions(crd.positions)
return self.system
def main(n_runs,
n_cycles,
steps,
n_walkers,
n_workers=1,
debug_prints=False,
seed=None):
## Load objects needed for various purposes
# load a json string of the topology
with open(json_top_path, mode='r') as rf:
sEH_TPPU_system_top_json = rf.read()
# an openmm.State object for setting the initial walkers up
with open(omm_state_path, mode='rb') as rf:
omm_state = pickle.load(rf)
## set up the OpenMM Runner
# load the psf which is needed for making a system in OpenMM with
# CHARMM force fields
psf = omma.CharmmPsfFile(charmm_psf_path)
# set the box size lengths and angles
lengths = [CUBE_LENGTH for i in range(3)]
angles = [CUBE_ANGLE for i in range(3)]
psf.setBox(*lengths, *angles)
# charmm forcefields parameters
params = omma.CharmmParameterSet(*charmm_param_paths)
# create a system using the topology method giving it a topology and
# the method for calculation
system = psf.createSystem(params,
nonbondedMethod=omma.CutoffPeriodic,
nonbondedCutoff=NONBONDED_CUTOFF,
constraints=omma.HBonds)
# make this a constant temperature and pressure simulation at 1.0
# atm, 300 K, with volume move attempts every 50 steps
barostat = omm.MonteCarloBarostat(PRESSURE, TEMPERATURE, VOLUME_MOVE_FREQ)
# add it as a "Force" to the system
system.addForce(barostat)
# make an integrator object that is constant temperature
integrator = omm.LangevinIntegrator(TEMPERATURE, FRICTION_COEFFICIENT,
STEP_SIZE)
# set up the OpenMMRunner with the system
runner = OpenMMRunner(system, psf.topology, integrator, platform=PLATFORM)
# the initial state, which is used as reference for many things
init_state = OpenMMState(omm_state)
## Make the distance Metric
# load the crystal structure coordinates
crystal_traj = mdj.load_pdb(pdb_path)
# get the atoms in the binding site according to the crystal structure
bs_idxs = binding_site_atoms(crystal_traj.top, LIG_RESID,
crystal_traj.xyz[0])
lig_idxs = ligand_idxs(crystal_traj.top, LIG_RESID)
prot_idxs = protein_idxs(crystal_traj.top)
# make the distance metric with the ligand and binding site
# indices for selecting atoms for the image and for doing the
# alignments to only the binding site. All images will be aligned
# to the reference initial state
unb_distance = UnbindingDistance(lig_idxs, bs_idxs, init_state)
## Make the resampler
# make a Wexplore resampler with default parameters and our
# distance metric
resampler = WExploreResampler(distance=unb_distance,
init_state=init_state,
max_n_regions=MAX_N_REGIONS,
max_region_sizes=MAX_REGION_SIZES,
pmin=PMIN,
pmax=PMAX)
## Make the Boundary Conditions
# makes ref_traj and selects lingand_atom and protein atom indices
# instantiate a revo unbindingboudaryconditiobs
ubc = UnbindingBC(cutoff_distance=CUTOFF_DISTANCE,
initial_state=init_state,
topology=crystal_traj.topology,
ligand_idxs=lig_idxs,
receptor_idxs=prot_idxs)
## make the reporters
# WepyHDF5
# make a dictionary of units for adding to the HDF5
# open it in truncate mode first, then switch after first run
hdf5_reporter = WepyHDF5Reporter(
hdf5_path,
mode='w',
# the fields of the State that will be saved in the HDF5 file
save_fields=SAVE_FIELDS,
# the topology in a JSON format
topology=sEH_TPPU_system_top_json,
# the resampler and boundary
# conditions for getting data
# types and shapes for saving
resampler=resampler,
boundary_conditions=ubc,
# the units to save the fields in
units=dict(UNITS),
# sparse (in time) fields
sparse_fields=dict(SPARSE_FIELDS),
# sparse atoms fields
main_rep_idxs=np.concatenate((lig_idxs, prot_idxs)),
all_atoms_rep_freq=ALL_ATOMS_SAVE_FREQ)
dashboard_reporter = WExploreDashboardReporter(
dashboard_path,
mode='w',
step_time=STEP_SIZE.value_in_unit(unit.second),
max_n_regions=resampler.max_n_regions,
max_region_sizes=resampler.max_region_sizes,
bc_cutoff_distance=ubc.cutoff_distance)
setup_reporter = SetupReporter(setup_state_path, mode='w')
restart_reporter = RestartReporter(restart_state_path, mode='w')
reporters = [
hdf5_reporter, dashboard_reporter, setup_reporter, restart_reporter
]
## The work mapper
# we use a mapper that uses GPUs
work_mapper = WorkerMapper(worker_type=OpenMMGPUWorker,
num_workers=n_workers)
## Combine all these parts and setup the simulation manager
# set up parameters for running the simulation
# initial weights
init_weight = 1.0 / n_walkers
# a list of the initial walkers
init_walkers = [
Walker(OpenMMState(omm_state), init_weight) for i in range(n_walkers)
]
# Instantiate a simulation manager
sim_manager = Manager(init_walkers,
runner=runner,
resampler=resampler,
boundary_conditions=ubc,
work_mapper=work_mapper,
reporters=reporters)
### RUN the simulation
for run_idx in range(n_runs):
print("Starting run: {}".format(run_idx))
sim_manager.run_simulation(n_cycles, steps, debug_prints=True)
print("Finished run: {}".format(run_idx))
fftx = int(tokens[3])
if tokens[1] == 'FFTY':
ffty = int(tokens[3])
if tokens[1] == 'FFTZ':
fftz = int(tokens[3])
box_vectors = u.Quantity(np.zeros([3, 3], np.float32), u.angstroms)
box_vectors[0][0] = a
box_vectors[1][1] = b
box_vectors[2][2] = c
# Load positions
#pdb = app.PDBFile(os.path.join(prefix, filename + '.pdb'))
#pdb.topology.setPeriodicBoxVectors(box_vectors)
# Load topology
psf = app.CharmmPsfFile(os.path.join(prefix, filename + '.psf'))
# Taken from output of CHARMM run
psf.setBox(a, b, c)
crd = app.CharmmCrdFile(os.path.join(prefix, filename + '.crd'))
topology, positions = psf.topology, crd.positions
#params = app.CharmmParameterSet(
# os.path.join(prefix, 'toppar/par_all36_prot.prm'),
# os.path.join(prefix, 'toppar/par_all36_na.prm'),
# os.path.join(prefix, 'toppar/toppar_water_ions.str'))
#pdb = app.PDBFile(os.path.join(prefix, filename + '.pdb'))
#topology, positions = pdb.topology, pdb.positions # DEBUG
# Delete H-H bonds from waters and retreive updated topology and positions
modeller = app.Modeller(topology, positions)
hhbonds = [
import simtk.openmm.app as omm_app
import simtk.openmm as omm
import simtk.unit as unit
import math
import os
import numpy as np
from tqdm import tqdm
from sys import exit
## read the OpenMM system of dialanine
with open("./output/system.xml", 'r') as file_handle:
xml = file_handle.read()
system = omm.XmlSerializer.deserialize(xml)
## read psf and pdb file of dialanine
psf = omm_app.CharmmPsfFile("./data/dialanine.psf")
pdb = omm_app.PDBFile('./data/dialanine.pdb')
## setup an OpenMM context
platform = omm.Platform.getPlatformByName('CPU')
T = 298.15 * unit.kelvin
fricCoef = 10 / unit.picoseconds
stepsize = 1 * unit.femtoseconds
integrator = omm.LangevinIntegrator(T, fricCoef, stepsize)
context = omm.Context(system, integrator, platform)
## set force constant for the biasing potential
k_psi = 100
k_phi = 100
context.setParameter("k_psi", k_psi)
context.setParameter("k_phi", k_phi)
def run_omm(options):
inp = Config(options.input)
dt = float(inp.getWithDefault("timestep", 4)) * u.femtosecond
temperature = float(inp.getWithDefault("temperature", 300)) * u.kelvin
thermostattemperature = float(
inp.getWithDefault("thermostattemperature", 300)) * u.kelvin
logPeriod = 1 * u.picosecond
trajectoryPeriod = int(inp.getWithDefault("trajectoryperiod", 25000)) * dt
run_steps = int(inp.run)
basename = "output"
trajectory_file = basename + ".dcd"
if 'PME' in inp and not inp.getboolean('PME'):
nonbondedMethod = app.NoCutoff
else:
nonbondedMethod = app.PME
nonbondedCutoff = float(inp.getWithDefault("cutoff", 9.0)) * u.angstrom
switchDistance = float(inp.getWithDefault("switchdistance",
7.5)) * u.angstrom
frictionCoefficient = float(inp.getWithDefault("thermostatdamping",
0.1)) / u.picosecond
endTime = run_steps * dt
util.check_openmm()
if options.platform is None:
print("Selecting best platform:")
req_platform_name = util.get_best_platform()
else:
print(f"Requesting platform {options.platform}")
req_platform_name = options.platform
req_platform = mm.Platform.getPlatformByName(req_platform_name)
req_properties = {} # {'UseBlockingSync':'true'}
if options.device is not None and 'DeviceIndex' in req_platform.getPropertyNames(
):
print(" Setting DeviceIndex = " + options.device)
req_properties['DeviceIndex'] = options.device
if options.precision is not None and 'Precision' in req_platform.getPropertyNames(
):
print(" Setting Precision = " + options.precision)
req_properties['Precision'] = options.precision
# Same logic as https://software.acellera.com/docs/latest/acemd3/reference.html
if dt > 2 * u.femtosecond:
hydrogenMass = 4 * u.amu
constraints = app.AllBonds
rigidWater = True
elif dt > 0.5 * u.femtosecond:
hydrogenMass = None
constraints = app.HBonds
rigidWater = True
else:
hydrogenMass = None
constraints = None
rigidWater = False
print(f"""
Host: {socket.gethostname()}
Date: {datetime.datetime.now().ctime()}
Timestep: {dt}
Constraints: {constraints}
Rigid water: {rigidWater}
Nonbonded: {nonbondedMethod}
Hydrogen mass repartitioning: {hydrogenMass}
""")
_printPluginInfo()
if 'parmfile' in inp:
print(f"Creating an AMBER system...")
if 'structure' in inp:
print("Warning: 'structure' given but ignored for AMBER")
prmtop = app.AmberPrmtopFile(inp.parmfile)
system = prmtop.createSystem(nonbondedMethod=nonbondedMethod,
nonbondedCutoff=nonbondedCutoff,
switchDistance=switchDistance,
constraints=constraints,
hydrogenMass=hydrogenMass,
rigidWater=rigidWater)
topology = prmtop.topology
else:
print(f"Creating a CHARMM system...")
psf = app.CharmmPsfFile(inp.structure)
params = app.CharmmParameterSet(inp.parameters, permissive=True)
psf.setBox(50. * u.angstrom, 50. * u.angstrom,
50. * u.angstrom) # otherwise
# refuses
# PME
system = psf.createSystem(params,
nonbondedMethod=nonbondedMethod,
nonbondedCutoff=nonbondedCutoff,
switchDistance=switchDistance,
constraints=constraints,
hydrogenMass=hydrogenMass,
rigidWater=rigidWater)
topology = psf.topology
if 'barostat' in inp and inp.getboolean('barostat'):
pressure = float(inp.barostatpressure) * u.bar
print(f"Enabling barostat at {pressure}...")
system.addForce(mm.MonteCarloBarostat(pressure, thermostattemperature))
if 'plumedfile' in inp:
print("Attempting to load PLUMED plugin...")
from openmmplumed import PlumedForce
plines = util.plumed_parser(inp.plumedfile)
system.addForce(PlumedForce(plines))
integrator = mm.LangevinIntegrator(thermostattemperature,
frictionCoefficient, dt)
integrator.setConstraintTolerance(1e-5)
simulation = app.Simulation(topology, system, integrator, req_platform,
req_properties)
ctx = simulation.context
platform = ctx.getPlatform()
print(f"Got platform {platform.getName()} with properties:")
for prop in platform.getPropertyNames():
print(f" {prop}\t\t{platform.getPropertyValue(ctx,prop)}")
print("")
resuming = False
if os.path.exists(checkpoint_file):
with open(checkpoint_file, 'rb') as cf:
ctx.loadCheckpoint(cf.read())
# ctx.loadCheckpoint(str(checkpoint_file))
util.round_state_time(ctx, 10 * dt)
print(f"Successfully loaded {checkpoint_file}, resuming simulation...")
resuming = True
else:
print(
f"File {checkpoint_file} absent, starting simulation from the beginning..."
)
coords = util.get_coords(inp)
ctx.setPositions(coords)
if not resuming:
(boxa, boxb, boxc) = util.get_box_size(inp)
ctx.setPeriodicBoxVectors(boxa, boxb, boxc)
if 'minimize' in inp:
print(f'Minimizing for max {inp.minimize} iterations...')
simulation.minimizeEnergy(maxIterations=int(inp.minimize))
simulation.saveState(f"miniomm_minimized.xml")
else:
if 'binvelocities' in inp:
print(f"Reading velocities from NAMDBin: " + inp.binvelocities)
vels = NAMDBin(inp.binvelocities).getVelocities()
ctx.setVelocities(vels)
else:
print(f"Resetting thermal velocities at {temperature}")
ctx.setVelocitiesToTemperature(temperature)
# -------------------------------------------------------
print("")
inp.printWarnings()
# -------------------------------------------------------
print("")
startTime = ctx.getState().getTime()
startTime_f = startTime.in_units_of(u.nanoseconds).format("%.3f")
endTime_f = endTime.in_units_of(u.nanoseconds).format("%.3f")
remaining_steps = round((endTime - startTime) / dt)
remaining_ns = remaining_steps * dt.value_in_unit(u.nanosecond)
print(
f"Current simulation time is {startTime_f}, running up to {endTime_f}."
)
print(
f"Will run for {remaining_steps} timesteps = {remaining_ns:.3f} ns...")
print("")
log_every = util.every(logPeriod, dt)
save_every = util.every(trajectoryPeriod, dt)
if remaining_steps % save_every != 0:
raise ValueError(
"Remaining steps is not a multiple of trajectoryperiod")
util.add_reporters(simulation, trajectory_file, log_every, save_every,
remaining_steps, resuming, checkpoint_file)
# ----------------------------------------
simulation.saveState(f"miniomm_pre.xml")
# ----------------------------------------
simulation.step(remaining_steps)
# ----------------------------------------
simulation.saveState(f"miniomm_post.xml")
final_state = simulation.context.getState(getPositions=True,
getVelocities=True)
final_coor = final_state.getPositions(asNumpy=True)
NAMDBin(final_coor).write_file(f"{basename}.coor")
final_box = final_state.getPeriodicBoxVectors(asNumpy=True)
write_xsc(f"{basename}.xsc", remaining_steps, final_state.getTime(),
final_box)
# ----------------------------------------
print('Done!')
return
import simtk.openmm.app as omm_app
import simtk.openmm as omm
import simtk.unit as unit
import math
import os
import numpy as np
from tqdm import tqdm
from sys import exit
## read the OpenMM system of butane
with open("./output/system.xml", 'r') as file_handle:
xml = file_handle.read()
system = omm.XmlSerializer.deserialize(xml)
## read psf and pdb file of butane
psf = omm_app.CharmmPsfFile("./data/butane.psf")
pdb = omm_app.PDBFile('./data/butane.pdb')
## setup an OpenMM context
platform = omm.Platform.getPlatformByName('Reference')
T = 298.15 * unit.kelvin
fricCoef = 10 / unit.picoseconds
stepsize = 1 * unit.femtoseconds
integrator = omm.LangevinIntegrator(T, fricCoef, stepsize)
context = omm.Context(system, integrator, platform)
## set equilibrium theta0 for the biasing potential
K = 50
context.setParameter("K", K)
## M centers of dihedral windows are used in umbrella sampling
