def test_add_solvent(self):
"""Test using simtk.opnmm.app.Modeller to add solvent to a small molecule parameterized by template generator"""
# Select a molecule to add solvent around
from simtk.openmm.app import NoCutoff, Modeller
from simtk import unit
molecule = self.molecules[0]
openmm_topology = molecule.to_topology().to_openmm()
openmm_positions = molecule.conformers[0]
# Try adding solvent without residue template generator; this will fail
from simtk.openmm.app import ForceField
forcefield = ForceField('tip3p.xml')
# Add solvent to a system containing a small molecule
modeller = Modeller(openmm_topology, openmm_positions)
try:
modeller.addSolvent(forcefield, model='tip3p', padding=6.0*unit.angstroms)
except ValueError as e:
pass
# Create a generator that knows about a few molecules
generator = self.TEMPLATE_GENERATOR(molecules=self.molecules)
# Add to the forcefield object
forcefield.registerTemplateGenerator(generator.generator)
# Add solvent to a system containing a small molecule
# This should succeed
modeller.addSolvent(forcefield, model='tip3p', padding=6.0*unit.angstroms)
def _prep_sim(self, coords, external_forces=[]):
try:
from simtk.openmm import Platform, LangevinIntegrator, Vec3
from simtk.openmm.app import Modeller, ForceField, \
CutoffNonPeriodic, PME, Simulation, HBonds
from simtk.unit import angstrom, nanometers, picosecond, \
kelvin, Quantity, molar
except ImportError:
raise ImportError(
'Please install PDBFixer and OpenMM in order to use ClustENM.')
positions = Quantity([Vec3(*xyz) for xyz in coords], angstrom)
modeller = Modeller(self._topology, positions)
if self._sol == 'imp':
forcefield = ForceField(*self._force_field)
system = forcefield.createSystem(modeller.topology,
nonbondedMethod=CutoffNonPeriodic,
nonbondedCutoff=1.0 * nanometers,
constraints=HBonds)
if self._sol == 'exp':
forcefield = ForceField(*self._force_field)
modeller.addSolvent(forcefield,
padding=self._padding * nanometers,
ionicStrength=self._ionicStrength * molar)
system = forcefield.createSystem(modeller.topology,
nonbondedMethod=PME,
nonbondedCutoff=1.0 * nanometers,
constraints=HBonds)
for force in external_forces:
system.addForce(force)
integrator = LangevinIntegrator(self._temp * kelvin, 1 / picosecond,
0.002 * picosecond)
# precision could be mixed, but single is okay.
platform = self._platform if self._platform is None else Platform.getPlatformByName(
self._platform)
properties = None
if self._platform is None:
properties = {'Precision': 'single'}
elif self._platform in ['CUDA', 'OpenCL']:
properties = {'Precision': 'single'}
simulation = Simulation(modeller.topology, system, integrator,
platform, properties)
simulation.context.setPositions(modeller.positions)
return simulation
def add_hydrogens_by_openmm(self):
from simtk.openmm.app import ForceField, Modeller, PDBFile
from pdbfixer import PDBFixer
fixer = PDBFixer(self.name)
field = ForceField('amber99sb.xml', 'tip3p.xml')
fixer.findMissingResidues()
fixer.findMissingAtoms()
fixer.addMissingAtoms()
fixer.addMissingHydrogens(7.0)
modeller = Modeller(fixer.topology, fixer.positions)
modeller.addHydrogens(forcefield=field)
modeller.deleteWater()
PDBFile.writeModel(modeller.topology, modeller.positions, open(self.shotname+'_h.pdb', 'w'))
def check_hydrogens(molecule, ID):
# Check that Hydrogens are in structure
if len(molecule.top.select("name == H")) == 0:
# If absent, then add Hydrogens using the Amber99sb force-field
try:
from simtk.openmm.app import PDBFile, Modeller, ForceField
pdb = PDBFile(ID + ".pdb")
modeller = Modeller(pdb.topology, pdb.positions)
forcefield = ForceField('amber99sb.xml', 'tip3p.xml')
modeller.addHydrogens(forcefield)
PDBFile.writeFile(modeller.topology, modeller.positions,
open(ID + ".pdb", 'w'))
molecule = md.load(ID + ".pdb").remove_solvent()
except:
warnings.warn(
"""PDB topology missing Hydrogens. Either manually add
or install OpenMM through SIMTK to automatically correct.""")
pass
return molecule
def __init__(self, pdb_path, offset_size=2):
# OpenMM init
self.pdb_path = pdb_path
self.pdb = PDBFile(self.pdb_path)
self.forcefield = ForceField('amber14-all.xml', 'amber14/tip3pfb.xml')
self.modeller = Modeller(self.pdb.topology, self.pdb.positions)
# Remove any water that might be present in the PDB file
self.modeller.deleteWater()
# Add any hydrogens not present
self.modeller.addHydrogens(self.forcefield)
self.system = self.forcefield.createSystem(self.modeller.topology,
nonbondedMethod=PME,
nonbondedCutoff=1 *
u.nanometer,
constraints=HBonds)
self.integrator = LangevinIntegrator(300 * u.kelvin, 1 / u.picosecond,
0.002 * u.picoseconds)
self.simulation = Simulation(self.modeller.topology, self.system,
self.integrator)
self.pdb_positions = self.modeller.getPositions()
# Initialize bond dictionary and positions for chemcoord
self.cc_bonds = {}
self.offset_size = offset_size
self._init_pdb_bonds()
self.set_cc_positions(self.pdb_positions)
# Perform initial minimization, which updates self.pdb_positions
min_energy, min_positions = self.run_simulation()
# Reset the positions after the minimization
self.set_cc_positions(self.pdb_positions)
self.torsion_indices = self._get_torsion_indices()
self.starting_positions = min_positions
self.starting_torsions = np.array([
self.zmat.loc[self.torsion_indices[:, 0], 'dihedral'],
self.zmat.loc[self.torsion_indices[:, 1], 'dihedral']
]).T
self.seed_offsets()
---SYSTEM PREPARATION---
setup AM1-BCC charges for the solute, add solvent, set non-bonded method etc
'''
ligand_mol = Molecule.from_file('ethanol.sdf', file_format='sdf')
forcefield_kwargs = {'constraints': app.HBonds, 'rigidWater': True, 'removeCMMotion': True, 'hydrogenMass': 4 * unit.amu }
system_generator = SystemGenerator(
forcefields=['amber/ff14SB.xml', 'amber/tip4pew_standard.xml'],
small_molecule_forcefield='gaff-2.11',
molecules=[ligand_mol],
forcefield_kwargs=forcefield_kwargs)
ligand_pdb = PDBFile('ethanol.pdb')
modeller = Modeller(ligand_pdb.topology, ligand_pdb.positions)
modeller.addSolvent(system_generator.forcefield, model='tip4pew', padding=12.0 * unit.angstroms)
system = system_generator.forcefield.createSystem(modeller.topology, nonbondedMethod=PME,
nonbondedCutoff=9.0 * unit.angstroms, constraints=HBonds)
'''
---FINISHED SYSTEM PREPARATION---
'''
'''
---ALCHEMICAL CONFIGURATION---
define solute indexes, set up the alchemical region + factory, and specify steric/electrostatic lambda coupling for solvation
'''
# determines solute indexes
'rigidWater': True,
'removeCMMotion': False,
'hydrogenMass': 4 * unit.amu
}
system_generator = SystemGenerator(
forcefields=['amber/ff14SB.xml', 'amber/tip3p_standard.xml'],
small_molecule_forcefield='gaff-2.11',
molecules=[ligand_mol],
forcefield_kwargs=forcefield_kwargs)
# Use Modeller to combine the protein and ligand into a complex
print('Reading protein')
protein_pdb = PDBFile(pdb_in)
print('Preparing complex')
modeller = Modeller(protein_pdb.topology, protein_pdb.positions)
print('System has %d atoms' % modeller.topology.getNumAtoms())
# This next bit is black magic.
# Modeller needs topology and positions. Lots of trial and error found that this is what works to get these from
# an openforcefield Molecule object that was created from a RDKit molecule.
# The topology part is described in the openforcefield API but the positions part grabs the first (and only)
# conformer and passes it to Modeller. It works. Don't ask why!
modeller.add(ligand_mol.to_topology().to_openmm(), ligand_mol.conformers[0])
print('System has %d atoms' % modeller.topology.getNumAtoms())
# Solvate
print('Adding solvent...')
# we use the 'padding' option to define the periodic box. The PDB file does not contain any
# unit cell information so we just create a box that has a 10A padding around the complex.
if chain.get_id() == self.chain:
return 1
else:
return 0
p = PDBParser(PERMISSIVE=1)
structure = p.get_structure(f'{pdbid}', f'{pdbid}_fixed.pdb')
pdb_chain_file = f'chain_{chain}.pdb'
io_w_no_h = PDBIO()
io_w_no_h.set_structure(structure)
io_w_no_h.save(f'{pdbid}_chain{chain}.pdb', ChainSelect(chain))
print("The fixed.pdb file with selected chain is ready.")
# load pdb to Modeller
pdb = PDBFile(f'{pdbid}_chain{chain}.pdb')
molecule = Modeller(pdb.topology, pdb.positions)
print("Done loading pdb to Modeller.")
# load force field
forcefield = ForceField('amber14-all.xml', 'amber14/tip3pfb.xml')
print("Done loading force field.")
print("OpenMM version:", version.version)
# prepare system
molecule.addSolvent(forcefield,
padding=12 * unit.angstrom,
model='tip3p',
positiveIon='Na+',
negativeIon='Cl-',
ionicStrength=0 * unit.molar)
print("Done adding solvent.")
PDBxFile.writeFile(molecule.topology,
molecule.positions,
def calculate_protein_energetics():
"""
* Create an OpenMM system using the first fragment.
* Add each fragment into the system.
* Calculate the energy of the system and print.
"""
os.chdir('group2')
# Necessary due to size of calculation
sys.setrecursionlimit(15000)
frag1 = PDBFile('frag1/no_QUP_frag1.pdb')
forcefield = ForceField(
'frag1/QUBE_pro_frag1.xml',
'frag2/QUBE_pro_frag2_plus.xml',
'frag3/QUBE_pro_frag3_plus.xml',
'frag4/QUBE_pro_frag4_plus.xml',
)
modeller = Modeller(frag1.topology, frag1.positions)
frag2 = PDBFile('frag2/no_QUP_frag2.pdb')
modeller.add(frag2.topology, frag2.positions)
frag3 = PDBFile('frag3/no_QUP_frag3.pdb')
modeller.add(frag3.topology, frag3.positions)
frag4 = PDBFile('frag4/no_QUP_frag4.pdb')
modeller.add(frag4.topology, frag4.positions)
system = forcefield.createSystem(
modeller.topology,
nonbondedMethod=NoCutoff,
)
system = apply_opls_combo(system)
integrator = LangevinIntegrator(
298.15 * unit.kelvin, # Temperature of heat bath
1.0 / unit.picoseconds, # Friction coefficient
2.0 * unit.femtoseconds, # Time step
)
platform = Platform.getPlatformByName('CPU')
simulation = Simulation(modeller.topology, system, integrator, platform)
simulation.context.setPositions(modeller.positions)
print('energy from openmm library')
print(simulation.context.getState(getEnergy=True).getPotentialEnergy())
positions = simulation.context.getState(getPositions=True).getPositions()
with open('output.pdb', 'w') as out_file:
PDBFile.writeFile(simulation.topology, positions, out_file)
structure = parmed.load_file('output.pdb')
energy_comps = parmed.openmm.energy_decomposition_system(structure, system)
total_energy = 0.0
for comp in energy_comps:
total_energy += comp[1]
print(*comp)
print(f'Total energy {total_energy: 6.6f}')
"""
Testing the funnel hypothesis
"""
from math import pi
from simtk.openmm.app import PDBFile, ForceField, Modeller, PME, HBonds
from simtk.openmm import LangevinIntegrator
from simtk.unit import kelvin, nanometer, picosecond, picoseconds
import chemcoord as cc
import numpy as np
import pandas as pd
import util
pdb = PDBFile('1ubq.pdb')
forcefield = ForceField('amber14-all.xml', 'amber14/tip3pfb.xml')
modeller = Modeller(pdb.topology, pdb.positions)
modeller.addHydrogens(forcefield)
system = forcefield.createSystem(modeller.topology,
nonbondedMethod=PME,
nonbondedCutoff=1 * nanometer,
constraints=HBonds)
integrator = LangevinIntegrator(300 * kelvin, 1 / picosecond,
0.002 * picoseconds)
pdb_bonds = modeller.topology.bonds()
atoms = modeller.topology.atoms()
positions = modeller.getPositions()
cc_bonds = {}
cc_positions = np.zeros((3, modeller.topology.getNumAtoms()))
atom_names = []
'removeCMMotion': False,
'hydrogenMass': 4 * unit.amu
}
system_generator = SystemGenerator(
forcefields=['amber/ff14SB.xml', 'amber/tip3p_standard.xml'],
small_molecule_forcefield='openff_unconstrained-1.2.1.offxml',
# small_molecule_forcefield='gaff-2.11',
molecules=other_mols,
forcefield_kwargs=forcefield_kwargs)
# Use Modeller to combine the protein and ligand into a complex
print('Reading protein')
protein_pdb = PDBFile(opt.receptor)
print('Preparing complex')
modeller = Modeller(protein_pdb.topology, protein_pdb.positions)
print('System has %d atoms' % modeller.topology.getNumAtoms())
# This next bit is black magic.
# Modeller needs topology and positions. Lots of trial and error found that this is what works to get these from
# an openforcefield Molecule object that was created from a RDKit molecule.
# The topology part is described in the openforcefield API but the positions part grabs the first (and only)
# conformer and passes it to Modeller. It works. Don't ask why!
if len(other_mols) != 0:
for other_mol in other_mols:
modeller.add(other_mol.to_topology().to_openmm(),
other_mol.conformers[0])
#modeller.add(ligand_mol.to_topology().to_openmm(), ligand_mol.conformers[0])
# Generate ligand with solvent for FEP
if opt.ligand: