def test_water256_periodic(self):
nonbondedMethod = app.PME
expected_energy = -2270.88890
pdb = app.PDBFile("pdb_files/water256_integration_test.pdb")
forcefield = app.ForceField("../mbpol.xml")
nonbondedCutoff = 0.9 * unit.nanometer
if (nonbondedMethod == app.PME):
boxDimension = 19.3996888399961804 / 10.
boxsize = [boxDimension, boxDimension, boxDimension]
pdb.topology.setUnitCellDimensions(boxsize)
system = forcefield.createSystem(pdb.topology,
nonbondedMethod=nonbondedMethod,
nonbondedCutoff=nonbondedCutoff)
integrator = mm.LangevinIntegrator(0.0, 0.1, 0.01)
platform = mm.Platform.getPlatformByName('Reference')
simulation = app.Simulation(pdb.topology, system, integrator, platform)
simulation.context.setPositions(pdb.positions)
simulation.context.computeVirtualSites()
state = simulation.context.getState(getForces=True,
getEnergy=True,
getPositions=True)
potential_energy = state.getPotentialEnergy()
potential_energy.in_units_of(unit.kilocalorie_per_mole)
self.assertTrue(
abs(
potential_energy.in_units_of(unit.kilocalorie_per_mole)._value
- expected_energy) < 20)
def build_engine(self):
"""Builds the OpenMMEngine."""
from simtk.openmm import app
import simtk.openmm as mm
from simtk import unit
kinase = self.kinase
#### SET UP THE OPENMM STUFF #######################################
# taken from builder.openmm.org
forcefield = app.ForceField('amber99sbildn.xml', 'amber99_obc.xml')
system = forcefield.createSystem(app.PDBFile(kinase['pdb']).topology,
nonbondedMethod=app.NoCutoff,
constraints=app.HBonds)
integrator = mm.LangevinIntegrator(300 * unit.kelvin,
1.0 / unit.picoseconds,
2.0 * unit.femtoseconds)
integrator.setConstraintTolerance(0.00001)
#### OPENPATHSAMPLING-SPECIFIC SETUP ###############################
options = {'nsteps_per_frame': 50, 'n_frames_max': 1500}
template = omm_eng.tools.snapshot_from_pdb(kinase['pdb'])
engine = omm_eng.Engine(template=template,
system=system,
integrator=integrator,
options=options)
return engine
def clean_protein(
prot: protein.Protein,
checks: bool = True):
"""Adds missing atoms to Protein instance.
Args:
prot: A `protein.Protein` instance.
checks: A `bool` specifying whether to add additional checks to the cleaning
process.
Returns:
pdb_string: A string of the cleaned protein.
"""
_check_atom_mask_is_ideal(prot)
# Clean pdb.
prot_pdb_string = protein.to_pdb(prot)
pdb_file = io.StringIO(prot_pdb_string)
alterations_info = {}
fixed_pdb = cleanup.fix_pdb(pdb_file, alterations_info)
fixed_pdb_file = io.StringIO(fixed_pdb)
pdb_structure = PdbStructure(fixed_pdb_file)
cleanup.clean_structure(pdb_structure, alterations_info)
logger.info("alterations info: %s", alterations_info)
# Write pdb file of cleaned structure.
as_file = openmm_app.PDBFile(pdb_structure)
pdb_string = _get_pdb_string(as_file.getTopology(), as_file.getPositions())
if checks:
_check_cleaned_atoms(pdb_string, prot_pdb_string)
return pdb_string
def __init__(self, conf):
self.diag = []
self.off_diag = []
self.V = []
for d in conf["diag"]:
pdbname, xmlname = d["topology"], d["parameter"]
self.V.append(d["V"])
ff = app.ForceField(xmlname)
pdb = app.PDBFile(pdbname)
system = ff.createSystem(pdb.topology,
nonbondedMethod=app.NoCutoff,
polarization='mutual',
mutualInducedTargetEpsilon=0.00001,
removeCMMotion=False)
integrator = mm.LangevinIntegrator(195 * unit.kelvin,
1 / unit.picosecond,
0.0005 * unit.picoseconds)
if "platform" in conf:
context = mm.Context(
system, integrator,
mm.Platform.getPlatformByName(conf["platform"].upper()))
else:
context = mm.Context(system, integrator)
self.diag.append(context)
for offd in conf["off_diag"]:
self.off_diag.append(offd)
self.emat = np.zeros((len(self.diag), len(self.diag)))
def build_protein_system(host_pdbfile):
host_ff = app.ForceField("amber99sbildn.xml", "tip3p.xml")
host_pdb = app.PDBFile(host_pdbfile)
modeller = app.Modeller(host_pdb.topology, host_pdb.positions)
host_coords = strip_units(host_pdb.positions)
padding = 1.0
box_lengths = np.amax(host_coords, axis=0) - np.amin(host_coords, axis=0)
box_lengths = box_lengths.value_in_unit_system(unit.md_unit_system)
box_lengths = box_lengths + padding
box = np.eye(3, dtype=np.float64) * box_lengths
modeller.addSolvent(host_ff,
boxSize=np.diag(box) * unit.nanometers,
neutralize=False)
solvated_host_coords = strip_units(modeller.positions)
nha = host_coords.shape[0]
nwa = solvated_host_coords.shape[0] - nha
print("building a protein system with", nha, "protein atoms and", nwa,
"water atoms")
solvated_host_system = host_ff.createSystem(modeller.topology,
nonbondedMethod=app.NoCutoff,
constraints=None,
rigidWater=False)
return solvated_host_system, solvated_host_coords, nwa, nha, box, modeller.topology
def convert_spce_to_cs(file, saveas="newpdb.pdb"):
"""Extract and rename oxygens from all-atom water structure"""
import os
import numpy as np
import simtk.unit as unit
import simtk.openmm as omm
import simtk.openmm.app as app
file = "equil_spc.pdb"
saveas = "justO_spc.pdb"
app.element.solvent = app.element.Element(201, "Solvent", "Sv",
18 * unit.amu)
pdb = app.PDBFile(file)
O_idxs = np.array(
[atm.index for atm in pdb.topology.atoms() if atm.name == "O"])
xyz = np.array(pdb.positions / unit.angstrom)[O_idxs]
positions = unit.Quantity(xyz, unit.angstrom)
n_slv = len(O_idxs)
topology = app.Topology()
chain = topology.addChain()
for i in range(n_slv):
res = topology.addResidue("SLV", chain)
topology.addAtom("CS", app.element.get_by_symbol("Sv"), res)
box_edge = 5.96256971 * unit.nanometer
topology.setUnitCellDimensions(box_edge * omm.Vec3(1, 1, 1))
with open(saveas, "w") as fout:
pdb.writeFile(topology, positions, file=fout)
def test_chemical_environments_matches_OE(self):
"""Test Topology.chemical_environment_matches"""
from simtk.openmm import app
toolkit_wrapper = OpenEyeToolkitWrapper()
pdbfile = app.PDBFile(
get_data_file_path(
'systems/packmol_boxes/cyclohexane_ethanol_0.4_0.6.pdb'))
# toolkit_wrapper = RDKitToolkitWrapper()
molecules = [
Molecule.from_file(get_data_file_path(name))
for name in ('molecules/ethanol.mol2',
'molecules/cyclohexane.mol2')
]
topology = Topology.from_openmm(pdbfile.topology,
unique_molecules=molecules)
# Test for substructure match
matches = topology.chemical_environment_matches(
"[C:1]-[C:2]-[O:3]", toolkit_registry=toolkit_wrapper)
assert len(matches) == 143
assert matches[0].topology_atom_indices == (1728, 1729, 1730)
# Test for whole-molecule match
matches = topology.chemical_environment_matches(
"[H][C:1]([H])([H])-[C:2]([H])([H])-[O:3][H]",
toolkit_registry=toolkit_wrapper)
assert len(
matches
) == 1716 # 143 * 12 (there are 12 possible hydrogen mappings)
assert matches[0].topology_atom_indices == (1728, 1729, 1730)
# Search for a substructure that isn't there
matches = topology.chemical_environment_matches(
"[C][C:1]-[C:2]-[O:3]", toolkit_registry=toolkit_wrapper)
assert len(matches) == 0
def test_residues():
pdb = app.PDBFile(get_test_file_path("ALA_GLY/ALA_GLY.pdb"))
traj = md.load(get_test_file_path("ALA_GLY/ALA_GLY.pdb"))
mol = Molecule(get_test_file_path("ALA_GLY/ALA_GLY.sdf"),
file_format="sdf")
top = OFFBioTop.from_openmm(pdb.topology, unique_molecules=[mol])
top.mdtop = traj.top
assert top.n_topology_atoms == 29
assert top.mdtop.n_residues == 4
assert [r.name for r in top.mdtop.residues] == ["ACE", "ALA", "GLY", "NME"]
ff = ForceField("openff-1.3.0.offxml")
off_sys = Interchange.from_smirnoff(ff, top)
# Assign positions and box vectors in order to run MM
off_sys.positions = pdb.positions
off_sys.box = [4.8, 4.8, 4.8]
# Just ensure that a single-point energy can be obtained without error
get_openmm_energies(off_sys)
assert len(top.mdtop.select("resname ALA")) == 10
assert [*off_sys.topology.mdtop.residues][-1].n_atoms == 6
def addExtraMolecules_PDB(self, system, extra_input_pdb, input_path=None):
if input_path == None:
input_path=self.def_input_struct
total_mols=[]
for idx, pdb_e in enumerate(extra_input_pdb, 1):
path_pdb=f'{self.def_input_struct}/{pdb_e}'
if not os.path.exists(path_pdb):
print(f'\tFile {path_pdb} not found!')
else:
print(f'\tAdding extra PDB file {idx} to pre-system: {path_pdb}')
extra_pdb = app.PDBFile(path_pdb)
try:
system.add(extra_pdb.topology, extra_pdb.positions)
print(f'\t{extra_pdb.topology}')
total_mols.append((idx, path_pdb))
except:
print(f'\tMolecule {idx} ({extra_pdb}) could not be added by openMM')
for mol in total_mols:
print(f'\tAdded {mol[0]}: {mol[1]}')
return system, total_mols
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)
forcefield = app.ForceField(self.xml)
modeller = app.Modeller(pdb.topology, pdb.positions) # set the initial positions from the pdb
self.system = forcefield.createSystem(modeller.topology, nonbondedMethod=app.NoCutoff, constraints=None)
# Check what combination rule we should be using from the xml
xmlstr = open(self.xml).read()
# check if we have opls combination rules if the xml is present
try:
self.combination = ET.fromstring(xmlstr).find('NonbondedForce').attrib['combination']
except AttributeError:
pass
except KeyError:
pass
if self.combination == 'opls':
print('OPLS combination rules found in xml file')
self.opls_lj()
temperature = constants.STP * unit.kelvin
integrator = mm.LangevinIntegrator(temperature, 5 / unit.picoseconds, 0.001 * unit.picoseconds)
self.simulation = app.Simulation(modeller.topology, self.system, integrator)
self.simulation.context.setPositions(modeller.positions)
def test_chemical_environments_matches_RDK(self):
"""Test Topology.chemical_environment_matches"""
from simtk.openmm import app
toolkit_wrapper = RDKitToolkitWrapper()
pdbfile = app.PDBFile(
get_data_file_path(
'systems/packmol_boxes/cyclohexane_ethanol_0.4_0.6.pdb'))
# toolkit_wrapper = RDKitToolkitWrapper()
#molecules = [Molecule.from_file(get_data_file_path(name)) for name in ('molecules/ethanol.mol2',
# 'molecules/cyclohexane.mol2')]
molecules = []
molecules.append(Molecule.from_smiles('CCO'))
molecules.append(Molecule.from_smiles('C1CCCCC1'))
topology = Topology.from_openmm(pdbfile.topology,
unique_molecules=molecules)
# Count CCO matches
matches = topology.chemical_environment_matches(
"[C:1]-[C:2]-[O:3]", toolkit_registry=toolkit_wrapper)
assert len(matches) == 143
assert tuple(i.topology_atom_index
for i in matches[0]) == (1728, 1729, 1730)
matches = topology.chemical_environment_matches(
"[H][C:1]([H])([H])-[C:2]([H])([H])-[O:3][H]",
toolkit_registry=toolkit_wrapper)
assert len(
matches
) == 1716 # 143 * 12 (there are 12 possible hydrogen mappings)
assert tuple(i.topology_atom_index
for i in matches[0]) == (1728, 1729, 1730)
# Search for a substructure that isn't there
matches = topology.chemical_environment_matches(
"[C][C:1]-[C:2]-[O:3]", toolkit_registry=toolkit_wrapper)
assert len(matches) == 0
def create_vdata_txt(pdb_fnm, data):
# check gradient
gradient = data['gradient']
if np.abs(gradient).max() > 1e-3:
print("Warning! Max gradient greater than 1e-3")
# get the openmm list of masses for the molecule, to be consistent with ForceBalance
pdb = app.PDBFile(pdb_fnm)
mass_array = np.array([
a.element.mass.value_in_unit(unit.dalton)
for a in pdb.topology.atoms()
])
# compute mass-weighted hessian
invert_sqrt_mass_array_repeat = 1.0 / np.sqrt(
mass_array.repeat(3)) # repeat for x, y, z coords
hessian = data['hessian']
mass_weighted_hessian = hessian * invert_sqrt_mass_array_repeat[:, np.
newaxis] * invert_sqrt_mass_array_repeat[
np.
newaxis, :]
mass_weighted_hessian *= 937583.07 # convert units from Eh / bohr^2 * dalton to 10^24 s^-2
# perform normal mode analysis
freqs, normal_modes = compute_normal_modes(mass_weighted_hessian)
# write vdata.txt
with open('vdata.txt', 'w') as outfile:
outfile.write(data['molecule'].to_string('xyz') + '\n')
for freq, normol_mode in zip(freqs, normal_modes):
outfile.write(f'{freq}\n')
for nx, ny, nz in normol_mode:
outfile.write(f'{nx:13.4f} {ny:13.4f} {nz:13.4f}\n')
outfile.write('\n')
def get_mixture_tesystem(packmol_boxname, monomers):
"""Retrieve test system information for specified packmol mixed-component box and monomers.
Parameters
----------
packmol_boxname : str
Prefix of PDB file to be retrieved from systems/packmolboxes in test data directory
monomers : list of str
List of monomer names within packmol box
Returns
-------
topology : openforcefield.topology.Topology
Topology for the packmol box
positions : simtk.unit.Quantity with dimension (nparticles,3) with units compatible with angstroms
Positions corresponding to particles in ``topology``
"""
pdbfile = app.PDBFile(get_packmol_pdb_file_path(packmol_boxname))
molecules = [
Molecule.from_file(get_monomer_mol2_file_path(name))
for name in monomers
]
topology = Topology.from_openmm(pdbfile.topology,
unique_molecules=molecules)
positions = pdbfile.positions
return topology, positions
def production(self):
if os.path.exists(self.production_dcd_filename) and os.path.exists(self.production_data_filename):
return
prmtop = app.AmberPrmtopFile(self.prmtop_filename)
pdb = app.PDBFile(self.equil_pdb_filename)
system = prmtop.createSystem(nonbondedMethod=app.PME, nonbondedCutoff=CUTOFF, constraints=app.HBonds)
integrator = mm.LangevinIntegrator(self.temperature, FRICTION, TIMESTEP)
system.addForce(mm.MonteCarloBarostat(PRESSURE, self.temperature, BAROSTAT_FREQUENCY))
simulation = app.Simulation(prmtop.topology, system, integrator)
simulation.context.setPositions(pdb.positions)
simulation.context.setPeriodicBoxVectors(*pdb.topology.getPeriodicBoxVectors())
simulation.context.setVelocitiesToTemperature(self.temperature)
print('Production.')
simulation.reporters.append(app.DCDReporter(self.production_dcd_filename, OUTPUT_FREQUENCY))
simulation.reporters.append(app.StateDataReporter(self.production_data_filename, OUTPUT_DATA_FREQUENCY, step=True, potentialEnergy=True, temperature=True, density=True))
converged = False
while not converged:
simulation.step(N_STEPS)
d = pd.read_csv(self.production_data_filename, names=["step", "U", "Temperature", "Density"], skiprows=1)
density_ts = np.array(d.Density)
[t0, g, Neff] = ts.detectEquilibration(density_ts, nskip=1000)
density_ts = density_ts[t0:]
density_mean_stderr = density_ts.std() / np.sqrt(Neff)
if density_mean_stderr < STD_ERROR_TOLERANCE:
converged = True
def makeLib(file_path, residue_name, connect0=None, connect1=None, charges='bcc', atom_type='gaff', force_field='leaprc.ff12SB', parameterized=False):
name, extension = file_path.split('/')[-1].split(".")
lib_path = '/'.join(file_path.split('/')[:-1]+[residue_name])
tleap_input = """
source %s
source leaprc.gaff
%s = loadmol2 %s.mol2
loadamberparams %s.frcmod"""%(force_field,
residue_name, name,
lib_path)
if connect0 and connect1:
tleap_input += """
set %s head %s.1.%s
set %s tail %s.1.%s
set %s.1 connect0 %s.head
set %s.1 connect1 %s.tail"""%(residue_name, residue_name, connect0,
residue_name, residue_name, connect1,
residue_name, residue_name,
residue_name, residue_name)
tleap_input +="""
check %s
saveoff %s %s.lib
savepdb %s %s_tmp.pdb
quit
"""%(residue_name, residue_name, lib_path, residue_name, lib_path)
if parameterized:
tleap_input = """
source leaprc.gaff
source %s
%s = loadpdb %s.pdb
saveoff %s %s.lib
savepdb %s %s_tmp.pdb
quit
"""%(force_field, residue_name, name, residue_name, lib_path,
residue_name, lib_path)
#Write LEaP infile
with open("%s.in"%name,"w") as fil:
fil.write(tleap_input)
if not parameterized:
#Execute
subprocess.call("antechamber -i %s -fi %s -o %s.mol2 -fo mol2 -c %s -rn %s -at %s"%(file_path,
extension,
name,
charges,
residue_name,
atom_type),
shell=True)
subprocess.call("parmchk -i %s.mol2 -f mol2 -o %s.frcmod"%(name, lib_path), shell=True)
subprocess.call("tleap -f %s.in"%name, shell=True)
PDB = app.PDBFile(lib_path + "_tmp.pdb")
length = sum([1 for atom in PDB.topology.atoms()])
#Cleanup
if not parameterized:
os.remove(name+".mol2")
#os.remove(name+".frcmod")
os.remove("%s.in"%name)
os.remove("%s_tmp.pdb"%(lib_path))
os.remove("leap.log")
return length
def __init__(self, true_value=None, initial_value=None, n_increments=18, rj=True, sample_phase=False,
continuous=False):
self._param = CharmmParameterSet(get_fun('toy.str'))
self._struct = CharmmPsfFile(get_fun('toy.psf'))
self._pdb = app.PDBFile(get_fun('toy.pdb'))
self._topology = md.load_psf(get_fun('toy.psf'))
self.synthetic_energy = units.Quantity()
self._positions = units.Quantity()
self._platform = mm.Platform.getPlatformByName('Reference')
# Replace ('CG331', 'CG321', 'CG321', 'CG331') torsion with true_value
self._dih_type = ('CG331', 'CG321', 'CG321', 'CG331')
original_torsion = self._param.dihedral_types[self._dih_type]
if true_value is not None:
if type(true_value) == DihedralTypeList:
dih_tlist = true_value
elif type(true_value) == DihedralType:
dih_tlist = DihedralTypeList()
dih_tlist.append(true_value)
else:
dih_tlist = self._randomize_dih_param(return_dih=True)
self.true_value = copy.deepcopy(dih_tlist)
self._param.dihedral_types[self._dih_type] = dih_tlist
# parametrize toy
self._struct.load_parameters(self._param, copy_parameters=False)
self._struct.positions = self._pdb.positions
# generate synthetic torsion scan
self._torsion_scan(n_increments=n_increments)
# initialize parameter
if initial_value is not None:
if type(initial_value) == DihedralTypeList:
dih_tlist = initial_value
if type(initial_value) == DihedralType:
dih_tlist = DihedralTypeList()
dih_tlist.append(initial_value)
elif initial_value == 'cgenff':
dih_tlist = original_torsion
else:
dih_tlist = self._randomize_dih_param(return_dih=True)
self.initial_value = copy.deepcopy(dih_tlist)
self._param.dihedral_types[self._dih_type] = dih_tlist
# create torsionfit.TorsionScanSet
torsions = np.zeros((len(self._positions), 4))
torsions[:] = [1, 2, 3, 4]
direction = None
steps = None
self.scan_set = ScanSet.QMDataBase(positions=self._positions.value_in_unit(units.nanometers),
topology=self._topology, structure=self._struct, torsions=torsions,
steps=steps, directions=direction,
qm_energies=self.synthetic_energy.value_in_unit(units.kilojoules_per_mole))
self.model = model.TorsionFitModel(param=self._param, frags=self.scan_set, platform=self._platform,
param_to_opt=[self._dih_type], rj=rj, continuous_phase=continuous,
sample_phase=sample_phase)
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 simulate(pdbcode, pdb_filename):
from simtk.openmm import app
import simtk.openmm as mm
from simtk import unit
from sys import stdout
# Load the PDB file.
pdb = app.PDBFile(pdb_filename)
# Set up implicit solvent forcefield.
#forcefield = app.ForceField('amber99sbildn.xml')
forcefield = app.ForceField('amber10.xml')
# Create the system.
system = forcefield.createSystem(pdb.topology,
nonbondedMethod=app.NoCutoff,
constraints=app.HBonds)
# Create an integrator.
integrator = mm.LangevinIntegrator(300 * unit.kelvin,
91.0 / unit.picoseconds,
1.0 * unit.femtoseconds)
# Create a context.
context = mm.Context(system, integrator)
context.setPositions(pdb.positions)
# Check to make sure energy is finite.
state = context.getState(getEnergy=True)
potential = state.getPotentialEnergy() / unit.kilocalories_per_mole
if numpy.isnan(potential):
raise Exception("Initial energy for %s is NaN." % pdbcode)
# Minimize.
tolerance = 1.0 * unit.kilocalories_per_mole / unit.angstroms
maxIterations = 50
mm.LocalEnergyMinimizer.minimize(context, tolerance, maxIterations)
# Check to make sure energy is finite.
state = context.getState(getEnergy=True)
potential = state.getPotentialEnergy() / unit.kilocalories_per_mole
if numpy.isnan(potential):
raise Exception("Energy for %s is NaN after minimization." % pdbcode)
# Simulate.
nsteps = 500
integrator.step(nsteps)
# Check to make sure energy is finite.
state = context.getState(getEnergy=True)
potential = state.getPotentialEnergy() / unit.kilocalories_per_mole
if numpy.isnan(potential):
raise Exception("Energy for %s is NaN after simulation." % pdbcode)
del context, integrator
print("Simulation completed: potential = %.3f kcal/mol" % potential)
return
def _check_cleaned_atoms(pdb_cleaned_string: str, pdb_ref_string: str):
"""Checks that no atom positions have been altered by cleaning."""
cleaned = openmm_app.PDBFile(io.StringIO(pdb_cleaned_string))
reference = openmm_app.PDBFile(io.StringIO(pdb_ref_string))
cl_xyz = np.array(cleaned.getPositions().value_in_unit(LENGTH))
ref_xyz = np.array(reference.getPositions().value_in_unit(LENGTH))
for ref_res, cl_res in zip(reference.topology.residues(),
cleaned.topology.residues()):
assert ref_res.name == cl_res.name
for rat in ref_res.atoms():
for cat in cl_res.atoms():
if cat.name == rat.name:
if not np.array_equal(cl_xyz[cat.index], ref_xyz[rat.index]):
raise ValueError(f"Coordinates of cleaned atom {cat} do not match "
f"coordinates of reference atom {rat}.")
def _execute(self, directory, available_resources):
from openforcefield.topology import Molecule, Topology
pdb_file = app.PDBFile(self.coordinate_file_path)
force_field_source = ForceFieldSource.from_json(self.force_field_path)
if not isinstance(force_field_source, SmirnoffForceFieldSource):
raise ValueError(
"Only SMIRNOFF force fields are supported by this protocol.")
force_field = force_field_source.to_force_field()
unique_molecules = []
charged_molecules = []
if self.apply_known_charges:
charged_molecules = self._generate_known_charged_molecules()
# Load in any additional, user specified charged molecules.
for charged_molecule_path in self.charged_molecule_paths:
charged_molecule = Molecule.from_file(charged_molecule_path,
"MOL2")
charged_molecules.append(charged_molecule)
for component in self.substance.components:
molecule = Molecule.from_smiles(smiles=component.smiles)
if molecule is None:
raise ValueError(
f"{component} could not be converted to a Molecule")
unique_molecules.append(molecule)
topology = Topology.from_openmm(pdb_file.topology,
unique_molecules=unique_molecules)
if len(charged_molecules) > 0:
system = force_field.create_openmm_system(
topology, charge_from_molecules=charged_molecules)
else:
system = force_field.create_openmm_system(topology)
if system is None:
raise RuntimeError(
"Failed to create a system from the specified topology and molecules."
)
system_xml = openmm.XmlSerializer.serialize(system)
self.system_path = os.path.join(directory, "system.xml")
with open(self.system_path, "w") as file:
file.write(system_xml)
def load_amoeba(hydrogenMass=1.0):
pdb = app.PDBFile("./sandbox/iamoeba.pdb")
forcefield = app.ForceField('iamoeba.xml')
system = forcefield.createSystem(pdb.topology,
nonbondedMethod=app.PME,
nonbondedCutoff=1.0 * u.nanometers,
hydrogenMass=hydrogenMass * u.amu,
rigidWater=False)
return system, pdb.positions
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 convert_input(self):
"""
Converts inputs to OpenMM readable topologies and positions.
Currently supports pdb inputs as well as Amber and Gromacs input files.
"""
if self.system_info_format == 'pdb':
# instantiate OpenMM pdb object
if type(self.system_info) is list:
self.pdb = OM_app.PDBFile(self.system_info[0])
elif type(self.system_info) is str:
self.pdb = OM_app.PDBFile(self.system_info)
# instantiate OpenMM forcefield object
self.forcefield = OM_app.ForceField(self.ff, self.ff_water)
self.topology = self.pdb.topology
self.positions = self.pdb.positions
self.PeriodicBoxVector = self.topology.getPeriodicBoxVectors()
elif self.system_info_format in ['Amber', 'amber']:
for fil in self.system_info:
if fil.endswith('prmtop'):
self.forcefield = OM_app.AmberPrmtopFile(fil)
self.topology = self.forcefield.topology
self.use_pdb = False
if fil.endswith('pdb'):
self.pdb = OM_app.PDBFile(fil)
self.forcefield = OM_app.ForceField(self.ff, self.ff_water)
self.topology = self.pdb.topology
self.use_pdb = True
if fil.endswith('inpcrd'):
self.inpcrd = OM_app.AmberInpcrdFile(fil)
self.positions = self.inpcrd.positions
self.PeriodicBoxVector = self.inpcrd.boxVectors
elif self.system_info_format in ['Gromacs', 'gromacs']:
for fil in self.system_info:
if 'gro' in fil:
self.pdb = OM_app.GromacsGroFile(fil)
for fil in self.system_info:
if 'top' in fil:
self.forcefield = OM_app.GromacsTopFile(
fil,
periodicBoxVectors=self.pdb.getPeriodicBoxVectors())
self.topology = self.forcefield.topology
def testLongTrajectory(self):
"""Test writing a trajectory that has more than 2^31 steps."""
fname = tempfile.mktemp(suffix='.dcd')
pdbfile = app.PDBFile('systems/alanine-dipeptide-implicit.pdb')
natom = len(list(pdbfile.topology.atoms()))
with open(fname, 'wb') as f:
dcd = app.DCDFile(f, pdbfile.topology, 0.001, interval=1000000000)
for i in range(5):
dcd.writeModel([mm.Vec3(random(), random(), random()) for j in range(natom)]*unit.angstroms)
os.remove(fname)
def write_header(self):
"""
Confusingly this initializes writer as well because
"""
outfile = open(self.out_filepath, 'w')
self.outfile = outfile
cpdb = app.PDBFile(self.pdb_str)
PDBFile.writeHeader(cpdb.topology, self.outfile)
self.topology = cpdb.topology
self.frame_idx = 0
def test_dcd(self):
""" Test the DCD file """
fname = tempfile.mktemp(suffix='.dcd')
pdbfile = app.PDBFile('systems/alanine-dipeptide-implicit.pdb')
natom = len(list(pdbfile.topology.atoms()))
with open(fname, 'wb') as f:
dcd = app.DCDFile(f, pdbfile.topology, 0.001)
for i in range(5):
dcd.writeModel([mm.Vec3(random(), random(), random()) for j in range(natom)]*unit.angstroms)
os.remove(fname)
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 load_receptor_pdb(pdb_filename):
"""
Load the receptor by PDB filename.
Parameters
----------
pdb_filename
"""
f = open(pdb_filename, 'r')
pdbfile = app.PDBFile(f)
return pdbfile.topology, pdbfile.positions
def make_xml_explicit_imidazole(
pdb_filename="protons/examples/Ligand example/imidazole.pdb",
ffxml_filename="protons/examples/Ligand example/imidazole.xml",
outfile="imidazole-explicit",
):
"""Solvate an imidazole pdb file and minimize the system"""
temperature = 300.0 * unit.kelvin
pressure = 1.0 * unit.atmospheres
outfile1 = open("{}.sys.xml".format(outfile), "w")
outfile2 = open("{}.state.xml".format(outfile), "w")
gaff = get_data("gaff.xml", "forcefields")
pdb = app.PDBFile(pdb_filename)
forcefield = app.ForceField(gaff, ffxml_filename, "amber99sbildn.xml",
"tip3p.xml")
integrator = openmm.LangevinIntegrator(300 * unit.kelvin,
1.0 / unit.picoseconds,
2.0 * unit.femtoseconds)
integrator.setConstraintTolerance(0.00001)
modeller = app.Modeller(pdb.topology, pdb.positions)
modeller.addSolvent(
forcefield,
boxSize=openmm.Vec3(3.5, 3.5, 3.5) * unit.nanometers,
model="tip3p",
ionicStrength=0.1 * unit.molar,
positiveIon="Na+",
negativeIon="Cl-",
)
system = forcefield.createSystem(
modeller.topology,
nonbondedMethod=app.PME,
nonbondedCutoff=1.0 * unit.nanometers,
constraints=app.HBonds,
rigidWater=True,
ewaldErrorTolerance=0.0005,
)
system.addForce(openmm.MonteCarloBarostat(pressure, temperature))
simulation = app.Simulation(modeller.topology, system, integrator)
simulation.context.setPositions(modeller.positions)
simulation.minimizeEnergy()
outfile1.write(openmm.XmlSerializer.serialize(simulation.system))
positions = simulation.context.getState(getPositions=True)
outfile2.write(openmm.XmlSerializer.serialize(positions))
app.PDBFile.writeFile(
simulation.topology,
modeller.positions,
open("imidazole-solvated-minimized.pdb", "w"),
)
def fix(pdbid, missing_residues, padding=PADDING, mutations=None):
fixer = pdbfixer.PDBFixer(filename="%s.pdb" % pdbid)
if mutations is not None:
fixer.applyMutations(mutations[0], mutations[1])
fixer.missingResidues = missing_residues
fixer.findNonstandardResidues()
fixer.replaceNonstandardResidues()
fixer.removeHeterogens(True)
fixer.findMissingAtoms()
fixer.addMissingAtoms()
fixer.addMissingHydrogens(7.0)
numChains = len(list(fixer.topology.chains()))
fixer.removeChains(range(1, numChains))
file_handle = open("./pdbs/%s_fixed0.pdb" % pdbid, 'wb')
app.PDBFile.writeFile(fixer.topology, fixer.positions, file_handle)
file_handle.close()
traj0 = md.load("./pdbs/%s_fixed0.pdb" % pdbid)
traj = sort_atoms(traj0)
filename1 = "./pdbs/%s_fixed1.pdb" % pdbid
traj.save(filename1)
filename = "./pdbs/%s_fixed.pdb" % pdbid
# Need to sync the protonation state of one histidine
cmd = """grep -v 'HE1 HIS A 119' %s |grep -v 'HE2 HIS A 119'|grep -v 'HD1 HIS A 119'|grep -v 'HD2 HIS A 119' > %s""" % (filename1, filename)
os.system(cmd)
#os.system("grep -v 'HE2 HIS A 119' %s > %s""" % (filename1, filename))
#os.system("grep -v 'HD1 HIS A 119' %s > %s""" % (filename1, filename))
#os.system("grep -v 'HD2 HIS A 119' %s > %s""" % (filename1, filename))
ff_name = "amber99sbildn"
water_name = 'tip3p'
which_forcefield = "%s.xml" % ff_name
which_water = '%s.xml' % water_name
out_pdb_filename = "./equil/equil.pdb"
ff = app.ForceField(which_forcefield, which_water)
pdb = app.PDBFile(filename)
modeller = app.Modeller(pdb.topology, pdb.positions)
variants = [None for i in range(161)]
variants[118] = "HIE"
modeller.addHydrogens(ff, variants=variants)
modeller.addSolvent(ff, padding=padding)
app.PDBFile.writeFile(modeller.topology, modeller.positions, open("./pdbs/%s_box.pdb" % pdbid, 'w'))
