def minimize(self, tolerance=None, maxIterations=None, platform=None):
"""
Minimize the current configuration.
Parameters
----------
tolerance : simtk.unit.Quantity compatible with kilocalories_per_mole/anstroms, optional, default = 1*kilocalories_per_mole/anstrom
Tolerance to use for minimization termination criterion.
maxIterations : int, optional, default = 100
Maximum number of iterations to use for minimization.
platform : simtk.openmm.Platform, optional
Platform to use for minimization.
Examples
--------
>>> # Create a test system
>>> import testsystems
>>> test = testsystems.AlanineDipeptideVacuum()
>>> # Create a sampler state.
>>> sampler_state = SamplerState(system=test.system, positions=test.positions)
>>> # Minimize
>>> sampler_state.minimize()
"""
timer = Timer()
if (tolerance is None):
tolerance = 1.0 * u.kilocalories_per_mole / u.angstroms
if (maxIterations is None):
maxIterations = 100
# Use LocalEnergyMinimizer
from simtk.openmm import LocalEnergyMinimizer
timer.start("Context creation")
context = self.createContext(platform=platform)
logger.debug("LocalEnergyMinimizer: platform is %s" %
context.getPlatform().getName())
logger.debug("Minimizing with tolerance %s and %d max. iterations." %
(tolerance, maxIterations))
timer.stop("Context creation")
timer.start("LocalEnergyMinimizer minimize")
LocalEnergyMinimizer.minimize(context, tolerance, maxIterations)
timer.stop("LocalEnergyMinimizer minimize")
# Retrieve data.
sampler_state = SamplerState.createFromContext(context)
self.positions = sampler_state.positions
self.potential_energy = sampler_state.potential_energy
self.total_energy = sampler_state.total_energy
del context
timer.report_timing()
return
def run(self):
if not self._initialized:
self._initialize()
LocalEnergyMinimizer.minimize(self._explorer.context, self._tolerance,
self._max_iter)
def minimize(self, tolerance=None, maxIterations=None, platform=None):
"""
Minimize the current configuration.
Parameters
----------
tolerance : simtk.unit.Quantity compatible with kilocalories_per_mole/anstroms, optional, default = 1*kilocalories_per_mole/anstrom
Tolerance to use for minimization termination criterion.
maxIterations : int, optional, default = 100
Maximum number of iterations to use for minimization.
platform : simtk.openmm.Platform, optional
Platform to use for minimization.
Examples
--------
>>> # Create a test system
>>> from openmmtools import testsystems
>>> test = testsystems.AlanineDipeptideVacuum()
>>> # Create a sampler state.
>>> sampler_state = SamplerState(system=test.system, positions=test.positions)
>>> # Minimize
>>> sampler_state.minimize()
"""
timer = Timer()
if (tolerance is None):
tolerance = 1.0 * u.kilocalories_per_mole / u.angstroms
if (maxIterations is None):
maxIterations = 100
# Use LocalEnergyMinimizer
from simtk.openmm import LocalEnergyMinimizer
timer.start("Context creation")
context = self.createContext(platform=platform)
logger.debug("LocalEnergyMinimizer: platform is %s" % context.getPlatform().getName())
logger.debug("Minimizing with tolerance %s and %d max. iterations." % (tolerance, maxIterations))
timer.stop("Context creation")
timer.start("LocalEnergyMinimizer minimize")
LocalEnergyMinimizer.minimize(context, tolerance, maxIterations)
timer.stop("LocalEnergyMinimizer minimize")
# Retrieve data.
sampler_state = SamplerState.createFromContext(context)
self.positions = sampler_state.positions
self.potential_energy = sampler_state.potential_energy
self.total_energy = sampler_state.total_energy
del context
timer.report_timing()
return
kilocalorie_per_mole_per_angstrom = unit.kilocalorie_per_mole/unit.angstrom
for f in state.getForces():
print(f.in_units_of(kilocalorie_per_mole_per_angstrom))
##### Local energy minimization
# In[ ]:
from simtk.openmm import LocalEnergyMinimizer
# In[ ]:
LocalEnergyMinimizer.minimize(simulation.context, 1e-1)
##### Energy, forces and positions after minimization
# In[ ]:
state = simulation.context.getState(getForces=True, getEnergy=True, getPositions=True)
potential_energy = state.getPotentialEnergy()
potential_energy.in_units_of(unit.kilocalorie_per_mole)
# In[ ]:
kilocalorie_per_mole_per_angstrom = unit.kilocalorie_per_mole/unit.angstrom
for f in state.getForces():
def prepare_ml_system(positions,
topology,
system,
residue_indices,
model_name='ani2x',
save_filename='animodel.pt',
torch_scale_name='torch_scale',
torch_scale_default_value=0.,
HybridSystemFactory_kwargs={},
minimizer_kwargs={'maxIterations': 1000}):
"""
prepare an ani-force-compatible system with built-in lambda assertions and energy compatibility assertions
"""
from qmlify.openmm_torch.torchforce_generator import torch_alchemification_wrapper
from openmmtools import utils
from openmmtools.integrators import LangevinIntegrator
from openmmtools.constants import kB
from simtk.openmm import LocalEnergyMinimizer
import numpy as np
DEFAULT_TEMPERATURE = 300.0 * unit.kelvin
ENERGY_DIFFERENCE_TOLERANCE = 1e-2
_logger.info("preparing ML system and initializing assertions...")
# make ml system and hybrid factory
_logger.info(
f"executing torch alchemification wrapper to make ml_system and hybrid_factory"
)
ml_system, hybrid_factory = torch_alchemification_wrapper(
topology,
system,
residue_indices,
model_name,
save_filename,
torch_scale_name,
torch_scale_default_value,
)
# get platform
platform = configure_platform(
platform_name=utils.get_fastest_platform().getName())
beta = 1. / (kB * DEFAULT_TEMPERATURE)
# get integrators
old_mm_int = LangevinIntegrator(temperature=DEFAULT_TEMPERATURE)
mm_int = LangevinIntegrator(temperature=DEFAULT_TEMPERATURE)
ml_int = LangevinIntegrator(temperature=DEFAULT_TEMPERATURE)
# make mm contexts at lambda 0
mm_context = openmm.Context(hybrid_factory.system, mm_int, platform)
mm_context.setPositions(positions)
mm_context.setPeriodicBoxVectors(
*hybrid_factory.system.getDefaultPeriodicBoxVectors())
# get the swig parameters and check the alchemical mm system
_logger.debug(
f"ensuring appropriate lambda initialization at lambda0 for alchemical system..."
)
mm_swig_params = mm_context.getParameters()
for name in mm_swig_params:
assert DEFAULT_LAMBDA0s[name] == mm_swig_params[
name], f"swig parameter {name} is {mm_swig_params[name]} but should be {DEFAULT_LAMBDA0s[name]}"
# minimize mm context
LocalEnergyMinimizer.minimize(mm_context, **minimizer_kwargs)
# apply the positions to the ml context
ml_context = openmm.Context(ml_system, ml_int, platform)
# check the ml context swig parameters
ml_context.setPositions(
mm_context.getState(getPositions=True).getPositions(asNumpy=True))
ml_context.setPeriodicBoxVectors(
*hybrid_factory.system.getDefaultPeriodicBoxVectors())
# get the swig parameters and check the alchemical ml system
ml_swig_params = ml_context.getParameters()
torch_parameters_lambda0 = {
torch_scale_name: torch_scale_default_value,
f'auxiliary_{torch_scale_name}': 1.
} #this is hard coded...want this?
_logger.debug(
f"ensuring appropriate lambda initialization at lambda0 for ml alchemical system..."
)
for name in ml_swig_params:
if name in list(DEFAULT_LAMBDA0s.keys()):
assert DEFAULT_LAMBDA0s[name] == ml_swig_params[
name], f"swig parameter {name} is {ml_swig_params[name]} but should be {DEFAULT_LAMBDA0s[name]}"
else: #it is a special torch parameter
assert ml_swig_params[name] == torch_parameters_lambda0[name]
# build the old (nonalch) system
old_mm_context = openmm.Context(hybrid_factory._old_system, old_mm_int,
platform)
old_mm_context.setPositions(
mm_context.getState(getPositions=True).getPositions(asNumpy=True))
old_mm_context.setPeriodicBoxVectors(
*hybrid_factory.system.getDefaultPeriodicBoxVectors())
# now check energy by components
_logger.debug(
f"computing potential components of _all_ contexts...standby.")
old_mm_potential_components = compute_potential_components(
old_mm_context, beta, platform)
mm_potential_components = compute_potential_components(
mm_context, beta, platform)
# ml_potential_components = compute_potential_components(ml_context, beta, platform) #we can't do this right now since there is a bug...
sum_old_mm_potential_components = np.sum(
[tup[1] for tup in old_mm_potential_components])
sum_mm_potential_components = np.sum(
[tup[1] for tup in mm_potential_components])
# sum_ml_potential_components = np.sum(list(ml_potential_components.values()))
mm_difference = abs(sum_old_mm_potential_components -
sum_mm_potential_components)
ml_difference = abs(
sum_mm_potential_components -
ml_context.getState(getEnergy=True).getPotentialEnergy() * beta)
try:
_logger.info(f"checking mm bookkeeping energies...")
assert mm_difference < ENERGY_DIFFERENCE_TOLERANCE
except Exception as e:
_logger.warning(
f"{e}; difference between energies of the lambda0 alchemical mm and nonalchemical mm energy is {mm_difference}, which is higher than the tolerance of {ENERGY_DIFFERENCE_TOLERANCE}"
)
try:
_logger.info(f"checking mm bookkeeping energies...")
ml_difference < ENERGY_DIFFERENCE_TOLERANCE
except Exception as e:
_logger.warning(
f"{e}; difference between energies of the lambda0 alchemical mm and ml energy is {mm_difference}, which is higher than the tolerance of {ENERGY_DIFFERENCE_TOLERANCE}"
)
# we cannot do the following...
# for key, val in DEFAULT_LAMBDA1s:
# mm_context.setParameter(key, val)
# mm_final_potential_components = compute_potential_components(mm_context, beta, platform)
#
# try:
# _logger.info(f"checking ml bookkeeping energies...")
# """
# here, we are making sure that the alchemical forces starting with `Custom` are all zero and that the other components are unchanged
# """
# for forcename, energy in mm_final_potential_components.items():
# if forcename in [torch_scale_name, f'auxiliary_{torch_scale_name}']:
# # don't check the torch force...at least not yet
# pass
# elif forcename[:7] == 'Custom':
# assert np.isclose(energy, 0.), f"the energy of {forcename} at lambda 1 is {energy} when it should be 0."
# else:
# lambda0_energy = mm_potential_components[forcename]
# assert np.isclose(energy, lambda0_energy), f"the energy of {forcename} at lambda 1 is {energy} when it should be {lambda0_energy}"
# except Exception as e:
# _logger.warning(f"{e}; there is an issue associated with the lambda1 endstate energy bookkeeping. see above for which assertion failed.")
# TODO : add a test for scaling lambdas?
# remove the contexts and integrators used for testing (this will shore up some memory)...
_logger.debug(f"removing contexts...")
for context in [old_mm_context, mm_context, ml_context]:
del context
_logger.debug(f"removing integrators...")
for integrator in [old_mm_int, mm_int, ml_int]:
del integrator
return ml_system, hybrid_factory
def addHydrogens(self, forcefield, pH=7.0, variants=None, platform=None):
"""Add missing hydrogens to the model.
Some residues can exist in multiple forms depending on the pH and properties of the local environment. These
variants differ in the presence or absence of particular hydrogens. In particular, the following variants
are supported:
Aspartic acid:
ASH: Neutral form with a hydrogen on one of the delta oxygens
ASP: Negatively charged form without a hydrogen on either delta oxygen
Cysteine:
CYS: Neutral form with a hydrogen on the sulfur
CYX: No hydrogen on the sulfur (either negatively charged, or part of a disulfide bond)
Glutamic acid:
GLH: Neutral form with a hydrogen on one of the epsilon oxygens
GLU: Negatively charged form without a hydrogen on either epsilon oxygen
Histidine:
HID: Neutral form with a hydrogen on the ND1 atom
HIE: Neutral form with a hydrogen on the NE2 atom
HIP: Positively charged form with hydrogens on both ND1 and NE2
Lysine:
LYN: Neutral form with two hydrogens on the zeta nitrogen
LYS: Positively charged form with three hydrogens on the zeta nitrogen
The variant to use for each residue is determined by the following rules:
1. The most common variant at the specified pH is selected.
2. Any Cysteine that participates in a disulfide bond uses the CYX variant regardless of pH.
3. For a neutral Histidine residue, the HID or HIE variant is selected based on which one forms a better hydrogen bond.
You can override these rules by explicitly specifying a variant for any residue. Also keep in mind that this
function will only add hydrogens. It will never remove ones that are already present in the model, regardless
of the specified pH.
Definitions for standard amino acids and nucleotides are built in. You can call loadHydrogenDefinitions() to load
additional definitions for other residue types.
Parameters:
- forcefield (ForceField) the ForceField to use for determining the positions of hydrogens
- pH (float=7.0) the pH based on which to select variants
- variants (list=None) an optional list of variants to use. If this is specified, its length must equal the number
of residues in the model. variants[i] is the name of the variant to use for residue i (indexed starting at 0).
If an element is None, the standard rules will be followed to select a variant for that residue.
- platform (Platform=None) the Platform to use when computing the hydrogen atom positions. If this is None,
the default Platform will be used.
Returns: a list of what variant was actually selected for each residue, in the same format as the variants parameter
"""
# Check the list of variants.
residues = list(self.topology.residues())
if variants is not None:
if len(variants) != len(residues):
raise ValueError("The length of the variants list must equal the number of residues")
else:
variants = [None]*len(residues)
actualVariants = [None]*len(residues)
# Load the residue specifications.
if not Modeller._hasLoadedStandardHydrogens:
Modeller.loadHydrogenDefinitions(os.path.join(os.path.dirname(__file__), 'data', 'hydrogens.xml'))
# Make a list of atoms bonded to each atom.
bonded = {}
for atom in self.topology.atoms():
bonded[atom] = []
for atom1, atom2 in self.topology.bonds():
bonded[atom1].append(atom2)
bonded[atom2].append(atom1)
# Define a function that decides whether a set of atoms form a hydrogen bond, using fairly tolerant criteria.
def isHbond(d, h, a):
if norm(d-a) > 0.35*nanometer:
return False
deltaDH = h-d
deltaHA = a-h
deltaDH /= norm(deltaDH)
deltaHA /= norm(deltaHA)
return acos(dot(deltaDH, deltaHA)) < 50*degree
# Loop over residues.
newTopology = Topology()
newTopology.setUnitCellDimensions(deepcopy(self.topology.getUnitCellDimensions()))
newAtoms = {}
newPositions = []*nanometer
newIndices = []
acceptors = [atom for atom in self.topology.atoms() if atom.element in (elem.oxygen, elem.nitrogen)]
for chain in self.topology.chains():
newChain = newTopology.addChain()
for residue in chain.residues():
newResidue = newTopology.addResidue(residue.name, newChain)
isNTerminal = (residue == chain._residues[0])
isCTerminal = (residue == chain._residues[-1])
if residue.name in Modeller._residueHydrogens:
# Add hydrogens. First select which variant to use.
spec = Modeller._residueHydrogens[residue.name]
variant = variants[residue.index]
if variant is None:
if residue.name == 'CYS':
# If this is part of a disulfide, use CYX.
sulfur = [atom for atom in residue.atoms() if atom.element == elem.sulfur]
if len(sulfur) == 1 and any((atom.residue != residue for atom in bonded[sulfur[0]])):
variant = 'CYX'
if residue.name == 'HIS' and pH > 6.5:
# See if either nitrogen already has a hydrogen attached.
nd1 = [atom for atom in residue.atoms() if atom.name == 'ND1']
ne2 = [atom for atom in residue.atoms() if atom.name == 'NE2']
if len(nd1) != 1 or len(ne2) != 1:
raise ValueError('HIS residue (%d) has the wrong set of atoms' % residue.index)
nd1 = nd1[0]
ne2 = ne2[0]
nd1HasHydrogen = any((atom.element == elem.hydrogen for atom in bonded[nd1]))
ne2HasHydrogen = any((atom.element == elem.hydrogen for atom in bonded[ne2]))
if nd1HasHydrogen and ne2HasHydrogen:
variant = 'HIP'
elif nd1HasHydrogen:
variant = 'HID'
elif ne2HasHydrogen:
variant = 'HIE'
else:
# Estimate the hydrogen positions.
nd1Pos = self.positions[nd1.index]
ne2Pos = self.positions[ne2.index]
hd1Delta = Vec3(0, 0, 0)*nanometer
for other in bonded[nd1]:
hd1Delta += nd1Pos-self.positions[other.index]
hd1Delta *= 0.1*nanometer/norm(hd1Delta)
hd1Pos = nd1Pos+hd1Delta
he2Delta = Vec3(0, 0, 0)*nanometer
for other in bonded[ne2]:
he2Delta += ne2Pos-self.positions[other.index]
he2Delta *= 0.1*nanometer/norm(he2Delta)
he2Pos = ne2Pos+he2Delta
# See whether either hydrogen would form a hydrogen bond.
nd1IsBonded = False
ne2IsBonded = False
for acceptor in acceptors:
if acceptor.residue != residue:
acceptorPos = self.positions[acceptor.index]
if isHbond(nd1Pos, hd1Pos, acceptorPos):
nd1IsBonded = True
break
if isHbond(ne2Pos, he2Pos, acceptorPos):
ne2IsBonded = True
if ne2IsBonded and not nd1IsBonded:
variant = 'HIE'
else:
variant = 'HID'
elif residue.name == 'HIS':
variant = 'HIP'
if variant is not None and variant not in spec.variants:
raise ValueError('Illegal variant for %s residue: %s' % (residue.name, variant))
actualVariants[residue.index] = variant
# Make a list of hydrogens that should be present in the residue.
parents = [atom for atom in residue.atoms() if atom.element != elem.hydrogen]
parentNames = [atom.name for atom in parents]
hydrogens = [h for h in spec.hydrogens if (variant is None and pH <= h.maxph) or (h.variants is None and pH <= h.maxph) or (h.variants is not None and variant in h.variants)]
hydrogens = [h for h in hydrogens if h.terminal is None or (isNTerminal and h.terminal == 'N') or (isCTerminal and h.terminal == 'C')]
hydrogens = [h for h in hydrogens if h.parent in parentNames]
# Loop over atoms in the residue, adding them to the new topology along with required hydrogens.
for parent in residue.atoms():
# Add the atom.
newAtom = newTopology.addAtom(parent.name, parent.element, newResidue)
newAtoms[parent] = newAtom
newPositions.append(deepcopy(self.positions[parent.index]))
if parent in parents:
# Match expected hydrogens with existing ones and find which ones need to be added.
existing = [atom for atom in bonded[parent] if atom.element == elem.hydrogen]
expected = [h for h in hydrogens if h.parent == parent.name]
if len(existing) < len(expected):
# Try to match up existing hydrogens to expected ones.
matches = []
for e in existing:
match = [h for h in expected if h.name == e.name]
if len(match) > 0:
matches.append(match[0])
expected.remove(match[0])
else:
matches.append(None)
# If any hydrogens couldn't be matched by name, just match them arbitrarily.
for i in range(len(matches)):
if matches[i] is None:
matches[i] = expected[-1]
expected.remove(expected[-1])
# Add the missing hydrogens.
for h in expected:
newH = newTopology.addAtom(h.name, elem.hydrogen, newResidue)
newIndices.append(newH.index)
delta = Vec3(0, 0, 0)*nanometer
if len(bonded[parent]) > 0:
for other in bonded[parent]:
delta += self.positions[parent.index]-self.positions[other.index]
else:
delta = Vec3(random.random(), random.random(), random.random())*nanometer
delta *= 0.1*nanometer/norm(delta)
delta += 0.05*Vec3(random.random(), random.random(), random.random())*nanometer
delta *= 0.1*nanometer/norm(delta)
newPositions.append(self.positions[parent.index]+delta)
newTopology.addBond(newAtom, newH)
else:
# Just copy over the residue.
for atom in residue.atoms():
newAtom = newTopology.addAtom(atom.name, atom.element, newResidue)
newAtoms[atom] = newAtom
newPositions.append(deepcopy(self.positions[atom.index]))
for bond in self.topology.bonds():
if bond[0] in newAtoms and bond[1] in newAtoms:
newTopology.addBond(newAtoms[bond[0]], newAtoms[bond[1]])
# The hydrogens were added at random positions. Now use the ForceField to fix them up.
system = forcefield.createSystem(newTopology, rigidWater=False)
atoms = list(newTopology.atoms())
for i in range(system.getNumParticles()):
if atoms[i].element != elem.hydrogen:
# This is a heavy atom, so make it immobile.
system.setParticleMass(i, 0)
if platform is None:
context = Context(system, VerletIntegrator(0.0))
else:
context = Context(system, VerletIntegrator(0.0), platform)
context.setPositions(newPositions)
LocalEnergyMinimizer.minimize(context)
self.topology = newTopology
self.positions = context.getState(getPositions=True).getPositions()
return actualVariants
#platform = mm.Platform.getPlatformByName('CPU')
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)
kilocalorie_per_mole_per_angstrom = unit.kilocalorie_per_mole / unit.angstrom
for f in state.getForces():
print(f.in_units_of(kilocalorie_per_mole_per_angstrom))
from simtk.openmm import LocalEnergyMinimizer
LocalEnergyMinimizer.minimize(simulation.context, 1e-1)
simulation.context.setVelocitiesToTemperature(30 * unit.kelvin)
#simulation.step(10)
#Outputs progress to command line
simulation.reporters.append(
app.StateDataReporter(sys.stdout,
skipSteps,
step=True,
potentialEnergy=True,
temperature=True,
progress=True,
remainingTime=True,
speed=True,
totalSteps=steps,
def addHydrogens(self,
forcefield=None,
pH=None,
variants=None,
platform=None):
"""Add missing hydrogens to the model.
This function automatically changes compatible residues into their constant-pH variant if no variant is specified.:
Aspartic acid:
AS4: Form with a 2 hydrogens on each one of the delta oxygens (syn,anti)
It has 5 titration states.
Alternative:
AS2: Has 2 hydrogens (syn, anti) on one of the delta oxygens
It has 3 titration states.
Cysteine:
CYS: Neutral form with a hydrogen on the sulfur
CYX: No hydrogen on the sulfur (either negatively charged, or part of a disulfide bond)
Glutamic acid:
GL4: Form with a 2 hydrogens on each one of the epsilon oxygens (syn,anti)
It has 5 titration states.
Histidine:
HIP: Positively charged form with hydrogens on both ND1 and NE2
It has 3 titration states.
The variant to use for each residue is determined by the following rules:
1. Any Cysteine that participates in a disulfide bond uses the CYX variant regardless of pH.
2. Other residues are all set to maximally protonated state, which can be updated using a proton drive
You can override these rules by explicitly specifying a variant for any residue. To do that, provide a list for the
'variants' parameter, and set the corresponding element to the name of the variant to use.
A special case is when the model already contains a hydrogen that should not be present in the desired variant.
If you explicitly specify a variant using the 'variants' parameter, the residue will be modified to match the
desired variant, removing hydrogens if necessary. On the other hand, for residues whose variant is selected
automatically, this function will only add hydrogens. It will never remove ones that are already present in the
model.
Definitions for standard amino acids and nucleotides are built in. You can call loadHydrogenDefinitions() to load
additional definitions for other residue types.
Parameters
----------
forcefield : ForceField=None
the ForceField to use for determining the positions of hydrogens.
If this is None, positions will be picked which are generally
reasonable but not optimized for any particular ForceField.
pH : None,
Kept for compatibility reasons. Has no effect.
variants : list=None
an optional list of variants to use. If this is specified, its
length must equal the number of residues in the model. variants[i]
is the name of the variant to use for residue i (indexed starting at
0). If an element is None, the standard rules will be followed to
select a variant for that residue.
platform : Platform=None
the Platform to use when computing the hydrogen atom positions. If
this is None, the default Platform will be used.
Returns
-------
list
a list of what variant was actually selected for each residue,
in the same format as the variants parameter
Notes
-----
This function does not use a pH specification. The argument is kept for compatibility reasons.
"""
# Check the list of variants.
if pH is not None:
print("Ignored pH argument provided for constant-pH residues.")
residues = list(self.topology.residues())
if variants is not None:
if len(variants) != len(residues):
raise ValueError(
"The length of the variants list must equal the number of residues"
)
else:
variants = [None] * len(residues)
actualVariants = [None] * len(residues)
# Load the residue specifications.
if not Modeller._hasLoadedStandardHydrogens:
Modeller.loadHydrogenDefinitions(
os.path.join(os.path.dirname(__file__), "data",
"hydrogens-amber10-constph.xml"))
# Make a list of atoms bonded to each atom.
bonded = {}
for atom in self.topology.atoms():
bonded[atom] = []
for atom1, atom2 in self.topology.bonds():
bonded[atom1].append(atom2)
bonded[atom2].append(atom1)
# Define a function that decides whether a set of atoms form a hydrogen bond, using fairly tolerant criteria.
def isHbond(d, h, a):
if norm(d - a) > 0.35 * nanometer:
return False
deltaDH = h - d
deltaHA = a - h
deltaDH /= norm(deltaDH)
deltaHA /= norm(deltaHA)
return acos(dot(deltaDH, deltaHA)) < 50 * degree
# Loop over residues.
newTopology = Topology()
newTopology.setPeriodicBoxVectors(
self.topology.getPeriodicBoxVectors())
newAtoms = {}
newPositions = [] * nanometer
newIndices = []
acceptors = [
atom for atom in self.topology.atoms()
if atom.element in (elem.oxygen, elem.nitrogen)
]
for chain in self.topology.chains():
newChain = newTopology.addChain(chain.id)
for residue in chain.residues():
newResidue = newTopology.addResidue(residue.name, newChain,
residue.id)
isNTerminal = residue == chain._residues[0]
isCTerminal = residue == chain._residues[-1]
if residue.name in Modeller._residueHydrogens:
# Add hydrogens. First select which variant to use.
spec = Modeller._residueHydrogens[residue.name]
variant = variants[residue.index]
if variant is None:
if residue.name == "CYS":
# If this is part of a disulfide, use CYX.
sulfur = [
atom for atom in residue.atoms()
if atom.element == elem.sulfur
]
if len(sulfur) == 1 and any(
(atom.residue != residue
for atom in bonded[sulfur[0]])):
variant = "CYX"
if residue.name == "HIS":
variant = "HIP"
if residue.name == "GLU":
variant = "GL4"
if residue.name == "ASP":
variant = "AS4"
if variant is not None and variant not in spec.variants:
raise ValueError("Illegal variant for %s residue: %s" %
(residue.name, variant))
actualVariants[residue.index] = variant
removeExtraHydrogens = variants[residue.index] is not None
# Make a list of hydrogens that should be present in the residue.
parents = [
atom for atom in residue.atoms()
if atom.element != elem.hydrogen
]
parentNames = [atom.name for atom in parents]
hydrogens = [
h for h in spec.hydrogens
if (variant is None) or (h.variants is None) or (
h.variants is not None and variant in h.variants)
]
hydrogens = [
h for h in hydrogens if h.terminal is None or (
isNTerminal and h.terminal == "N") or (
isCTerminal and h.terminal == "C")
]
hydrogens = [
h for h in hydrogens if h.parent in parentNames
]
# Loop over atoms in the residue, adding them to the new topology along with required hydrogens.
for parent in residue.atoms():
# Check whether this is a hydrogen that should be removed.
if (removeExtraHydrogens
and parent.element == elem.hydrogen
and not any(parent.name == h.name
for h in hydrogens)):
continue
# Add the atom.
newAtom = newTopology.addAtom(parent.name,
parent.element,
newResidue)
newAtoms[parent] = newAtom
newPositions.append(
deepcopy(self.positions[parent.index]))
if parent in parents:
# Match expected hydrogens with existing ones and find which ones need to be added.
existing = [
atom for atom in bonded[parent]
if atom.element == elem.hydrogen
]
expected = [
h for h in hydrogens if h.parent == parent.name
]
if len(existing) < len(expected):
# Try to match up existing hydrogens to expected ones.
matches = []
for e in existing:
match = [
h for h in expected if h.name == e.name
]
if len(match) > 0:
matches.append(match[0])
expected.remove(match[0])
else:
matches.append(None)
# If any hydrogens couldn't be matched by name, just match them arbitrarily.
for i in range(len(matches)):
if matches[i] is None:
matches[i] = expected[-1]
expected.remove(expected[-1])
# Add the missing hydrogens.
for h in expected:
newH = newTopology.addAtom(
h.name, elem.hydrogen, newResidue)
newIndices.append(newH.index)
delta = Vec3(0, 0, 0) * nanometer
if len(bonded[parent]) > 0:
for other in bonded[parent]:
delta += (
self.positions[parent.index] -
self.positions[other.index])
else:
delta = (Vec3(
random.random(),
random.random(),
random.random(),
) * nanometer)
delta *= 0.1 * nanometer / norm(delta)
delta += (0.05 * Vec3(
random.random(),
random.random(),
random.random(),
) * nanometer)
delta *= 0.1 * nanometer / norm(delta)
newPositions.append(
self.positions[parent.index] + delta)
newTopology.addBond(newAtom, newH)
else:
# Just copy over the residue.
for atom in residue.atoms():
newAtom = newTopology.addAtom(atom.name, atom.element,
newResidue)
newAtoms[atom] = newAtom
newPositions.append(
deepcopy(self.positions[atom.index]))
for bond in self.topology.bonds():
if bond[0] in newAtoms and bond[1] in newAtoms:
newTopology.addBond(newAtoms[bond[0]], newAtoms[bond[1]])
# The hydrogens were added at random positions. Now perform an energy minimization to fix them up.
if forcefield is not None:
# Use the ForceField the user specified.
system = forcefield.createSystem(newTopology, rigidWater=False)
atoms = list(newTopology.atoms())
for i in range(system.getNumParticles()):
if atoms[i].element != elem.hydrogen:
# This is a heavy atom, so make it immobile.
system.setParticleMass(i, 0)
else:
# Create a System that restrains the distance of each hydrogen from its parent atom
# and causes hydrogens to spread out evenly.
system = System()
nonbonded = CustomNonbondedForce("100/((r/0.1)^4+1)")
bonds = HarmonicBondForce()
angles = HarmonicAngleForce()
system.addForce(nonbonded)
system.addForce(bonds)
system.addForce(angles)
bondedTo = []
for atom in newTopology.atoms():
nonbonded.addParticle([])
if atom.element != elem.hydrogen:
system.addParticle(0.0)
else:
system.addParticle(1.0)
bondedTo.append([])
for atom1, atom2 in newTopology.bonds():
if atom1.element == elem.hydrogen or atom2.element == elem.hydrogen:
bonds.addBond(atom1.index, atom2.index, 0.1, 100_000.0)
bondedTo[atom1.index].append(atom2)
bondedTo[atom2.index].append(atom1)
for residue in newTopology.residues():
if residue.name == "HOH":
# Add an angle term to make the water geometry correct.
atoms = list(residue.atoms())
oindex = [
i for i in range(len(atoms))
if atoms[i].element == elem.oxygen
]
if len(atoms) == 3 and len(oindex) == 1:
hindex = list(set([0, 1, 2]) - set(oindex))
angles.addAngle(
atoms[hindex[0]].index,
atoms[oindex[0]].index,
atoms[hindex[1]].index,
1.824,
836.8,
)
else:
# Add angle terms for any hydroxyls.
for atom in residue.atoms():
index = atom.index
if (atom.element == elem.oxygen
and len(bondedTo[index]) == 2 and elem.hydrogen
in (a.element for a in bondedTo[index])):
angles.addAngle(
bondedTo[index][0].index,
index,
bondedTo[index][1].index,
1.894,
460.24,
)
if platform is None:
context = Context(system, VerletIntegrator(0.0))
else:
context = Context(system, VerletIntegrator(0.0), platform)
context.setPositions(newPositions)
LocalEnergyMinimizer.minimize(context, 1.0, 50)
self.topology = newTopology
self.positions = context.getState(getPositions=True).getPositions()
del context
return actualVariants
def addHydrogens(self, forcefield=None, pH=None, variants=None, platform=None):
"""Add missing hydrogens to the model.
This function automatically changes compatible residues into their constant-pH variant if no variant is specified.:
Aspartic acid:
AS4: Form with a 2 hydrogens on each one of the delta oxygens (syn,anti)
It has 5 titration states.
Alternative:
AS2: Has 2 hydrogens (syn, anti) on one of the delta oxygens
It has 3 titration states.
Cysteine:
CYS: Neutral form with a hydrogen on the sulfur
CYX: No hydrogen on the sulfur (either negatively charged, or part of a disulfide bond)
Glutamic acid:
GL4: Form with a 2 hydrogens on each one of the epsilon oxygens (syn,anti)
It has 5 titration states.
Histidine:
HIP: Positively charged form with hydrogens on both ND1 and NE2
It has 3 titration states.
The variant to use for each residue is determined by the following rules:
1. Any Cysteine that participates in a disulfide bond uses the CYX variant regardless of pH.
2. Other residues are all set to maximally protonated state, which can be updated using a proton drive
You can override these rules by explicitly specifying a variant for any residue. To do that, provide a list for the
'variants' parameter, and set the corresponding element to the name of the variant to use.
A special case is when the model already contains a hydrogen that should not be present in the desired variant.
If you explicitly specify a variant using the 'variants' parameter, the residue will be modified to match the
desired variant, removing hydrogens if necessary. On the other hand, for residues whose variant is selected
automatically, this function will only add hydrogens. It will never remove ones that are already present in the
model.
Definitions for standard amino acids and nucleotides are built in. You can call loadHydrogenDefinitions() to load
additional definitions for other residue types.
Parameters
----------
forcefield : ForceField=None
the ForceField to use for determining the positions of hydrogens.
If this is None, positions will be picked which are generally
reasonable but not optimized for any particular ForceField.
pH : None,
Kept for compatibility reasons. Has no effect.
variants : list=None
an optional list of variants to use. If this is specified, its
length must equal the number of residues in the model. variants[i]
is the name of the variant to use for residue i (indexed starting at
0). If an element is None, the standard rules will be followed to
select a variant for that residue.
platform : Platform=None
the Platform to use when computing the hydrogen atom positions. If
this is None, the default Platform will be used.
Returns
-------
list
a list of what variant was actually selected for each residue,
in the same format as the variants parameter
Notes
-----
This function does not use a pH specification. The argument is kept for compatibility reasons.
"""
# Check the list of variants.
if pH is not None:
print("Ignored pH argument provided for constant-pH residues.")
residues = list(self.topology.residues())
if variants is not None:
if len(variants) != len(residues):
raise ValueError(
"The length of the variants list must equal the number of residues"
)
else:
variants = [None] * len(residues)
actualVariants = [None] * len(residues)
# Load the residue specifications.
if not Modeller._hasLoadedStandardHydrogens:
Modeller.loadHydrogenDefinitions(
os.path.join(
os.path.dirname(__file__), "data", "hydrogens-amber10-constph.xml"
)
)
# Make a list of atoms bonded to each atom.
bonded = {}
for atom in self.topology.atoms():
bonded[atom] = []
for atom1, atom2 in self.topology.bonds():
bonded[atom1].append(atom2)
bonded[atom2].append(atom1)
# Define a function that decides whether a set of atoms form a hydrogen bond, using fairly tolerant criteria.
def isHbond(d, h, a):
if norm(d - a) > 0.35 * nanometer:
return False
deltaDH = h - d
deltaHA = a - h
deltaDH /= norm(deltaDH)
deltaHA /= norm(deltaHA)
return acos(dot(deltaDH, deltaHA)) < 50 * degree
# Loop over residues.
newTopology = Topology()
newTopology.setPeriodicBoxVectors(self.topology.getPeriodicBoxVectors())
newAtoms = {}
newPositions = [] * nanometer
newIndices = []
acceptors = [
atom
for atom in self.topology.atoms()
if atom.element in (elem.oxygen, elem.nitrogen)
]
for chain in self.topology.chains():
newChain = newTopology.addChain(chain.id)
for residue in chain.residues():
newResidue = newTopology.addResidue(residue.name, newChain, residue.id)
isNTerminal = residue == chain._residues[0]
isCTerminal = residue == chain._residues[-1]
if residue.name in Modeller._residueHydrogens:
# Add hydrogens. First select which variant to use.
spec = Modeller._residueHydrogens[residue.name]
variant = variants[residue.index]
if variant is None:
if residue.name == "CYS":
# If this is part of a disulfide, use CYX.
sulfur = [
atom
for atom in residue.atoms()
if atom.element == elem.sulfur
]
if len(sulfur) == 1 and any(
(atom.residue != residue for atom in bonded[sulfur[0]])
):
variant = "CYX"
if residue.name == "HIS":
variant = "HIP"
if residue.name == "GLU":
variant = "GL4"
if residue.name == "ASP":
variant = "AS4"
if variant is not None and variant not in spec.variants:
raise ValueError(
"Illegal variant for %s residue: %s"
% (residue.name, variant)
)
actualVariants[residue.index] = variant
removeExtraHydrogens = variants[residue.index] is not None
# Make a list of hydrogens that should be present in the residue.
parents = [
atom
for atom in residue.atoms()
if atom.element != elem.hydrogen
]
parentNames = [atom.name for atom in parents]
hydrogens = [
h
for h in spec.hydrogens
if (variant is None)
or (h.variants is None)
or (h.variants is not None and variant in h.variants)
]
hydrogens = [
h
for h in hydrogens
if h.terminal is None
or (isNTerminal and h.terminal == "N")
or (isCTerminal and h.terminal == "C")
]
hydrogens = [h for h in hydrogens if h.parent in parentNames]
# Loop over atoms in the residue, adding them to the new topology along with required hydrogens.
for parent in residue.atoms():
# Check whether this is a hydrogen that should be removed.
if (
removeExtraHydrogens
and parent.element == elem.hydrogen
and not any(parent.name == h.name for h in hydrogens)
):
continue
# Add the atom.
newAtom = newTopology.addAtom(
parent.name, parent.element, newResidue
)
newAtoms[parent] = newAtom
newPositions.append(deepcopy(self.positions[parent.index]))
if parent in parents:
# Match expected hydrogens with existing ones and find which ones need to be added.
existing = [
atom
for atom in bonded[parent]
if atom.element == elem.hydrogen
]
expected = [h for h in hydrogens if h.parent == parent.name]
if len(existing) < len(expected):
# Try to match up existing hydrogens to expected ones.
matches = []
for e in existing:
match = [h for h in expected if h.name == e.name]
if len(match) > 0:
matches.append(match[0])
expected.remove(match[0])
else:
matches.append(None)
# If any hydrogens couldn't be matched by name, just match them arbitrarily.
for i in range(len(matches)):
if matches[i] is None:
matches[i] = expected[-1]
expected.remove(expected[-1])
# Add the missing hydrogens.
for h in expected:
newH = newTopology.addAtom(
h.name, elem.hydrogen, newResidue
)
newIndices.append(newH.index)
delta = Vec3(0, 0, 0) * nanometer
if len(bonded[parent]) > 0:
for other in bonded[parent]:
delta += (
self.positions[parent.index]
- self.positions[other.index]
)
else:
delta = (
Vec3(
random.random(),
random.random(),
random.random(),
)
* nanometer
)
delta *= 0.1 * nanometer / norm(delta)
delta += (
0.05
* Vec3(
random.random(),
random.random(),
random.random(),
)
* nanometer
)
delta *= 0.1 * nanometer / norm(delta)
newPositions.append(
self.positions[parent.index] + delta
)
newTopology.addBond(newAtom, newH)
else:
# Just copy over the residue.
for atom in residue.atoms():
newAtom = newTopology.addAtom(
atom.name, atom.element, newResidue
)
newAtoms[atom] = newAtom
newPositions.append(deepcopy(self.positions[atom.index]))
for bond in self.topology.bonds():
if bond[0] in newAtoms and bond[1] in newAtoms:
newTopology.addBond(newAtoms[bond[0]], newAtoms[bond[1]])
# The hydrogens were added at random positions. Now perform an energy minimization to fix them up.
if forcefield is not None:
# Use the ForceField the user specified.
system = forcefield.createSystem(newTopology, rigidWater=False)
atoms = list(newTopology.atoms())
for i in range(system.getNumParticles()):
if atoms[i].element != elem.hydrogen:
# This is a heavy atom, so make it immobile.
system.setParticleMass(i, 0)
else:
# Create a System that restrains the distance of each hydrogen from its parent atom
# and causes hydrogens to spread out evenly.
system = System()
nonbonded = CustomNonbondedForce("100/((r/0.1)^4+1)")
bonds = HarmonicBondForce()
angles = HarmonicAngleForce()
system.addForce(nonbonded)
system.addForce(bonds)
system.addForce(angles)
bondedTo = []
for atom in newTopology.atoms():
nonbonded.addParticle([])
if atom.element != elem.hydrogen:
system.addParticle(0.0)
else:
system.addParticle(1.0)
bondedTo.append([])
for atom1, atom2 in newTopology.bonds():
if atom1.element == elem.hydrogen or atom2.element == elem.hydrogen:
bonds.addBond(atom1.index, atom2.index, 0.1, 100_000.0)
bondedTo[atom1.index].append(atom2)
bondedTo[atom2.index].append(atom1)
for residue in newTopology.residues():
if residue.name == "HOH":
# Add an angle term to make the water geometry correct.
atoms = list(residue.atoms())
oindex = [
i for i in range(len(atoms)) if atoms[i].element == elem.oxygen
]
if len(atoms) == 3 and len(oindex) == 1:
hindex = list(set([0, 1, 2]) - set(oindex))
angles.addAngle(
atoms[hindex[0]].index,
atoms[oindex[0]].index,
atoms[hindex[1]].index,
1.824,
836.8,
)
else:
# Add angle terms for any hydroxyls.
for atom in residue.atoms():
index = atom.index
if (
atom.element == elem.oxygen
and len(bondedTo[index]) == 2
and elem.hydrogen in (a.element for a in bondedTo[index])
):
angles.addAngle(
bondedTo[index][0].index,
index,
bondedTo[index][1].index,
1.894,
460.24,
)
if platform is None:
context = Context(system, VerletIntegrator(0.0))
else:
context = Context(system, VerletIntegrator(0.0), platform)
context.setPositions(newPositions)
LocalEnergyMinimizer.minimize(context, 1.0, 50)
self.topology = newTopology
self.positions = context.getState(getPositions=True).getPositions()
del context
return actualVariants
