def genTop(self):
self.processFile(self.infile)
# Create the Topology from it.
top = Topology()
# The Topology read from the prmtop infile
self.topology = top
top.setUnitCellDimensions(self.unitCellDimensions)
# PDBFile._loadNameReplacementTables()
for moleculeName, moleculeCount in self.molecules:
if moleculeName not in self.moleculeTypes:
raise ValueError("Unknown molecule type: " + moleculeName)
moleculeType = self.moleculeTypes[moleculeName]
# Create the specified number of molecules of this type.
for i in range(moleculeCount):
atoms = []
lastResidue = None
c = top.addChain()
for index, fields in enumerate(moleculeType.atoms):
resNumber = fields[2]
if resNumber != lastResidue:
lastResidue = resNumber
resName = fields[3]
r = top.addResidue(resName, c)
atomName = fields[4]
atoms.append(top.addAtom(atomName, None, r))
# Add bonds to the topology
for fields in moleculeType.bonds:
top.addBond(atoms[int(fields[0]) - 1],
atoms[int(fields[1]) - 1])
def _createTopology(self):
"""Build the topology of the system
"""
top = Topology()
positions = []
velocities = []
boxVectors = []
for x, y, z in self._conn.execute('SELECT x, y, z FROM global_cell'):
boxVectors.append(mm.Vec3(x, y, z))
unitCellDimensions = [boxVectors[0][0], boxVectors[1][1], boxVectors[2][2]]
top.setUnitCellDimensions(unitCellDimensions*angstrom)
atoms = {}
lastChain = None
lastResId = None
c = top.addChain()
q = """SELECT id, name, anum, resname, resid, chain, x, y, z, vx, vy, vz
FROM particle ORDER BY id"""
for (atomId, atomName, atomNumber, resName, resId, chain, x, y, z, vx, vy, vz) in self._conn.execute(q):
newChain = False
if chain != lastChain:
lastChain = chain
c = top.addChain()
newChain = True
if resId != lastResId or newChain:
lastResId = resId
if resName in PDBFile._residueNameReplacements:
resName = PDBFile._residueNameReplacements[resName]
r = top.addResidue(resName, c)
if resName in PDBFile._atomNameReplacements:
atomReplacements = PDBFile._atomNameReplacements[resName]
else:
atomReplacements = {}
if atomNumber == 0 and atomName.startswith('Vrt'):
elem = None
else:
elem = Element.getByAtomicNumber(atomNumber)
if atomName in atomReplacements:
atomName = atomReplacements[atomName]
atoms[atomId] = top.addAtom(atomName, elem, r)
positions.append(mm.Vec3(x, y, z))
velocities.append(mm.Vec3(vx, vy, vz))
for p0, p1 in self._conn.execute('SELECT p0, p1 FROM bond'):
top.addBond(atoms[p0], atoms[p1])
positions = positions*angstrom
velocities = velocities*angstrom/femtosecond
return top, positions, velocities
def generateTopologyFromOEMol(molecule):
"""
Generate an OpenMM Topology object from an OEMol molecule.
Parameters
----------
molecule : openeye.oechem.OEMol
The molecule from which a Topology object is to be generated.
Returns
-------
topology : simtk.openmm.app.Topology
The Topology object generated from `molecule`.
"""
# Create a Topology object with one Chain and one Residue.
from simtk.openmm.app import Topology
topology = Topology()
chain = topology.addChain()
resname = molecule.GetTitle()
residue = topology.addResidue(resname, chain)
# Create atoms in the residue.
for atom in molecule.GetAtoms():
name = atom.GetName()
element = Element.getByAtomicNumber(atom.GetAtomicNum())
atom = topology.addAtom(name, element, residue)
# Create bonds.
atoms = {atom.name: atom for atom in topology.atoms()}
for bond in molecule.GetBonds():
topology.addBond(atoms[bond.GetBgn().GetName()],
atoms[bond.GetEnd().GetName()])
return topology
def _createTopology(self):
"""Build the topology of the system
"""
top = Topology()
positions = []
velocities = []
boxVectors = []
for x, y, z in self._conn.execute('SELECT x, y, z FROM global_cell'):
boxVectors.append(mm.Vec3(x, y, z))
unitCellDimensions = [boxVectors[0][0], boxVectors[1][1], boxVectors[2][2]]
top.setUnitCellDimensions(unitCellDimensions*angstrom)
atoms = {}
lastChain = None
lastResId = None
c = top.addChain()
q = """SELECT id, name, anum, resname, resid, chain, x, y, z, vx, vy, vz
FROM particle ORDER BY id"""
for (atomId, atomName, atomNumber, resName, resId, chain, x, y, z, vx, vy, vz) in self._conn.execute(q):
newChain = False
if chain != lastChain:
lastChain = chain
c = top.addChain()
newChain = True
if resId != lastResId or newChain:
lastResId = resId
if resName in PDBFile._residueNameReplacements:
resName = PDBFile._residueNameReplacements[resName]
r = top.addResidue(resName, c)
if resName in PDBFile._atomNameReplacements:
atomReplacements = PDBFile._atomNameReplacements[resName]
else:
atomReplacements = {}
if atomNumber == 0 and atomName.startswith('Vrt'):
elem = None
else:
elem = Element.getByAtomicNumber(atomNumber)
if atomName in atomReplacements:
atomName = atomReplacements[atomName]
atoms[atomId] = top.addAtom(atomName, elem, r)
positions.append(mm.Vec3(x, y, z))
velocities.append(mm.Vec3(vx, vy, vz))
for p0, p1 in self._conn.execute('SELECT p0, p1 FROM bond'):
top.addBond(atoms[p0], atoms[p1])
positions = positions*angstrom
velocities = velocities*angstrom/femtosecond
return top, positions, velocities
def _find_nonsolvent_atoms(self, topology: app.Topology) -> List[int]:
solvent_residue_names = ["WAT", "SOL", "H2O", "HOH"]
nonsolvent_atoms = []
for atom in topology.atoms():
if not atom.residue.name in solvent_residue_names:
nonsolvent_atoms.append(atom.index)
return nonsolvent_atoms
def _create_dodecane_acrylate_topology(self):
if self._topology is None:
topology = Topology()
if self.box_vectors is not None:
topology.setPeriodicBoxVectors(self.box_vectors)
for chain_option in self.chains:
id_to_sequence = chain_option.add_chain_to_topology(topology)
self.id_to_sequence.update(id_to_sequence)
for branched_chain_option in self.branched_chains:
branched_chain_option.add_chain_to_topology(topology)
for _ in range(self.numDodecane):
dodecane_id = self._add_dodecane_to_topology(topology)
self.id_to_sequence[dodecane_id] = "C12"
for _ in range(self.numSqualane):
squalane_id = self._add_squalane_to_topology(topology)
self.id_to_sequence[squalane_id] = "squalane"
self._topology = topology
def generateTopologyFromOEMol(molecule):
"""
Generate an OpenMM Topology object from an OEMol molecule.
Parameters
----------
molecule : openeye.oechem.OEMol
The molecule from which a Topology object is to be generated.
Returns
-------
topology : simtk.openmm.app.Topology
The Topology object generated from `molecule`.
"""
# Create a Topology object with one Chain and one Residue.
from simtk.openmm.app import Topology
topology = Topology()
chain = topology.addChain()
resname = molecule.GetTitle()
residue = topology.addResidue(resname, chain)
# Create atoms in the residue.
for atom in molecule.GetAtoms():
name = atom.GetName()
element = Element.getByAtomicNumber(atom.GetAtomicNum())
atom = topology.addAtom(name, element, residue)
# Create bonds.
atoms = { atom.name : atom for atom in topology.atoms() }
for bond in molecule.GetBonds():
topology.addBond(atoms[bond.GetBgn().GetName()], atoms[bond.GetEnd().GetName()])
return topology
def openmm_topology(atoms, bonds):
'''Make OpenMM topology from ChimeraX atoms and bonds.'''
a = atoms
n = len(a)
r = a.residues
aname = a.names
ename = a.element_names
rname = r.names
rnum = r.numbers
cids = r.chain_ids
from simtk.openmm.app import Topology, Element
top = Topology()
cmap = {}
rmap = {}
atoms = {}
for i in range(n):
cid = cids[i]
if not cid in cmap:
cmap[cid] = top.addChain() # OpenMM chains have no name.
rid = (rname[i], rnum[i], cid)
if not rid in rmap:
rmap[rid] = top.addResidue(rname[i], cmap[cid])
element = Element.getBySymbol(ename[i])
atoms[i] = top.addAtom(aname[i], element, rmap[rid])
a1, a2 = bonds.atoms
for i1, i2 in zip(a.indices(a1), a.indices(a2)):
top.addBond(atoms[i1], atoms[i2])
return top
def openmm_topology_from_chimerax_model(model):
'''
Take an AtomicStructure model from ChimeraX and return an OpenMM
topology (e.g. for use with the OpenMM Modeller class).
'''
a = model.atoms
b = model.bonds
n = len(a)
r = a.residues
aname = a.names
ename = a.element_names
rname = r.names
rnum = r.numbers
cids = r.chain_ids
from simtk.openmm.app import Topology, Element
from simtk import unit
top = Topology()
cmap = {}
rmap = {}
atoms = {}
for i in range(n):
cid = cids[i]
if not cid in cmap:
cmap[cid] = top.addChain() # OpenMM chains have no name
rid = (rname[i], rnum[i], cid)
if not rid in rmap:
rmap[rid] = top.addResidue(rname[i], cmap[cid])
element = Element.getBySymbol(ename[i])
atoms[i] = top.addAtom(aname[i], element, rmap[rid])
a1, a2 = b.atoms
for i1, i2 in zip(a.indices(a1), a.indices(a2)):
if -1 not in [i1, i2]:
top.addBond(atoms[i1], atoms[i2])
return top
def generateTopologyFromOEMol(molecule):
"""
Generate an OpenMM Topology object from an OEMol molecule.
Parameters
----------
molecule : openeye.oechem.OEMol
The molecule from which a Topology object is to be generated.
Returns
-------
topology : simtk.openmm.app.Topology
The Topology object generated from `molecule`.
"""
# Avoid manipulating the molecule
mol = OEMol(molecule)
# Create a Topology object with one Chain and one Residue.
from simtk.openmm.app import Topology
topology = Topology()
chain = topology.addChain()
resname = mol.GetTitle()
residue = topology.addResidue(resname, chain)
# Make sure the atoms have names, otherwise bonds won't be created properly below
if any([atom.GetName() == '' for atom in mol.GetAtoms()]):
oechem.OETriposAtomNames(mol)
# Check names are unique; non-unique names will also cause a problem
atomnames = [atom.GetName() for atom in mol.GetAtoms()]
if any(atomnames.count(atom.GetName()) > 1 for atom in mol.GetAtoms()):
raise Exception(
"Error: Reference molecule must have unique atom names in order to create a Topology."
)
# Create atoms in the residue.
for atom in mol.GetAtoms():
name = atom.GetName()
element = elem.Element.getByAtomicNumber(atom.GetAtomicNum())
openmm_atom = topology.addAtom(name, element, residue)
# Create bonds.
atoms = {atom.name: atom for atom in topology.atoms()}
for bond in mol.GetBonds():
aromatic = None
if bond.IsAromatic(): aromatic = 'Aromatic'
# Add bond, preserving order assessed by OEChem
topology.addBond(atoms[bond.GetBgn().GetName()],
atoms[bond.GetEnd().GetName()],
type=aromatic,
order=bond.GetOrder())
return topology
def openmm_topology_and_external_forces(self,
sim_construct,
sim_bonds,
fix_shell_backbones=False,
tug_hydrogens=False,
hydrogens_feel_maps=False,
logging=False,
log=None):
a = sim_construct
n = len(a)
r = a.residues
aname = a.names
ename = a.element_names
rname = r.names
rnum = r.numbers
cids = r.chain_ids
from simtk.openmm.app import Topology, Element
from simtk import unit
top = self._simulation_topology = Topology()
cmap = {}
rmap = {}
atoms = self._atoms = {}
for i in range(n):
cid = cids[i]
if not cid in cmap:
cmap[cid] = top.addChain() # OpenMM chains have no name
rid = (rname[i], rnum[i], cid)
if not rid in rmap:
rmap[rid] = top.addResidue(rname[i], cmap[cid])
element = Element.getBySymbol(ename[i])
atoms[i] = top.addAtom(aname[i], element, rmap[rid])
# Register atoms with forces
if ename is not 'H' or (ename is 'H' and tug_hydrogens):
# All CustomExternalForces
for key, ff in self._custom_external_forces.items():
f = ff[0]
per_particle_param_vals = ff[3]
index_map = ff[4]
index_map[i] = f.addParticle(i, per_particle_param_vals)
if ename is not 'H' or (ename is 'H' and hydrogens_feel_maps):
# All map forces
for m in self._maps:
self.couple_atom_to_map(i, m)
a1, a2 = sim_bonds.atoms
for i1, i2 in zip(a.indices(a1), a.indices(a2)):
if -1 not in [i1, i2]:
top.addBond(atoms[i1], atoms[i2])
from simtk.openmm import Vec3
pos = a.coords # in Angstrom (convert to nm for OpenMM)
return top, pos
def _createTopology(self):
'''Build the topology of the system
'''
top = Topology()
positions = []
boxVectors = []
for x, y, z in self._conn.execute('SELECT x, y, z FROM global_cell'):
boxVectors.append(mm.Vec3(x, y, z)*angstrom)
unitCellDimensions = [boxVectors[0][0], boxVectors[1][1], boxVectors[2][2]]
top.setUnitCellDimensions(unitCellDimensions)
atoms = {}
lastChain = None
lastResId = None
c = top.addChain()
q = '''SELECT id, name, anum, resname, resid, chain, x, y, z
FROM particle'''
for (atomId, atomName, atomNumber, resName, resId, chain, x, y, z) in self._conn.execute(q):
if chain != lastChain:
lastChain = chain
c = top.addChain()
if resId != lastResId:
lastResId = resId
if resName in PDBFile._residueNameReplacements:
resName = PDBFile._residueNameReplacements[resName]
r = top.addResidue(resName, c)
if resName in PDBFile._atomNameReplacements:
atomReplacements = PDBFile._atomNameReplacements[resName]
else:
atomReplacements = {}
if atomName in atomReplacements:
atomName = atomReplacements[atomName]
elem = Element.getByAtomicNumber(atomNumber)
atoms[atomId] = top.addAtom(atomName, elem, r)
positions.append(mm.Vec3(x, y, z)*angstrom)
for p0, p1 in self._conn.execute('SELECT p0, p1 FROM bond'):
top.addBond(atoms[p0], atoms[p1])
return top, positions
def topology(self):
"""
The OpenMM Topology object. Cached when possible, but any changes to the
topology object lists results in the topology being deleted and rebuilt
"""
# If anything changed, rebuild the topology
if not self._topology_changed():
try:
return self._topology
except AttributeError:
pass
else:
self.remake_parm()
self._topology = Topology()
# Add all of the atoms to the topology file in the same chain
chain = self._topology.addChain()
last_residue = None
for i, atm in enumerate(self.atom_list):
resnum = atm.residue.idx
if last_residue != resnum:
last_residue = resnum
resname = atm.residue.resname
res = self._topology.addResidue(resname, chain)
elem = element.get_by_symbol(pt.Element[atm.element])
self._topology.addAtom(atm.atname, elem, res)
# Add bonds to the topology (both with and without hydrogen)
atoms = list(self._topology.atoms())
for bnd in self.bonds_inc_h + self.bonds_without_h:
self._topology.addBond(atoms[bnd.atom1.starting_index],
atoms[bnd.atom2.starting_index])
# Set the box dimensions
if self.ptr('ifbox'):
if hasattr(self, 'rst7'):
self._topology.setUnitCellDimensions(
self.rst7.box[:3]*u.angstrom
)
else:
self._topology.setUnitCellDimensions(
self.parm_data['BOX_DIMENSIONS'][1:4]*u.angstrom
)
return self._topology
def delete(self, toDelete):
"""Delete chains, residues, atoms, and bonds from the model.
You can specify objects to delete at any granularity: atoms, residues, or chains. Passing
in an Atom object causes that Atom to be deleted. Passing in a Residue object causes that
Residue and all Atoms it contains to be deleted. Passing in a Chain object causes that
Chain and all Residues and Atoms it contains to be deleted.
In all cases, when an Atom is deleted, any bonds it participates in are also deleted.
You also can specify a bond (as a tuple of Atom objects) to delete just that bond without
deleting the Atoms it connects.
Parameters:
- toDelete (list) a list of Atoms, Residues, Chains, and bonds (specified as tuples of Atoms) to delete
"""
newTopology = Topology()
newTopology.setUnitCellDimensions(deepcopy(self.topology.getUnitCellDimensions()))
newAtoms = {}
newPositions = []*nanometer
deleteSet = set(toDelete)
for chain in self.topology.chains():
if chain not in deleteSet:
needNewChain = True;
for residue in chain.residues():
if residue not in deleteSet:
needNewResidue = True
for atom in residue.atoms():
if atom not in deleteSet:
if needNewChain:
newChain = newTopology.addChain()
needNewChain = False;
if needNewResidue:
newResidue = newTopology.addResidue(residue.name, newChain)
needNewResidue = False;
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:
if bond not in deleteSet and (bond[1], bond[0]) not in deleteSet:
newTopology.addBond(newAtoms[bond[0]], newAtoms[bond[1]])
self.topology = newTopology
self.positions = newPositions
def _gather_dihedral_params(self, nonsolvent_atoms: List[int],
topology: app.Topology) -> None:
bond_idxs = [sorted([i.index, j.index]) for i, j in topology.bonds()]
for parm_index in range(self.dihedral_force.getNumTorsions()):
params = self.dihedral_force.getTorsionParameters(parm_index)
i, j, k, l, _, _, _ = params
not_solvent = (i in nonsolvent_atoms and j in nonsolvent_atoms
and k in nonsolvent_atoms and l in nonsolvent_atoms)
not_improper = (sorted([i, j]) in bond_idxs
and sorted([j, k]) in bond_idxs
and sorted([k, l]) in bond_idxs)
# only modify dihedrals involving non-solvent atoms
# and those where sequential atoms are bonded (proper dihedrals)
if not_solvent and not_improper:
self.protein_dihedrals[parm_index] = params
def add_moltype_to_omm_topology(molecule_type: MoleculeType,
topology: app.Topology):
gmx_to_omm_index = {}
atom_index = topology.getNumAtoms() - 1
chain = topology.addChain()
residue_iterator = itertools.groupby(
molecule_type.atoms.items(),
key=lambda x: (x[1].residue_number, x[1].residue_name),
)
for (residue_index, residue_name), residue_atoms in residue_iterator:
residue = topology.addResidue(name=residue_name, chain=chain)
for atom_index, (_, atom) in enumerate(residue_atoms,
start=atom_index + 1):
topology.addAtom(atom_index, atom.type_, residue)
gmx_to_omm_index[atom.index] = atom_index
for interaction in molecule_type.interactions['bonds']:
topology.addBond(
gmx_to_omm_index[interaction.atoms[0]],
gmx_to_omm_index[interaction.atoms[1]],
)
def __init__(self, file):
"""Load a PDB file.
The atom positions and Topology can be retrieved by calling getPositions() and getTopology().
Parameters
----------
file : string
the name of the file to load
"""
top = Topology()
## The Topology read from the PDB file
self.topology = top
# Load the PDB file
if isinstance(file, PdbStructure):
pdb = file
else:
inputfile = file
own_handle = False
if isinstance(file, str):
inputfile = open(file)
own_handle = True
pdb = PdbStructure(inputfile, load_all_models=True)
if own_handle:
inputfile.close()
PDBFile._loadNameReplacementTables()
# Build the topology
atomByNumber = {}
for chain in pdb.iter_chains():
c = top.addChain(chain.chain_id)
for residue in chain.iter_residues():
resName = residue.get_name()
if resName in PDBFile._residueNameReplacements:
resName = PDBFile._residueNameReplacements[resName]
r = top.addResidue(resName, c, str(residue.number))
if resName in PDBFile._atomNameReplacements:
atomReplacements = PDBFile._atomNameReplacements[resName]
else:
atomReplacements = {}
for atom in residue.atoms:
atomName = atom.get_name()
if atomName in atomReplacements:
atomName = atomReplacements[atomName]
atomName = atomName.strip()
element = atom.element
if element is None:
# Try to guess the element.
upper = atomName.upper()
if upper.startswith('CL'):
element = elem.chlorine
elif upper.startswith('NA'):
element = elem.sodium
elif upper.startswith('MG'):
element = elem.magnesium
elif upper.startswith('BE'):
element = elem.beryllium
elif upper.startswith('LI'):
element = elem.lithium
elif upper.startswith('K'):
element = elem.potassium
elif upper.startswith('ZN'):
element = elem.zinc
elif( len( residue ) == 1 and upper.startswith('CA') ):
element = elem.calcium
else:
try:
element = elem.get_by_symbol(atomName[0])
except KeyError:
pass
newAtom = top.addAtom(atomName, element, r, str(atom.serial_number))
atomByNumber[atom.serial_number] = newAtom
self._positions = []
for model in pdb.iter_models(True):
coords = []
for chain in model.iter_chains():
for residue in chain.iter_residues():
for atom in residue.atoms:
pos = atom.get_position().value_in_unit(nanometers)
coords.append(Vec3(pos[0], pos[1], pos[2]))
self._positions.append(coords*nanometers)
## The atom positions read from the PDB file. If the file contains multiple frames, these are the positions in the first frame.
self.positions = self._positions[0]
self.topology.setPeriodicBoxVectors(pdb.get_periodic_box_vectors())
self.topology.createStandardBonds()
self.topology.createDisulfideBonds(self.positions)
self._numpyPositions = None
# Add bonds based on CONECT records.
connectBonds = []
for connect in pdb.models[0].connects:
i = connect[0]
for j in connect[1:]:
if i in atomByNumber and j in atomByNumber:
connectBonds.append((atomByNumber[i], atomByNumber[j]))
if len(connectBonds) > 0:
# Only add bonds that don't already exist.
existingBonds = set(top.bonds())
for bond in connectBonds:
if bond not in existingBonds and (bond[1], bond[0]) not in existingBonds:
top.addBond(bond[0], bond[1])
existingBonds.add(bond)
def __init__(self, file, extraParticleIdentifier='EP'):
"""Load a PDB file.
The atom positions and Topology can be retrieved by calling getPositions() and getTopology().
Parameters
----------
file : string
the name of the file to load
extraParticleIdentifier : string='EP'
if this value appears in the element column for an ATOM record, the Atom's element will be set to None to mark it as an extra particle
"""
metalElements = [
'Al', 'As', 'Ba', 'Ca', 'Cd', 'Ce', 'Co', 'Cs', 'Cu', 'Dy', 'Fe',
'Gd', 'Hg', 'Ho', 'In', 'Ir', 'K', 'Li', 'Mg', 'Mn', 'Mo', 'Na',
'Ni', 'Pb', 'Pd', 'Pt', 'Rb', 'Rh', 'Sm', 'Sr', 'Te', 'Tl', 'V',
'W', 'Yb', 'Zn'
]
top = Topology()
## The Topology read from the PDB file
self.topology = top
# Load the PDB file
if isinstance(file, PdbStructure):
pdb = file
else:
inputfile = file
own_handle = False
if isinstance(file, str):
inputfile = open(file)
own_handle = True
pdb = PdbStructure(inputfile,
load_all_models=True,
extraParticleIdentifier=extraParticleIdentifier)
if own_handle:
inputfile.close()
PDBFile._loadNameReplacementTables()
# Build the topology
atomByNumber = {}
for chain in pdb.iter_chains():
c = top.addChain(chain.chain_id)
for residue in chain.iter_residues():
resName = residue.get_name()
if resName in PDBFile._residueNameReplacements:
resName = PDBFile._residueNameReplacements[resName]
r = top.addResidue(resName, c, str(residue.number),
residue.insertion_code)
if resName in PDBFile._atomNameReplacements:
atomReplacements = PDBFile._atomNameReplacements[resName]
else:
atomReplacements = {}
for atom in residue.iter_atoms():
atomName = atom.get_name()
if atomName in atomReplacements:
atomName = atomReplacements[atomName]
atomName = atomName.strip()
element = atom.element
if element == 'EP':
element = None
elif element is None:
# Try to guess the element.
upper = atomName.upper()
while len(upper) > 1 and upper[0].isdigit():
upper = upper[1:]
if upper.startswith('CL'):
element = elem.chlorine
elif upper.startswith('NA'):
element = elem.sodium
elif upper.startswith('MG'):
element = elem.magnesium
elif upper.startswith('BE'):
element = elem.beryllium
elif upper.startswith('LI'):
element = elem.lithium
elif upper.startswith('K'):
element = elem.potassium
elif upper.startswith('ZN'):
element = elem.zinc
elif (len(residue) == 1 and upper.startswith('CA')):
element = elem.calcium
else:
try:
element = elem.get_by_symbol(upper[0])
except KeyError:
pass
newAtom = top.addAtom(atomName, element, r,
str(atom.serial_number))
atomByNumber[atom.serial_number] = newAtom
self._positions = []
for model in pdb.iter_models(True):
coords = []
for chain in model.iter_chains():
for residue in chain.iter_residues():
for atom in residue.iter_atoms():
pos = atom.get_position().value_in_unit(nanometers)
coords.append(Vec3(pos[0], pos[1], pos[2]))
self._positions.append(coords * nanometers)
## The atom positions read from the PDB file. If the file contains multiple frames, these are the positions in the first frame.
self.positions = self._positions[0]
self.topology.setPeriodicBoxVectors(pdb.get_periodic_box_vectors())
self.topology.createStandardBonds()
self.topology.createDisulfideBonds(self.positions)
self._numpyPositions = None
# Add bonds based on CONECT records. Bonds between metals of elements specified in metalElements and residues in standardResidues are not added.
connectBonds = []
for connect in pdb.models[-1].connects:
i = connect[0]
for j in connect[1:]:
if i in atomByNumber and j in atomByNumber:
if atomByNumber[i].element is not None and atomByNumber[
j].element is not None:
if atomByNumber[
i].element.symbol not in metalElements and atomByNumber[
j].element.symbol not in metalElements:
connectBonds.append(
(atomByNumber[i], atomByNumber[j]))
elif atomByNumber[
i].element.symbol in metalElements and atomByNumber[
j].residue.name not in PDBFile._standardResidues:
connectBonds.append(
(atomByNumber[i], atomByNumber[j]))
elif atomByNumber[
j].element.symbol in metalElements and atomByNumber[
i].residue.name not in PDBFile._standardResidues:
connectBonds.append(
(atomByNumber[i], atomByNumber[j]))
else:
connectBonds.append((atomByNumber[i], atomByNumber[j]))
if len(connectBonds) > 0:
# Only add bonds that don't already exist.
existingBonds = set(top.bonds())
for bond in connectBonds:
if bond not in existingBonds and (
bond[1], bond[0]) not in existingBonds:
top.addBond(bond[0], bond[1])
existingBonds.add(bond)
def __init__(self,
file,
unitCellDimensions=None,
includeDir='/usr/local/gromacs/share/gromacs/top',
defines={}):
"""Load a top file.
Parameters:
- file (string) the name of the file to load
- unitCellDimensions (Vec3=None) the dimensions of the crystallographic unit cell
- includeDir (string=/usr/local/gromacs/share/gromacs/top) a directory in which to look for other files
included from the top file
- defines (map={}) preprocessor definitions that should be predefined when parsing the file
"""
self._includeDirs = (os.path.dirname(file), includeDir)
self._defines = defines
# Parse the file.
self._currentCategory = None
self._ifStack = []
self._moleculeTypes = {}
self._molecules = []
self._currentMoleculeType = None
self._atomTypes = {}
self._bondTypes = {}
self._angleTypes = {}
self._dihedralTypes = {}
self._implicitTypes = {}
self._pairTypes = {}
self._cmapTypes = {}
self._processFile(file)
# Create the Topology from it.
top = Topology()
## The Topology read from the prmtop file
self.topology = top
top.setUnitCellDimensions(unitCellDimensions)
PDBFile._loadNameReplacementTables()
for moleculeName, moleculeCount in self._molecules:
if moleculeName not in self._moleculeTypes:
raise ValueError("Unknown molecule type: " + moleculeName)
moleculeType = self._moleculeTypes[moleculeName]
# Create the specified number of molecules of this type.
for i in range(moleculeCount):
atoms = []
lastResidue = None
c = top.addChain()
for index, fields in enumerate(moleculeType.atoms):
resNumber = fields[2]
if resNumber != lastResidue:
lastResidue = resNumber
resName = fields[3]
if resName in PDBFile._residueNameReplacements:
resName = PDBFile._residueNameReplacements[resName]
r = top.addResidue(resName, c)
if resName in PDBFile._atomNameReplacements:
atomReplacements = PDBFile._atomNameReplacements[
resName]
else:
atomReplacements = {}
atomName = fields[4]
if atomName in atomReplacements:
atomName = atomReplacements[atomName]
# Try to guess the element.
upper = atomName.upper()
if upper.startswith('CL'):
element = elem.chlorine
elif upper.startswith('NA'):
element = elem.sodium
elif upper.startswith('MG'):
element = elem.magnesium
else:
try:
element = elem.get_by_symbol(atomName[0])
except KeyError:
element = None
atoms.append(top.addAtom(atomName, element, r))
# Add bonds to the topology
for fields in moleculeType.bonds:
top.addBond(atoms[int(fields[0]) - 1],
atoms[int(fields[1]) - 1])
def _add_chain(self, topology):
# create chain
chain = topology.addChain()
# determine residue adding function
if self.forceField_str == 'TraPPE-UA':
add_residue_function = self._add_residue_trappeua
elif self.forceField_str == 'OPLS-AA':
add_residue_function = self._add_residue_to_chain_oplsaa
else:
raise ValueError("Invalid force field.")
# initialize previous residue atom
prev_res_atom = None
# add backbone
for i, monomer in enumerate(self.backbone):
# determine whether or not the residue is a terminal one
left_ter = False
right_ter = False
if i == 0:
left_ter = True
if i == len(self.backbone) - 1:
right_ter = True
# add residue
prev_res_atom = add_residue_function(topology, chain,
prev_res_atom, monomer,
left_ter, right_ter)
# add branches
for sequence, indices in self.branches:
residues = list(chain.residues())
for index in indices:
atom = self._find_atom_by_name('C1', residues[index])
atom.element = self.PHOSPHORUS
prev_res_atom = atom
for i, monomer in enumerate(sequence):
right_ter = i == len(sequence) - 1
prev_res_atom = add_residue_function(topology,
chain,
prev_res_atom,
monomer,
right_ter=right_ter)
# create pdb file
if self.pdb is None:
positions = self._create_positions_trappeua()
topology_pdb = Topology()
topology_pdb._chains.append(chain)
bc_num = 0
dirname = os.path.join(os.path.dirname(__file__), "data")
while os.path.exists(
os.path.join(dirname,
"branched_chain_{}.pdb".format(bc_num))):
bc_num += 1
self.pdb = os.path.join(dirname,
"branched_chain_{}.pdb".format(bc_num))
PDBFile.writeFile(topology_pdb, positions, open(self.pdb, 'w'))
def add_chain_to_topology(self, topology):
# Map chain id to sequence
id_to_sequence = {}
# Add specified number of chains
for _ in range(self.num):
# Initialize topology and positions array for creating chain pdb
topology_pdb = Topology()
positions = []
# Determine chain pdb
if self.id is not None:
chain_id = "{}-{}".format(topology.getNumChains() + 1, self.id)
else:
chain_id = "{}-{}".format(topology.getNumChains() + 1,
self.sequence_str)
# Create chain
chain = topology.addChain(id=chain_id)
chain_pdb = topology_pdb.addChain(id=chain_id)
# Add chain id and sequence to dictionary
id_to_sequence[chain.id] = self.sequence_str
# Initialize atom from previous residue
prev_res_atom = None
prev_res_atom_pdb = None
# Initialize pos of atom on previous residue
prev_res_atom_pos = np.array([0.0, 0.0, 0.0])
# Iterate through sequence to add residues to chain
for j in range(len(self.sequence)):
# String representation of monomer
monomer = self.sequence[j]
# Determine whether or not the residue is a terminal one
left_ter = False
right_ter = False
if j == 0:
left_ter = True
if j == len(self.sequence) - 1:
right_ter = True
# Add residue to chain
if self.forceField_str == 'TraPPE-UA':
add_residue_function = self._add_residue_to_chain_trappeua
elif self.forceField_str == 'OPLS-AA':
add_residue_function = self._add_residue_to_chain_oplsaa
else:
raise ValueError("Invalid force field.")
prev_res_atom, prev_res_atom_pdb, prev_res_atom_pos = add_residue_function(
topology, topology_pdb, chain, chain_pdb, prev_res_atom,
prev_res_atom_pdb, positions, prev_res_atom_pos, monomer,
left_ter, right_ter)
# Create pdb file for chain
if self.create_pdb:
self._create_chain_pdb(topology_pdb, positions)
return id_to_sequence
def convertWater(self, model='tip3p'):
"""Convert all water molecules to a different water model.
Parameters:
- model (string='tip3p') the water model to convert to. Supported values are 'tip3p', 'spce', 'tip4pew', and 'tip5p'.
@deprecated Use addExtraParticles() instead. It performs the same function but in a more general way.
"""
if model in ('tip3p', 'spce'):
sites = 3
elif model == 'tip4pew':
sites = 4
elif model == 'tip5p':
sites = 5
else:
raise ValueError('Unknown water model: %s' % model)
newTopology = Topology()
newTopology.setUnitCellDimensions(deepcopy(self.topology.getUnitCellDimensions()))
newAtoms = {}
newPositions = []*nanometer
for chain in self.topology.chains():
newChain = newTopology.addChain()
for residue in chain.residues():
newResidue = newTopology.addResidue(residue.name, newChain)
if residue.name == "HOH":
# Copy the oxygen and hydrogens
oatom = [atom for atom in residue.atoms() if atom.element == elem.oxygen]
hatoms = [atom for atom in residue.atoms() if atom.element == elem.hydrogen]
if len(oatom) != 1 or len(hatoms) != 2:
raise ValueError('Illegal water molecule (residue %d): contains %d oxygen(s) and %d hydrogen(s)' % (residue.index, len(oatom), len(hatoms)))
o = newTopology.addAtom(oatom[0].name, oatom[0].element, newResidue)
h1 = newTopology.addAtom(hatoms[0].name, hatoms[0].element, newResidue)
h2 = newTopology.addAtom(hatoms[1].name, hatoms[1].element, newResidue)
newAtoms[oatom[0]] = o
newAtoms[hatoms[0]] = h1
newAtoms[hatoms[1]] = h2
po = deepcopy(self.positions[oatom[0].index])
ph1 = deepcopy(self.positions[hatoms[0].index])
ph2 = deepcopy(self.positions[hatoms[1].index])
newPositions.append(po)
newPositions.append(ph1)
newPositions.append(ph2)
# Add virtual sites.
if sites == 4:
newTopology.addAtom('M', None, newResidue)
newPositions.append(0.786646558*po + 0.106676721*ph1 + 0.106676721*ph2)
elif sites == 5:
newTopology.addAtom('M1', None, newResidue)
newTopology.addAtom('M2', None, newResidue)
v1 = (ph1-po).value_in_unit(nanometer)
v2 = (ph2-po).value_in_unit(nanometer)
cross = Vec3(v1[1]*v2[2]-v1[2]*v2[1], v1[2]*v2[0]-v1[0]*v2[2], v1[0]*v2[1]-v1[1]*v2[0])
newPositions.append(po - (0.34490826*v1 - 0.34490826*v2 - 6.4437903*cross)*nanometer)
newPositions.append(po - (0.34490826*v1 - 0.34490826*v2 + 6.4437903*cross)*nanometer)
else:
# Just copy the residue over.
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]])
self.topology = newTopology
self.positions = newPositions
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
def __init__(self, file, periodicBoxVectors=None, unitCellDimensions=None, includeDir=None, defines=None):
"""Load a top file.
Parameters
----------
file : str
the name of the file to load
periodicBoxVectors : tuple of Vec3=None
the vectors defining the periodic box
unitCellDimensions : Vec3=None
the dimensions of the crystallographic unit cell. For
non-rectangular unit cells, specify periodicBoxVectors instead.
includeDir : string=None
A directory in which to look for other files included from the
top file. If not specified, we will attempt to locate a gromacs
installation on your system. When gromacs is installed in
/usr/local, this will resolve to /usr/local/gromacs/share/gromacs/top
defines : dict={}
preprocessor definitions that should be predefined when parsing the file
"""
if includeDir is None:
includeDir = _defaultGromacsIncludeDir()
self._includeDirs = (os.path.dirname(file), includeDir)
# Most of the gromacs water itp files for different forcefields,
# unless the preprocessor #define FLEXIBLE is given, don't define
# bonds between the water hydrogen and oxygens, but only give the
# constraint distances and exclusions.
self._defines = OrderedDict()
self._defines['FLEXIBLE'] = True
self._genpairs = True
if defines is not None:
for define, value in defines.iteritems():
self._defines[define] = value
# Parse the file.
self._currentCategory = None
self._ifStack = []
self._elseStack = []
self._moleculeTypes = {}
self._molecules = []
self._currentMoleculeType = None
self._atomTypes = {}
self._bondTypes= {}
self._angleTypes = {}
self._dihedralTypes = {}
self._implicitTypes = {}
self._pairTypes = {}
self._cmapTypes = {}
self._processFile(file)
# Create the Topology from it.
top = Topology()
## The Topology read from the prmtop file
self.topology = top
if periodicBoxVectors is not None:
if unitCellDimensions is not None:
raise ValueError("specify either periodicBoxVectors or unitCellDimensions, but not both")
top.setPeriodicBoxVectors(periodicBoxVectors)
else:
top.setUnitCellDimensions(unitCellDimensions)
PDBFile._loadNameReplacementTables()
for moleculeName, moleculeCount in self._molecules:
if moleculeName not in self._moleculeTypes:
raise ValueError("Unknown molecule type: "+moleculeName)
moleculeType = self._moleculeTypes[moleculeName]
if moleculeCount > 0 and moleculeType.has_virtual_sites:
raise ValueError('Virtual sites not yet supported by Gromacs parsers')
# Create the specified number of molecules of this type.
for i in range(moleculeCount):
atoms = []
lastResidue = None
c = top.addChain()
for index, fields in enumerate(moleculeType.atoms):
resNumber = fields[2]
if resNumber != lastResidue:
lastResidue = resNumber
resName = fields[3]
if resName in PDBFile._residueNameReplacements:
resName = PDBFile._residueNameReplacements[resName]
r = top.addResidue(resName, c)
if resName in PDBFile._atomNameReplacements:
atomReplacements = PDBFile._atomNameReplacements[resName]
else:
atomReplacements = {}
atomName = fields[4]
if atomName in atomReplacements:
atomName = atomReplacements[atomName]
# Try to guess the element.
upper = atomName.upper()
if upper.startswith('CL'):
element = elem.chlorine
elif upper.startswith('NA'):
element = elem.sodium
elif upper.startswith('MG'):
element = elem.magnesium
else:
try:
element = elem.get_by_symbol(atomName[0])
except KeyError:
element = None
atoms.append(top.addAtom(atomName, element, r))
# Add bonds to the topology
for fields in moleculeType.bonds:
top.addBond(atoms[int(fields[0])-1], atoms[int(fields[1])-1])
def _createTopology(self):
"""Build the topology of the system
"""
top = Topology()
positions = []
velocities = []
boxVectors = []
#assume cell dimensions are set in the first file
#the other molecules inherit the same cell
conn = self._conn[0]
self.pbc = False
if self._hasTable('global_cell', self._tables[0]):
for x, y, z in conn.execute('SELECT x, y, z FROM global_cell'):
boxVectors.append(mm.Vec3(x, y, z))
unitCellDimensions = [boxVectors[0][0], boxVectors[1][1], boxVectors[2][2]]
top.setUnitCellDimensions(unitCellDimensions*angstrom)
self.pbc = True
#process each file
nfiles = len(self._conn)
for (fcounter, conn, tables) in zip(range(0,nfiles),self._conn,self._tables):
"""
resdb = {}
chaindb = {}
"""
atoms = {}
lastChain = None
lastResId = None
c = top.addChain()
q = """SELECT id, name, anum, resname, resid, chain, x, y, z, vx, vy, vz
FROM particle ORDER BY id"""
for (atomId, atomName, atomNumber, resName, resId, chain, x, y, z, vx, vy, vz) in conn.execute(q):
"""
#more elegant way to assign atoms to residues
#but it works only if atoms in residues are contiguous
#due to the fact that openmm does not support non-contiguous residues
resuid = "%s:%s:%s" % (resName, resId, chain)
if resuid in resdb.keys():
r = resdb[resuid]
c = chaindb[chain]
else:
if chain in chaindb.keys():
c = chaindb[chain]
else:
c = top.addChain()
chaindb[chain] = c
r = top.addResidue(resName, c)
resdb[resuid] = r
"""
newChain = False
if chain != lastChain:
lastChain = chain
c = top.addChain()
newChain = True
if resId != lastResId or newChain:
lastResId = resId
if resName in PDBFile._residueNameReplacements:
resName = PDBFile._residueNameReplacements[resName]
r = top.addResidue(resName, c)
if resName in PDBFile._atomNameReplacements:
atomReplacements = PDBFile._atomNameReplacements[resName]
else:
atomReplacements = {}
if atomNumber == 0 and atomName.startswith('Vrt'):
elem = None
else:
elem = Element.getByAtomicNumber(atomNumber)
if atomName in atomReplacements:
atomName = atomReplacements[atomName]
atoms[atomId] = top.addAtom(atomName, elem, r)
positions.append(mm.Vec3(x, y, z))
velocities.append(mm.Vec3(vx, vy, vz))
self._natoms[fcounter] = len(atoms)
for p0, p1 in conn.execute('SELECT p0, p1 FROM bond'):
top.addBond(atoms[p0], atoms[p1])
positions = positions*angstrom
velocities = velocities*angstrom/picosecond
return top, positions, velocities
def __init__(self, file):
"""Load a PDB file.
The atom positions and Topology can be retrieved by calling getPositions() and getTopology().
Parameters:
- file (string) the name of the file to load
"""
top = Topology()
## The Topology read from the PDB file
self.topology = top
# Load the PDB file
if isinstance(file, PdbStructure):
pdb = file
else:
inputfile = file
if isinstance(file, str):
inputfile = open(file)
pdb = PdbStructure(inputfile, load_all_models=True)
PDBFile._loadNameReplacementTables()
# Build the topology
atomByNumber = {}
for chain in pdb.iter_chains():
c = top.addChain()
for residue in chain.iter_residues():
resName = residue.get_name()
if resName in PDBFile._residueNameReplacements:
resName = PDBFile._residueNameReplacements[resName]
r = top.addResidue(resName, c)
if resName in PDBFile._atomNameReplacements:
atomReplacements = PDBFile._atomNameReplacements[resName]
else:
atomReplacements = {}
for atom in residue.atoms:
atomName = atom.get_name()
if atomName in atomReplacements:
atomName = atomReplacements[atomName]
atomName = atomName.strip()
element = atom.element
if element is None:
# Try to guess the element.
upper = atomName.upper()
if upper.startswith('CL'):
element = elem.chlorine
elif upper.startswith('NA'):
element = elem.sodium
elif upper.startswith('MG'):
element = elem.magnesium
elif upper.startswith('BE'):
element = elem.beryllium
elif upper.startswith('LI'):
element = elem.lithium
elif upper.startswith('K'):
element = elem.potassium
elif (len(residue) == 1 and upper.startswith('CA')):
element = elem.calcium
else:
try:
element = elem.get_by_symbol(atomName[0])
except KeyError:
pass
newAtom = top.addAtom(atomName, element, r)
atomByNumber[atom.serial_number] = newAtom
self._positions = []
for model in pdb.iter_models(True):
coords = []
for chain in model.iter_chains():
for residue in chain.iter_residues():
for atom in residue.atoms:
pos = atom.get_position().value_in_unit(nanometers)
coords.append(Vec3(pos[0], pos[1], pos[2]))
self._positions.append(coords * nanometers)
## The atom positions read from the PDB file. If the file contains multiple frames, these are the positions in the first frame.
self.positions = self._positions[0]
self.topology.setUnitCellDimensions(pdb.get_unit_cell_dimensions())
self.topology.createStandardBonds()
self.topology.createDisulfideBonds(self.positions)
self._numpyPositions = None
# Add bonds based on CONECT records.
connectBonds = []
for connect in pdb.models[0].connects:
i = connect[0]
for j in connect[1:]:
if i in atomByNumber and j in atomByNumber:
connectBonds.append((atomByNumber[i], atomByNumber[j]))
if len(connectBonds) > 0:
# Only add bonds that don't already exist.
existingBonds = set(top.bonds())
for bond in connectBonds:
if bond not in existingBonds and (
bond[1], bond[0]) not in existingBonds:
top.addBond(bond[0], bond[1])
existingBonds.add(bond)
def __init__(self, file, unitCellDimensions=None, includeDir='/usr/local/gromacs/share/gromacs/top', defines={}):
"""Load a top file.
Parameters:
- file (string) the name of the file to load
- unitCellDimensions (Vec3=None) the dimensions of the crystallographic unit cell
- includeDir (string=/usr/local/gromacs/share/gromacs/top) a directory in which to look for other files
included from the top file
- defines (map={}) preprocessor definitions that should be predefined when parsing the file
"""
self._includeDirs = (os.path.dirname(file), includeDir)
self._defines = defines
# Parse the file.
self._currentCategory = None
self._ifStack = []
self._moleculeTypes = {}
self._molecules = []
self._currentMoleculeType = None
self._atomTypes = {}
self._bondTypes= {}
self._angleTypes = {}
self._dihedralTypes = {}
self._implicitTypes = {}
self._pairTypes = {}
self._cmapTypes = {}
self._processFile(file)
# Create the Topology from it.
top = Topology()
## The Topology read from the prmtop file
self.topology = top
top.setUnitCellDimensions(unitCellDimensions)
PDBFile._loadNameReplacementTables()
for moleculeName, moleculeCount in self._molecules:
if moleculeName not in self._moleculeTypes:
raise ValueError("Unknown molecule type: "+moleculeName)
moleculeType = self._moleculeTypes[moleculeName]
# Create the specified number of molecules of this type.
for i in range(moleculeCount):
atoms = []
lastResidue = None
c = top.addChain()
for index, fields in enumerate(moleculeType.atoms):
resNumber = fields[2]
if resNumber != lastResidue:
lastResidue = resNumber
resName = fields[3]
if resName in PDBFile._residueNameReplacements:
resName = PDBFile._residueNameReplacements[resName]
r = top.addResidue(resName, c)
if resName in PDBFile._atomNameReplacements:
atomReplacements = PDBFile._atomNameReplacements[resName]
else:
atomReplacements = {}
atomName = fields[4]
if atomName in atomReplacements:
atomName = atomReplacements[atomName]
# Try to guess the element.
upper = atomName.upper()
if upper.startswith('CL'):
element = elem.chlorine
elif upper.startswith('NA'):
element = elem.sodium
elif upper.startswith('MG'):
element = elem.magnesium
else:
try:
element = elem.get_by_symbol(atomName[0])
except KeyError:
element = None
atoms.append(top.addAtom(atomName, element, r))
# Add bonds to the topology
for fields in moleculeType.bonds:
top.addBond(atoms[int(fields[0])-1], atoms[int(fields[1])-1])
def __init__(self, file):
"""Load a PDBx/mmCIF file.
The atom positions and Topology can be retrieved by calling getPositions() and getTopology().
Parameters:
- file (string) the name of the file to load. Alternatively you can pass an open file object.
"""
top = Topology()
## The Topology read from the PDBx/mmCIF file
self.topology = top
self._positions = []
# Load the file.
inputFile = file
if isinstance(file, str):
inputFile = open(file)
reader = PdbxReader(inputFile)
data = []
reader.read(data)
block = data[0]
# Build the topology.
atomData = block.getObj('atom_site')
atomNameCol = atomData.getAttributeIndex('label_atom_id')
atomIdCol = atomData.getAttributeIndex('id')
resNameCol = atomData.getAttributeIndex('label_comp_id')
resIdCol = atomData.getAttributeIndex('label_seq_id')
resNumCol = atomData.getAttributeIndex('auth_seq_id')
asymIdCol = atomData.getAttributeIndex('label_asym_id')
chainIdCol = atomData.getAttributeIndex('label_entity_id')
elementCol = atomData.getAttributeIndex('type_symbol')
altIdCol = atomData.getAttributeIndex('label_alt_id')
modelCol = atomData.getAttributeIndex('pdbx_PDB_model_num')
xCol = atomData.getAttributeIndex('Cartn_x')
yCol = atomData.getAttributeIndex('Cartn_y')
zCol = atomData.getAttributeIndex('Cartn_z')
lastChainId = None
lastResId = None
lastAsymId = None
atomTable = {}
atomsInResidue = set()
models = []
for row in atomData.getRowList():
atomKey = ((row[resIdCol], row[asymIdCol], row[atomNameCol]))
model = ('1' if modelCol == -1 else row[modelCol])
if model not in models:
models.append(model)
self._positions.append([])
modelIndex = models.index(model)
if row[altIdCol] != '.' and atomKey in atomTable and len(
self._positions[modelIndex]) > atomTable[atomKey].index:
# This row is an alternate position for an existing atom, so ignore it.
continue
if modelIndex == 0:
# This row defines a new atom.
if lastChainId != row[chainIdCol]:
# The start of a new chain.
chain = top.addChain(row[asymIdCol])
lastChainId = row[chainIdCol]
lastResId = None
lastAsymId = None
if lastResId != row[resIdCol] or lastAsymId != row[
asymIdCol] or (lastResId == '.'
and row[atomNameCol] in atomsInResidue):
# The start of a new residue.
res = top.addResidue(
row[resNameCol], chain,
None if resNumCol == -1 else row[resNumCol])
lastResId = row[resIdCol]
lastAsymId = row[asymIdCol]
atomsInResidue.clear()
element = None
try:
element = elem.get_by_symbol(row[elementCol])
except KeyError:
pass
atom = top.addAtom(row[atomNameCol], element, res,
row[atomIdCol])
atomTable[atomKey] = atom
atomsInResidue.add(row[atomNameCol])
else:
# This row defines coordinates for an existing atom in one of the later models.
try:
atom = atomTable[atomKey]
except KeyError:
raise ValueError(
'Unknown atom %s in residue %s %s for model %s' %
(row[atomNameCol], row[resNameCol], row[resIdCol],
model))
if atom.index != len(self._positions[modelIndex]):
raise ValueError(
'Atom %s for model %s does not match the order of atoms for model %s'
% (row[atomIdCol], model, models[0]))
self._positions[modelIndex].append(
Vec3(float(row[xCol]), float(row[yCol]), float(row[zCol])) *
0.1)
for i in range(len(self._positions)):
self._positions[i] = self._positions[i] * nanometers
## The atom positions read from the PDBx/mmCIF file. If the file contains multiple frames, these are the positions in the first frame.
self.positions = self._positions[0]
self.topology.createStandardBonds()
self._numpyPositions = None
# Record unit cell information, if present.
cell = block.getObj('cell')
if cell is not None and cell.getRowCount() > 0:
row = cell.getRow(0)
(a, b, c) = [
float(row[cell.getAttributeIndex(attribute)]) * 0.1
for attribute in ('length_a', 'length_b', 'length_c')
]
(alpha, beta, gamma) = [
float(row[cell.getAttributeIndex(attribute)]) * math.pi / 180.0
for attribute in ('angle_alpha', 'angle_beta', 'angle_gamma')
]
self.topology.setPeriodicBoxVectors(
computePeriodicBoxVectors(a, b, c, alpha, beta, gamma))
# Add bonds based on struct_conn records.
connectData = block.getObj('struct_conn')
if connectData is not None:
res1Col = connectData.getAttributeIndex('ptnr1_label_seq_id')
res2Col = connectData.getAttributeIndex('ptnr2_label_seq_id')
atom1Col = connectData.getAttributeIndex('ptnr1_label_atom_id')
atom2Col = connectData.getAttributeIndex('ptnr2_label_atom_id')
asym1Col = connectData.getAttributeIndex('ptnr1_label_asym_id')
asym2Col = connectData.getAttributeIndex('ptnr2_label_asym_id')
typeCol = connectData.getAttributeIndex('conn_type_id')
connectBonds = []
for row in connectData.getRowList():
type = row[typeCol][:6]
if type in ('covale', 'disulf', 'modres'):
key1 = (row[res1Col], row[asym1Col], row[atom1Col])
key2 = (row[res2Col], row[asym2Col], row[atom2Col])
if key1 in atomTable and key2 in atomTable:
connectBonds.append((atomTable[key1], atomTable[key2]))
if len(connectBonds) > 0:
# Only add bonds that don't already exist.
existingBonds = set(top.bonds())
for bond in connectBonds:
if bond not in existingBonds and (
bond[1], bond[0]) not in existingBonds:
top.addBond(bond[0], bond[1])
existingBonds.add(bond)
class OpenMMAmberParm(AmberParm):
"""
OpenMM-compatible subclass of AmberParm. This object should still work with
the ParmEd API while also being compatible with OpenMM's environment
"""
# Define default force groups for all of the bonded terms. This allows them
# to be turned on and off selectively. This is a way to implement per-term
# energy decomposition to compare individual components
BOND_FORCE_GROUP = 0
ANGLE_FORCE_GROUP = 1
DIHEDRAL_FORCE_GROUP = 2
NONBONDED_FORCE_GROUP = 3
GB_FORCE_GROUP = 3
def openmm_LJ(self):
"""
Same as fill_LJ, except it uses 0.5 for the LJ radius for H-atoms with
no vdW parameters (per OpenMM's standard)
Returns:
list, list : The 1st list is the list of all Rmin/2 terms. The
2nd is the list of all epsilon (or well depth) terms.
"""
LJ_radius = [] # empty LJ_radii so it can be re-filled
LJ_depth = [] # empty LJ_depths so it can be re-filled
one_sixth = 1 / 6 # we need to raise some numbers to the 1/6th power
ntypes = self.pointers['NTYPES']
acoef = self.parm_data['LENNARD_JONES_ACOEF']
bcoef = self.parm_data['LENNARD_JONES_BCOEF']
for i in range(ntypes):
lj_index = self.parm_data["NONBONDED_PARM_INDEX"][ntypes*i+i] - 1
if acoef[lj_index] < 1.0e-10:
LJ_radius.append(0.5)
LJ_depth.append(0)
else:
factor = (2 * acoef[lj_index] / bcoef[lj_index])
LJ_radius.append(pow(factor, one_sixth) * 0.5)
LJ_depth.append(bcoef[lj_index] / 2 / factor)
# Now check that we haven't modified any off-diagonals, since that will
# not work with OpenMM
for i in range(ntypes):
for j in range(ntypes):
idx = self.parm_data['NONBONDED_PARM_INDEX'][ntypes*i+j] - 1
rij = LJ_radius[i] + LJ_radius[j]
wdij = sqrt(LJ_depth[i] * LJ_depth[j])
a = acoef[idx]
b = bcoef[idx]
if a == 0 or b == 0:
if a != 0 or b != 0 or (wdij != 0 and rij != 0):
raise OpenMMError('Off-diagonal LJ modifications '
'detected. These are incompatible '
'with the OpenMM API')
elif (abs((a - (wdij * rij**12)) / a) > 1e-6 or
abs((b - (2 * wdij * rij**6)) / b) > 1e-6):
raise OpenMMError(
'Off-diagonal LJ modifications detected. These are '
'incompatible with the OpenMM API. Acoef=%s; '
'computed=%s. Bcoef=%s; computed=%s' %
(acoef, wdij*rij**12, bcoef, 2*wdij*rij**6)
)
return LJ_radius, LJ_depth
def openmm_14_LJ(self):
"""
Returns the radii and depths for the LJ interactions between 1-4 pairs.
For Amber topology files this is the same as the normal LJ parameters,
but is done here so that OpenMMChamberParm can inherit and override this
behavior without having to duplicate all of the system creation code.
"""
return self.openmm_LJ()
@property
def topology(self):
"""
The OpenMM Topology object. Cached when possible, but any changes to the
topology object lists results in the topology being deleted and rebuilt
"""
# If anything changed, rebuild the topology
if not self._topology_changed():
try:
return self._topology
except AttributeError:
pass
else:
self.remake_parm()
self._topology = Topology()
# Add all of the atoms to the topology file in the same chain
chain = self._topology.addChain()
last_residue = None
for i, atm in enumerate(self.atom_list):
resnum = atm.residue.idx
if last_residue != resnum:
last_residue = resnum
resname = atm.residue.resname
res = self._topology.addResidue(resname, chain)
elem = element.get_by_symbol(pt.Element[atm.element])
self._topology.addAtom(atm.atname, elem, res)
# Add bonds to the topology (both with and without hydrogen)
atoms = list(self._topology.atoms())
for bnd in self.bonds_inc_h + self.bonds_without_h:
self._topology.addBond(atoms[bnd.atom1.starting_index],
atoms[bnd.atom2.starting_index])
# Set the box dimensions
if self.ptr('ifbox'):
if hasattr(self, 'rst7'):
self._topology.setUnitCellDimensions(
self.rst7.box[:3]*u.angstrom
)
else:
self._topology.setUnitCellDimensions(
self.parm_data['BOX_DIMENSIONS'][1:4]*u.angstrom
)
return self._topology
def _get_gb_params(self, gb_model=HCT):
""" Gets the GB parameters. Need this method to special-case GB neck """
if gb_model is GBn:
screen = [0.5 for atom in self.atom_list]
for i, atom in enumerate(self.atom_list):
if atom.element == 6:
screen[i] = 0.48435382330
elif atom.element == 1:
screen[i] = 1.09085413633
elif atom.element == 7:
screen[i] = 0.700147318409
elif atom.element == 8:
screen[i] = 1.06557401132
elif atom.element == 16:
screen[i] = 0.602256336067
elif gb_model is GBn2:
# Add non-optimized values as defaults
alpha = [1.0 for i in self.atom_list]
beta = [0.8 for i in self.atom_list]
gamma = [4.85 for i in self.atom_list]
screen = [0.5 for i in self.atom_list]
for i, atom in enumerate(self.atom_list):
if atom.element == 6:
screen[i] = 1.058554
alpha[i] = 0.733756
beta[i] = 0.506378
gamma[i] = 0.205844
elif atom.element == 1:
screen[i] = 1.425952
alpha[i] = 0.788440
beta[i] = 0.798699
gamma[i] = 0.437334
elif atom.element == 7:
screen[i] = 0.733599
alpha[i] = 0.503364
beta[i] = 0.316828
gamma[i] = 0.192915
elif atom.element == 8:
screen[i] = 1.061039
alpha[i] = 0.867814
beta[i] = 0.876635
gamma[i] = 0.387882
elif atom.element == 16:
screen[i] = -0.703469
alpha[i] = 0.867814
beta[i] = 0.876635
gamma[i] = 0.387882
else:
screen = self.parm_data['SCREEN']
length_conv = u.angstrom.conversion_factor_to(u.nanometer)
radii = [rad * length_conv for rad in self.parm_data['RADII']]
if gb_model is GBn2:
return zip(radii, screen, alpha, beta, gamma)
return zip(radii, screen)
def createSystem(self, nonbondedMethod=ff.NoCutoff,
nonbondedCutoff=1.0*u.nanometer,
constraints=None,
rigidWater=True,
implicitSolvent=None,
implicitSolventKappa=None,
implicitSolventSaltConc=0.0*u.moles/u.liter,
temperature=298.15*u.kelvin,
soluteDielectric=1.0,
solventDielectric=78.5,
removeCMMotion=True,
hydrogenMass=None,
ewaldErrorTolerance=0.0005,
flexibleConstraints=True,
verbose=False):
"""
Construct an OpenMM System representing the topology described by the
prmtop file.
Parameters:
- nonbondedMethod (object=NoCutoff) The method to use for nonbonded
interactions. Allowed values are NoCutoff, CutoffNonPeriodic,
CutoffPeriodic, Ewald, or PME.
- nonbondedCutoff (distance=1*nanometer) The cutoff distance to use
for nonbonded interactions.
- constraints (object=None) Specifies which bonds or angles should be
implemented with constraints. Allowed values are None, HBonds,
AllBonds, or HAngles.
- rigidWater (boolean=True) If true, water molecules will be fully
rigid regardless of the value passed for the constraints argument
- implicitSolvent (object=None) If not None, the implicit solvent
model to use. Allowed values are HCT, OBC1, OBC2, or GBn
- implicitSolventKappa (float=None): Debye screening parameter to
model salt concentrations in GB solvent.
- implicitSolventSaltConc (float=0.0*u.moles/u.liter): Salt
concentration for GB simulations. Converted to Debye length
`kappa'
- temperature (float=298.15*u.kelvin): Temperature used in the salt
concentration-to-kappa conversion for GB salt concentration term
- soluteDielectric (float=1.0) The solute dielectric constant to use
in the implicit solvent model.
- solventDielectric (float=78.5) The solvent dielectric constant to
use in the implicit solvent model.
- removeCMMotion (boolean=True) If true, a CMMotionRemover will be
added to the System.
- hydrogenMass (mass=None) The mass to use for hydrogen atoms bound to
heavy atoms. Any mass added to a hydrogen is subtracted from the
heavy atom to keep their total mass the same.
- ewaldErrorTolerance (float=0.0005) The error tolerance to use if the
nonbonded method is Ewald or PME.
- flexibleConstraints (bool=True) Are our constraints flexible or not?
- verbose (bool=False) Optionally prints out a running progress report
"""
# Rebuild the topology file if necessary, and flush the atom property
# data to the atom list
if self._topology_changed():
self.remake_parm()
else:
self.atom_list.refresh_data()
LJ_radius, LJ_depth = self.openmm_LJ() # Get our LJ parameters
LJ_14_radius, LJ_14_depth = self.openmm_14_LJ()
# Set the cutoff distance in nanometers
cutoff = None
if nonbondedMethod is not ff.NoCutoff:
cutoff = nonbondedCutoff
# Remove units from cutoff
if u.is_quantity(cutoff):
cutoff = cutoff.value_in_unit(u.nanometers)
if nonbondedMethod not in (ff.NoCutoff, ff.CutoffNonPeriodic,
ff.CutoffPeriodic, ff.Ewald, ff.PME):
raise ValueError('Illegal value for nonbonded method')
if self.ptr('ifbox') == 0 and nonbondedMethod in (ff.CutoffPeriodic,
ff.Ewald, ff.PME):
raise ValueError('Illegal nonbonded method for a '
'non-periodic system')
if implicitSolvent not in (HCT, OBC1, OBC2, GBn, GBn2, None):
raise ValueError('Illegal implicit solvent model choice.')
if not constraints in (None, ff.HAngles, ff.HBonds, ff.AllBonds):
raise ValueError('Illegal constraints choice')
# Define conversion factors
length_conv = u.angstrom.conversion_factor_to(u.nanometer)
_ambfrc = u.kilocalorie_per_mole/(u.angstrom*u.angstrom)
_openmmfrc = u.kilojoule_per_mole/(u.nanometer*u.nanometer)
bond_frc_conv = _ambfrc.conversion_factor_to(_openmmfrc)
_ambfrc = u.kilocalorie_per_mole/(u.radians*u.radians)
_openmmfrc = u.kilojoule_per_mole/(u.radians*u.radians)
angle_frc_conv = _ambfrc.conversion_factor_to(_openmmfrc)
dihe_frc_conv = u.kilocalorie_per_mole.conversion_factor_to(
u.kilojoule_per_mole)
ene_conv = dihe_frc_conv
# Create the system
system = mm.System()
if verbose: print('Adding particles...')
for mass in self.parm_data['MASS']:
system.addParticle(mass)
# Set up the constraints
if verbose and (constraints is not None and not rigidWater):
print('Adding constraints...')
if constraints in (ff.HBonds, ff.AllBonds, ff.HAngles):
for bond in self.bonds_inc_h:
system.addConstraint(bond.atom1.starting_index,
bond.atom2.starting_index,
bond.bond_type.req*length_conv)
if constraints in (ff.AllBonds, ff.HAngles):
for bond in self.bonds_without_h:
system.addConstraint(bond.atom1.starting_index,
bond.atom2.starting_index,
bond.bond_type.req*length_conv)
if rigidWater and constraints is None:
for bond in self.bonds_inc_h:
if (bond.atom1.residue.resname in WATNAMES and
bond.atom2.residue.resname in WATNAMES):
system.addConstraint(bond.atom1.starting_index,
bond.atom2.starting_index,
bond.bond_type.req*length_conv)
# Add Bond forces
if verbose: print('Adding bonds...')
force = mm.HarmonicBondForce()
force.setForceGroup(self.BOND_FORCE_GROUP)
if flexibleConstraints or (constraints not in (ff.HBonds, ff.AllBonds,
ff.HAngles)):
for bond in self.bonds_inc_h:
force.addBond(bond.atom1.starting_index,
bond.atom2.starting_index,
bond.bond_type.req*length_conv,
2*bond.bond_type.k*bond_frc_conv)
if flexibleConstraints or (constraints not in (ff.AllBonds,ff.HAngles)):
for bond in self.bonds_without_h:
force.addBond(bond.atom1.starting_index,
bond.atom2.starting_index,
bond.bond_type.req*length_conv,
2*bond.bond_type.k*bond_frc_conv)
system.addForce(force)
# Add Angle forces
if verbose: print('Adding angles...')
force = mm.HarmonicAngleForce()
force.setForceGroup(self.ANGLE_FORCE_GROUP)
if constraints is ff.HAngles:
num_constrained_bonds = system.getNumConstraints()
atom_constraints = [[]] * system.getNumParticles()
for i in range(num_constrained_bonds):
c = system.getConstraintParameters(i)
dist = c[2].value_in_unit(u.nanometer)
atom_constraints[c[0]].append((c[1], dist))
atom_constraints[c[1]].append((c[0], dist))
for angle in self.angles_inc_h:
if constraints is ff.HAngles:
a1 = angle.atom1.element
a2 = angle.atom2.element
a3 = angle.atom3.element
nh = int(a1==1) + int(a2==1) + int(a3==1)
constrained = (nh >= 2 or (nh == 1 and a2 == 8))
else:
constrained = False # no constraints
if constrained:
l1 = l2 = None
for bond in angle.atom2.bonds:
if bond.atom1 is angle.atom1 or bond.atom2 is angle.atom1:
l1 = bond.bond_type.req * length_conv
elif bond.atom1 is angle.atom3 or bond.atom2 is angle.atom3:
l2 = bond.bond_type.req * length_conv
# Compute the distance between the atoms and add a constraint
length = sqrt(l1*l1 + l2*l2 - 2*l1*l2*
cos(angle.angle_type.theteq))
system.addConstraint(bond.atom1.starting_index,
bond.atom2.starting_index, length)
if flexibleConstraints or not constrained:
force.addAngle(angle.atom1.starting_index,
angle.atom2.starting_index,
angle.atom3.starting_index,
angle.angle_type.theteq,
2*angle.angle_type.k*angle_frc_conv)
for angle in self.angles_without_h:
force.addAngle(angle.atom1.starting_index,
angle.atom2.starting_index,
angle.atom3.starting_index,
angle.angle_type.theteq,
2*angle.angle_type.k*angle_frc_conv)
system.addForce(force)
# Add dihedral forces
if verbose: print('Adding torsions...')
force = mm.PeriodicTorsionForce()
force.setForceGroup(self.DIHEDRAL_FORCE_GROUP)
for tor in self.dihedrals_inc_h + self.dihedrals_without_h:
force.addTorsion(tor.atom1.starting_index,
tor.atom2.starting_index,
tor.atom3.starting_index,
tor.atom4.starting_index,
int(tor.dihed_type.per),
tor.dihed_type.phase,
tor.dihed_type.phi_k*dihe_frc_conv)
system.addForce(force)
# Add nonbonded terms now
if verbose: print('Adding nonbonded interactions...')
force = mm.NonbondedForce()
force.setForceGroup(self.NONBONDED_FORCE_GROUP)
if self.ptr('ifbox') == 0: # non-periodic
if nonbondedMethod is ff.NoCutoff:
force.setNonbondedMethod(mm.NonbondedForce.NoCutoff)
elif nonbondedMethod is ff.CutoffNonPeriodic:
if cutoff is None:
raise ValueError('No cutoff value specified')
force.setNonbondedMethod(mm.NonbondedForce.CutoffNonPeriodic)
force.setCutoffDistance(cutoff)
else:
raise ValueError('Illegal nonbonded method for non-periodic '
'system')
else: # periodic
# Set up box vectors (from inpcrd if available, or fall back to
# prmtop definitions
system.setDefaultPeriodicBoxVectors(*self.box_vectors)
# Set cutoff
if cutoff is None:
# Compute cutoff automatically
box = self.box_lengths
min_box_width = min((box[0]/u.nanometers,
box[1]/u.nanometers,
box[2]/u.nanometers))
CLEARANCE_FACTOR = 0.97
cutoff = u.Quantity((min_box_width*CLEARANCE_FACTOR)/2.0,
u.nanometers)
if nonbondedMethod is not ff.NoCutoff:
force.setCutoffDistance(cutoff)
# Set nonbonded method.
if nonbondedMethod is ff.NoCutoff:
force.setNonbondedMethod(mm.NonbondedForce.NoCutoff)
elif nonbondedMethod is ff.CutoffNonPeriodic:
force.setNonbondedMethod(mm.NonbondedForce.CutoffNonPeriodic)
elif nonbondedMethod is ff.CutoffPeriodic:
force.setNonbondedMethod(mm.NonbondedForce.CutoffPeriodic)
elif nonbondedMethod is ff.Ewald:
force.setNonbondedMethod(mm.NonbondedForce.Ewald)
elif nonbondedMethod is ff.PME:
force.setNonbondedMethod(mm.NonbondedForce.PME)
else:
raise ValueError('Cutoff method is not understood')
if ewaldErrorTolerance is not None:
force.setEwaldErrorTolerance(ewaldErrorTolerance)
# Add per-particle nonbonded parameters (LJ params)
sigma_scale = 2**(-1/6) * 2
for i, atm in enumerate(self.atom_list):
force.addParticle(atm.charge,
sigma_scale*LJ_radius[atm.nb_idx-1]*length_conv,
LJ_depth[atm.nb_idx-1]*ene_conv)
# Add 1-4 interactions
excluded_atom_pairs = set() # save these pairs so we don't zero them out
sigma_scale = 2**(-1/6)
for tor in self.dihedrals_inc_h + self.dihedrals_without_h:
if min(tor.signs) < 0: continue # multi-terms and impropers
charge_prod = (tor.atom1.charge * tor.atom4.charge /
tor.dihed_type.scee)
epsilon = (sqrt(LJ_14_depth[tor.atom1.nb_idx-1] * ene_conv *
LJ_14_depth[tor.atom4.nb_idx-1] * ene_conv) /
tor.dihed_type.scnb)
sigma = (LJ_14_radius[tor.atom1.nb_idx-1] +
LJ_14_radius[tor.atom4.nb_idx-1])*length_conv*sigma_scale
force.addException(tor.atom1.starting_index,
tor.atom4.starting_index,
charge_prod, sigma, epsilon)
excluded_atom_pairs.add(
min( (tor.atom1.starting_index, tor.atom4.starting_index),
(tor.atom4.starting_index, tor.atom1.starting_index) )
)
# Add excluded atoms
for atom in self.atom_list:
# Exclude all bonds and angles
for atom2 in atom.bond_partners:
if atom2.starting_index > atom.starting_index:
force.addException(atom.starting_index,
atom2.starting_index, 0.0, 0.1, 0.0)
for atom2 in atom.angle_partners:
if atom2.starting_index > atom.starting_index:
force.addException(atom.starting_index,
atom2.starting_index, 0.0, 0.1, 0.0)
for atom2 in atom.exclusion_partners:
if atom2.starting_index > atom.starting_index:
force.addException(atom.starting_index,
atom2.starting_index, 0.0, 0.1, 0.0)
for atom2 in atom.dihedral_partners:
if atom2.starting_index <= atom.starting_index: continue
if ((atom.starting_index, atom2.starting_index) in
excluded_atom_pairs):
continue
force.addException(atom.starting_index,
atom2.starting_index, 0.0, 0.1, 0.0)
system.addForce(force)
# Add virtual sites for water
# First tag the residues that have an extra point in them
for res in self.residue_list: res.has_ep = False
ep = [atom for atom in self.atom_list if atom.atname in EPNAMES]
for atom in ep: atom.residue.has_ep = True
if len(ep) > 0:
numRes = ep[-1].residue.idx + 1
waterO = [[] for i in range(numRes)]
waterH = [[] for i in range(numRes)]
waterEP = [[] for i in range(numRes)]
for atom in self.atom_list:
if atom.residue.has_ep:
if atom.element == 8:
waterO[res].append(atom)
elif atom.element == 1:
waterH[res].append(atom)
elif atom.element == 0:
waterEP[res].append(atom)
# Record bond lengths for faster access
distOH = [None] * numRes
distHH = [None] * numRes
distOE = [None] * numRes
for bond in self.bonds_inc_h + self.bonds_without_h:
a1 = bond.atom1
a2 = bond.atom2
if a1.residue.has_ep:
res = a1.residue.idx
if a1.element == 1 or a2.element == 1:
if a1.element == 1 and a2.element == 1:
distHH[res] = bond.bond_type.req * u.angstroms
if a1.element == 8 or a2.element == 8:
distOH[res] = bond.bond_type.req * u.angstroms
elif ((a1.element == 8 or a2.element == 8) and
(a1.element == 0 or a2.element == 0)):
distOE[res] = bond.bond_type.req * u.angstroms
# Loop over residues and add the virtual points
out_of_plane_angle = 54.735 * u.degrees
cosOOP = u.cos(out_of_plane_angle)
sinOOP = u.sin(out_of_plane_angle)
for residue in self.residue_list:
if not residue.has_ep: continue
res = residue.idx
if len(waterO[res]) == 1 and len(waterH[res]) == 2:
if len(waterEP[res]) == 1:
# 4-point water
weightH = distOE[res] / sqrt(distOH[res] * distOH[res] -
0.25 * distHH[res] * distHH[res])
system.setVirtualSite(
waterEP[res][0],
mm.ThreeParticleAverageSite(waterO[res][0],
waterH[res][0], waterH[res][1],
1-weightH, weightH/2, weightH/2)
)
elif len(waterEP[res]) == 2:
# 5-point water
weightH = (cosOOP * distOE[res] /
sqrt(distOH[res] * distOH[res] -
0.25 * distHH[res] * distHH[res])
)
angleHOH = 2 * asin(0.5 * distHH[res] / distOH[res])
lenCross = distOH[res] * distOH[res] * sin(angleHOH)
weightCross = sinOOP * distOE[res] / lenCross
site1 = mm.OutOfPlaneSite(waterO[res][0], waterH[res][0],
waterH[res][1], weightH/2, weightH/2, weightCross)
site2 = mm.OutOfPlaneSite(waterO[res][0], waterH[res][0],
waterH[res][1], weightH/2, weightH/2, -weightCross)
system.setVirtualSite(waterEP[res][0], site1)
system.setVirtualSite(waterEP[res][1], site2)
# Add GB model if we're doing one
if implicitSolvent is not None:
if verbose: print('Adding GB parameters...')
gb_parms = self._get_gb_params(implicitSolvent)
# If implicitSolventKappa is None, compute it from salt
# concentration
if implicitSolventKappa is None:
if u.is_quantity(implicitSolventSaltConc):
sc = implicitSolventSaltConc.value_in_unit(u.moles/u.liter)
implicitSolventSaltConc = sc
if u.is_quantity(temperature):
temperature = temperature.value_in_unit(u.kelvin)
# The constant is 1 / sqrt( epsilon_0 * kB / (2 * NA * q^2 *
# 1000) ) where NA is avogadro's number, epsilon_0 is the
# permittivity of free space, q is the elementary charge (this
# number matches sander/pmemd's kappa conversion factor)
implicitSolventKappa = 50.33355 * sqrt(implicitSolventSaltConc /
solventDielectric / temperature)
# Multiply by 0.73 to account for ion exclusions, and multiply
# by 10 to convert to 1/nm from 1/angstroms
implicitSolventKappa *= 7.3
elif implicitSolvent is None:
implicitSolventKappa = 0.0
if u.is_quantity(implicitSolventKappa):
implicitSolventKappa = implicitSolventKappa.value_in_unit(
(1.0/u.nanometer).unit)
if implicitSolvent is HCT:
gb = GBSAHCTForce(solventDielectric, soluteDielectric, None,
cutoff, kappa=implicitSolventKappa)
elif implicitSolvent is OBC1:
gb = GBSAOBC1Force(solventDielectric, soluteDielectric, None,
cutoff, kappa=implicitSolventKappa)
elif implicitSolvent is OBC2:
gb = GBSAOBC2Force(solventDielectric, soluteDielectric, None,
cutoff, kappa=implicitSolventKappa)
elif implicitSolvent is GBn:
gb = GBSAGBnForce(solventDielectric, soluteDielectric, None,
cutoff, kappa=implicitSolventKappa)
elif implicitSolvent is GBn2:
gb = GBSAGBn2Force(solventDielectric, soluteDielectric, None,
cutoff, kappa=implicitSolventKappa)
for i, atom in enumerate(self.atom_list):
gb.addParticle([atom.charge] + list(gb_parms[i]))
# Set cutoff method
if nonbondedMethod is ff.NoCutoff:
gb.setNonbondedMethod(mm.NonbondedForce.NoCutoff)
elif nonbondedMethod is ff.CutoffNonPeriodic:
gb.setNonbondedMethod(mm.NonbondedForce.CutoffNonPeriodic)
gb.setCutoffDistance(cutoff)
elif nonbondedMethod is ff.CutoffPeriodic:
gb.setNonbondedMethod(mm.NonbondedForce.CutoffPeriodic)
gb.setCutoffDistance(cutoff)
else:
raise ValueError('Illegal nonbonded method for use with GBSA')
gb.setForceGroup(self.GB_FORCE_GROUP)
system.addForce(gb)
force.setReactionFieldDielectric(1.0) # applies to NonbondedForce
# See if we repartition the hydrogen masses
if hydrogenMass is not None:
for bond in self.bonds_inc_h:
atom1, atom2 = bond.atom1, bond.atom2
if atom1.element == 1:
atom1, atom2 = atom2, atom1 # now atom2 is hydrogen for sure
if atom1.element != 1:
transfer_mass = hydrogenMass - atom2.mass
new_mass1 = (system.getParticleMass(atom1.index) -
transfer_mass)
system.setParticleMass(atom2.index, hydrogenMass)
system.setParticleMass(atom1.index, new_mass1)
# See if we want to remove COM motion
if removeCMMotion:
system.addForce(mm.CMMotionRemover())
# Cache our system for easy access
self._system = system
return system
@property
def system(self):
"""
Return the cached system class -- it needs to be initialized via
"createSystem" first!
"""
try:
return self._system
except AttributeError:
raise APIError('You must initialize the system with createSystem '
'before accessing the cached object.')
@property
def positions(self):
"""
Return the cached positions or create new ones from the atoms
"""
try:
if len(self._positions) == len(self.atom_list):
return self._positions
except AttributeError:
pass
self._positions = tuple([Vec3(a.xx, a.xy, a.xz)
for a in self.atom_list]) * u.angstroms
return self._positions
@positions.setter
def positions(self, stuff):
"""
Update the cached positions and assign the coordinates to the atoms
"""
self._positions = stuff
for i, pos in enumerate(stuff.value_in_unit(u.angstroms)):
i3 = i * 3
atom = self.atom_list[i]
atom.xx, atom.xy, atom.xz = pos
self.coords[i3], self.coords[i3+1], self.coords[i3+2] = pos
@property
def velocities(self):
""" Same as for positions, but for velocities """
try:
if len(self._velocities) == len(self.atom_list):
return self._velocities
except AttributeError:
pass
self._velocities = tuple([Vec3(a.vx, a.vy, a.vz)
for a in self.atom_list]) * (u.angstroms/u.picosecond)
return self._velocities
@velocities.setter
def velocities(self, stuff):
self._velocities = stuff
for atom, vel in zip(self.atom_list, stuff):
atom.vx, atom.vy, atom.vz = vel.value_in_unit(
u.angstroms/u.picoseconds)
@property
def box_vectors(self):
""" Return tuple of box vectors """
if hasattr(self, 'rst7'):
box = [x*u.angstrom for x in self.rst7.box[:3]]
ang = [self.rst7.box[3], self.rst7.box[4], self.rst7.box[5]]
return _box_vectors_from_lengths_angles(box[0], box[1], box[2],
ang[0], ang[1], ang[2])
else:
box = [x*u.angstrom for x in self.parm_data['BOX_DIMENSIONS'][1:]]
ang = [self.parm_data['BOX_DIMENSIONS'][0]] * 3
return _box_vectors_from_lengths_angles(box[0], box[1], box[2],
ang[0], ang[1], ang[2])
@property
def box_lengths(self):
""" Return tuple of 3 units """
if hasattr(self, 'rst7'):
box = [x*u.angstrom for x in self.rst7.box[:3]]
else:
box = [x*u.angstrom for x in self.parm_data['BOX_DIMENSIONS'][1:]]
return tuple(box)
def addExtraParticles(self, forcefield):
"""Add missing extra particles to the model that are required by a force field.
Some force fields use "extra particles" that do not represent actual atoms, but still need to be included in
the System. Examples include lone pairs, Drude particles, and the virtual sites used in some water models
to adjust the charge distribution. Extra particles can be recognized by the fact that their element is None.
This method is primarily used to add extra particles, but it can also remove them. It tries to match every
residue in the Topology to a template in the force field. If there is no match, it will both add and remove
extra particles as necessary to make it match.
Parameters:
- forcefield (ForceField) the ForceField defining what extra particles should be present
"""
# Create copies of all residue templates that have had all extra points removed.
templatesNoEP = {}
for resName, template in forcefield._templates.iteritems():
if any(atom.element is None for atom in template.atoms):
index = 0
newIndex = {}
newTemplate = ForceField._TemplateData(resName)
for i, atom in enumerate(template.atoms):
if atom.element is not None:
newIndex[i] = index
index += 1
newTemplate.atoms.append(ForceField._TemplateAtomData(atom.name, atom.type, atom.element))
for b1, b2 in template.bonds:
if b1 in newIndex and b2 in newIndex:
newTemplate.bonds.append((newIndex[b1], newIndex[b2]))
newTemplate.atoms[newIndex[b1]].bondedTo.append(newIndex[b2])
newTemplate.atoms[newIndex[b2]].bondedTo.append(newIndex[b1])
for b in template.externalBonds:
if b in newIndex:
newTemplate.externalBonds.append(newIndex[b])
templatesNoEP[template] = newTemplate
# Record which atoms are bonded to each other atom, with and without extra particles.
bondedToAtom = []
bondedToAtomNoEP = []
for atom in self.topology.atoms():
bondedToAtom.append(set())
bondedToAtomNoEP.append(set())
for atom1, atom2 in self.topology.bonds():
bondedToAtom[atom1.index].add(atom2.index)
bondedToAtom[atom2.index].add(atom1.index)
if atom1.element is not None and atom2.element is not None:
bondedToAtomNoEP[atom1.index].add(atom2.index)
bondedToAtomNoEP[atom2.index].add(atom1.index)
# If the force field has a DrudeForce, record the types of Drude particles and their parents since we'll
# need them for picking particle positions.
drudeTypeMap = {}
for force in forcefield._forces:
if isinstance(force, DrudeGenerator):
for type in force.typeMap:
drudeTypeMap[type] = force.typeMap[type][0]
# Create the new Topology.
newTopology = Topology()
newTopology.setUnitCellDimensions(deepcopy(self.topology.getUnitCellDimensions()))
newAtoms = {}
newPositions = []*nanometer
for chain in self.topology.chains():
newChain = newTopology.addChain()
for residue in chain.residues():
newResidue = newTopology.addResidue(residue.name, newChain)
# Look for a matching template.
matchFound = False
signature = _createResidueSignature([atom.element for atom in residue.atoms()])
if signature in forcefield._templateSignatures:
for t in forcefield._templateSignatures[signature]:
if _matchResidue(residue, t, bondedToAtom) is not None:
matchFound = True
if matchFound:
# Just copy the residue over.
for atom in residue.atoms():
newAtom = newTopology.addAtom(atom.name, atom.element, newResidue)
newAtoms[atom] = newAtom
newPositions.append(deepcopy(self.positions[atom.index]))
else:
# There's no matching template. Try to find one that matches based on everything except
# extra points.
template = None
residueNoEP = Residue(residue.name, residue.index, residue.chain)
residueNoEP._atoms = [atom for atom in residue.atoms() if atom.element is not None]
if signature in forcefield._templateSignatures:
for t in forcefield._templateSignatures[signature]:
if t in templatesNoEP:
matches = _matchResidue(residueNoEP, templatesNoEP[t], bondedToAtomNoEP)
if matches is not None:
template = t;
# Record the corresponding atoms.
matchingAtoms = {}
for atom, match in zip(residueNoEP.atoms(), matches):
templateAtomName = t.atoms[match].name
for templateAtom in template.atoms:
if templateAtom.name == templateAtomName:
matchingAtoms[templateAtom] = atom
break
if template is None:
raise ValueError('Residue %d (%s) does not match any template defined by the ForceField.' % (residue.index+1, residue.name))
# Add the regular atoms.
for atom in residue.atoms():
if atom.element is not None:
newAtoms[atom] = newTopology.addAtom(atom.name, atom.element, newResidue)
newPositions.append(deepcopy(self.positions[atom.index]))
# Add the extra points.
templateAtomPositions = len(template.atoms)*[None]
for index, atom in enumerate(template.atoms):
if atom in matchingAtoms:
templateAtomPositions[index] = self.positions[matchingAtoms[atom].index].value_in_unit(nanometer)
for index, atom in enumerate(template.atoms):
if atom.element is None:
newTopology.addAtom(atom.name, None, newResidue)
position = None
for site in template.virtualSites:
if site.index == index:
# This is a virtual site. Compute its position by the correct rule.
if site.type == 'average2':
position = site.weights[0]*templateAtomPositions[index+site.atoms[0]] + site.weights[1]*templateAtomPositions[index+site.atoms[1]]
elif site.type == 'average3':
position = site.weights[0]*templateAtomPositions[index+site.atoms[0]] + site.weights[1]*templateAtomPositions[index+site.atoms[1]] + site.weights[2]*templateAtomPositions[index+site.atoms[2]]
elif site.type == 'outOfPlane':
v1 = templateAtomPositions[index+site.atoms[1]] - templateAtomPositions[index+site.atoms[0]]
v2 = templateAtomPositions[index+site.atoms[2]] - templateAtomPositions[index+site.atoms[0]]
cross = Vec3(v1[1]*v2[2]-v1[2]*v2[1], v1[2]*v2[0]-v1[0]*v2[2], v1[0]*v2[1]-v1[1]*v2[0])
position = templateAtomPositions[index+site.atoms[0]] + site.weights[0]*v1 + site.weights[1]*v2 + site.weights[2]*cross
if position is None and atom.type in drudeTypeMap:
# This is a Drude particle. Put it on top of its parent atom.
for atom2, pos in zip(template.atoms, templateAtomPositions):
if atom2.type in drudeTypeMap[atom.type]:
position = deepcopy(pos)
if position is None:
# We couldn't figure out the correct position. As a wild guess, just put it at the center of the residue
# and hope that energy minimization will fix it.
knownPositions = [x for x in templateAtomPositions if x is not None]
position = sum(knownPositions)/len(knownPositions)
newPositions.append(position*nanometer)
for bond in self.topology.bonds():
if bond[0] in newAtoms and bond[1] in newAtoms:
newTopology.addBond(newAtoms[bond[0]], newAtoms[bond[1]])
self.topology = newTopology
self.positions = newPositions
def __init__(self, file):
"""Load a prmtop file."""
top = Topology()
## The Topology read from the prmtop file
self.topology = top
self.elements = []
# Load the prmtop file
prmtop = amber_file_parser.PrmtopLoader(file)
self._prmtop = prmtop
# Add atoms to the topology
PDBFile._loadNameReplacementTables()
lastResidue = None
c = top.addChain()
for index in range(prmtop.getNumAtoms()):
resNumber = prmtop.getResidueNumber(index)
if resNumber != lastResidue:
lastResidue = resNumber
resName = prmtop.getResidueLabel(iAtom=index).strip()
if resName in PDBFile._residueNameReplacements:
resName = PDBFile._residueNameReplacements[resName]
r = top.addResidue(resName, c)
if resName in PDBFile._atomNameReplacements:
atomReplacements = PDBFile._atomNameReplacements[resName]
else:
atomReplacements = {}
atomName = prmtop.getAtomName(index).strip()
if atomName in atomReplacements:
atomName = atomReplacements[atomName]
# Get the element from the prmtop file if available
if prmtop.has_atomic_number:
try:
element = elem.Element.getByAtomicNumber(
int(prmtop._raw_data['ATOMIC_NUMBER'][index]))
except KeyError:
element = None
else:
# Try to guess the element from the atom name.
upper = atomName.upper()
if upper.startswith('CL'):
element = elem.chlorine
elif upper.startswith('NA'):
element = elem.sodium
elif upper.startswith('MG'):
element = elem.magnesium
elif upper.startswith('ZN'):
element = elem.zinc
else:
try:
element = elem.get_by_symbol(atomName[0])
except KeyError:
element = None
top.addAtom(atomName, element, r)
self.elements.append(element)
# Add bonds to the topology
atoms = list(top.atoms())
for bond in prmtop.getBondsWithH():
top.addBond(atoms[bond[0]], atoms[bond[1]])
for bond in prmtop.getBondsNoH():
top.addBond(atoms[bond[0]], atoms[bond[1]])
# Set the periodic box size.
if prmtop.getIfBox():
top.setUnitCellDimensions(
tuple(
x.value_in_unit(unit.nanometer)
for x in prmtop.getBoxBetaAndDimensions()[1:4]) *
unit.nanometer)
def __init__(self, file):
"""Load a PDBx/mmCIF file.
The atom positions and Topology can be retrieved by calling
getPositions() and getTopology().
Parameters
----------
file : string
the name of the file to load. Alternatively you can pass an open
file object.
"""
top = Topology()
## The Topology read from the PDBx/mmCIF file
self.topology = top
self._positions = []
# Load the file.
inputFile = file
if isinstance(file, str):
inputFile = open(file)
reader = PdbxReader(inputFile)
data = []
reader.read(data)
block = data[0]
# Build the topology.
atomData = block.getObj('atom_site')
atomNameCol = atomData.getAttributeIndex('auth_atom_id')
atomIdCol = atomData.getAttributeIndex('id')
resNameCol = atomData.getAttributeIndex('auth_comp_id')
resNumCol = atomData.getAttributeIndex('auth_seq_id')
resInsertionCol = atomData.getAttributeIndex('pdbx_PDB_ins_code')
chainIdCol = atomData.getAttributeIndex('auth_asym_id')
elementCol = atomData.getAttributeIndex('type_symbol')
altIdCol = atomData.getAttributeIndex('label_alt_id')
modelCol = atomData.getAttributeIndex('pdbx_PDB_model_num')
xCol = atomData.getAttributeIndex('Cartn_x')
yCol = atomData.getAttributeIndex('Cartn_y')
zCol = atomData.getAttributeIndex('Cartn_z')
lastChainId = None
lastResId = None
atomTable = {}
atomsInResidue = set()
models = []
for row in atomData.getRowList():
atomKey = ((row[resNumCol], row[chainIdCol], row[atomNameCol]))
model = ('1' if modelCol == -1 else row[modelCol])
if model not in models:
models.append(model)
self._positions.append([])
modelIndex = models.index(model)
if row[altIdCol] != '.' and atomKey in atomTable and len(self._positions[modelIndex]) > atomTable[atomKey].index:
# This row is an alternate position for an existing atom, so ignore it.
continue
if modelIndex == 0:
# This row defines a new atom.
if lastChainId != row[chainIdCol]:
# The start of a new chain.
chain = top.addChain(row[chainIdCol])
lastChainId = row[chainIdCol]
lastResId = None
if lastResId != row[resNumCol] or lastChainId != row[chainIdCol] or (lastResId == '.' and row[atomNameCol] in atomsInResidue):
# The start of a new residue.
resId = (None if resNumCol == -1 else row[resNumCol])
resIC = ('' if resInsertionCol == -1 else row[resInsertionCol])
res = top.addResidue(row[resNameCol], chain, resId, resIC)
lastResId = row[resNumCol]
atomsInResidue.clear()
element = None
try:
element = elem.get_by_symbol(row[elementCol])
except KeyError:
pass
atom = top.addAtom(row[atomNameCol], element, res, row[atomIdCol])
atomTable[atomKey] = atom
atomsInResidue.add(row[atomNameCol])
else:
# This row defines coordinates for an existing atom in one of the later models.
try:
atom = atomTable[atomKey]
except KeyError:
raise ValueError('Unknown atom %s in residue %s %s for model %s' % (row[atomNameCol], row[resNameCol], row[resNumCol], model))
if atom.index != len(self._positions[modelIndex]):
raise ValueError('Atom %s for model %s does not match the order of atoms for model %s' % (row[atomIdCol], model, models[0]))
self._positions[modelIndex].append(Vec3(float(row[xCol]), float(row[yCol]), float(row[zCol]))*0.1)
for i in range(len(self._positions)):
self._positions[i] = self._positions[i]*nanometers
## The atom positions read from the PDBx/mmCIF file. If the file contains multiple frames, these are the positions in the first frame.
self.positions = self._positions[0]
self.topology.createStandardBonds()
self._numpyPositions = None
# Record unit cell information, if present.
cell = block.getObj('cell')
if cell is not None and cell.getRowCount() > 0:
row = cell.getRow(0)
(a, b, c) = [float(row[cell.getAttributeIndex(attribute)])*0.1 for attribute in ('length_a', 'length_b', 'length_c')]
(alpha, beta, gamma) = [float(row[cell.getAttributeIndex(attribute)])*math.pi/180.0 for attribute in ('angle_alpha', 'angle_beta', 'angle_gamma')]
self.topology.setPeriodicBoxVectors(computePeriodicBoxVectors(a, b, c, alpha, beta, gamma))
# Add bonds based on struct_conn records.
connectData = block.getObj('struct_conn')
if connectData is not None:
res1Col = connectData.getAttributeIndex('ptnr1_label_seq_id')
res2Col = connectData.getAttributeIndex('ptnr2_label_seq_id')
atom1Col = connectData.getAttributeIndex('ptnr1_label_atom_id')
atom2Col = connectData.getAttributeIndex('ptnr2_label_atom_id')
asym1Col = connectData.getAttributeIndex('ptnr1_label_asym_id')
asym2Col = connectData.getAttributeIndex('ptnr2_label_asym_id')
typeCol = connectData.getAttributeIndex('conn_type_id')
connectBonds = []
for row in connectData.getRowList():
type = row[typeCol][:6]
if type in ('covale', 'disulf', 'modres'):
key1 = (row[res1Col], row[asym1Col], row[atom1Col])
key2 = (row[res2Col], row[asym2Col], row[atom2Col])
if key1 in atomTable and key2 in atomTable:
connectBonds.append((atomTable[key1], atomTable[key2]))
if len(connectBonds) > 0:
# Only add bonds that don't already exist.
existingBonds = set(top.bonds())
for bond in connectBonds:
if bond not in existingBonds and (bond[1], bond[0]) not in existingBonds:
top.addBond(bond[0], bond[1])
existingBonds.add(bond)
def addSolvent(self, forcefield, model='tip3p', boxSize=None, padding=None, positiveIon='Na+', negativeIon='Cl-', ionicStrength=0*molar):
"""Add solvent (both water and ions) to the model to fill a rectangular box.
The algorithm works as follows:
1. Water molecules are added to fill the box.
2. Water molecules are removed if their distance to any solute atom is less than the sum of their van der Waals radii.
3. If the solute is charged, enough positive or negative ions are added to neutralize it. Each ion is added by
randomly selecting a water molecule and replacing it with the ion.
4. Ion pairs are added to give the requested total ionic strength.
The box size can be specified in three ways. First, you can explicitly give a box size to use. Alternatively, you can
give a padding distance. The largest dimension of the solute (along the x, y, or z axis) is determined, and a cubic
box of size (largest dimension)+2*padding is used. Finally, if neither a box size nor a padding distance is specified,
the existing Topology's unit cell dimensions are used.
Parameters:
- forcefield (ForceField) the ForceField to use for determining van der Waals radii and atomic charges
- model (string='tip3p') the water model to use. Supported values are 'tip3p', 'spce', 'tip4pew', and 'tip5p'.
- boxSize (Vec3=None) the size of the box to fill with water
- padding (distance=None) the padding distance to use
- positiveIon (string='Na+') the type of positive ion to add. Allowed values are 'Cs+', 'K+', 'Li+', 'Na+', and 'Rb+'
- negativeIon (string='Cl-') the type of negative ion to add. Allowed values are 'Cl-', 'Br-', 'F-', and 'I-'. Be aware
that not all force fields support all ion types.
- ionicString (concentration=0*molar) the total concentration of ions (both positive and negative) to add. This
does not include ions that are added to neutralize the system.
"""
# Pick a unit cell size.
if boxSize is not None:
if is_quantity(boxSize):
boxSize = boxSize.value_in_unit(nanometer)
box = Vec3(boxSize[0], boxSize[1], boxSize[2])*nanometer
elif padding is not None:
maxSize = max(max((pos[i] for pos in self.positions))-min((pos[i] for pos in self.positions)) for i in range(3))
box = (maxSize+2*padding)*Vec3(1, 1, 1)
else:
box = self.topology.getUnitCellDimensions()
if box is None:
raise ValueError('Neither the box size nor padding was specified, and the Topology does not define unit cell dimensions')
box = box.value_in_unit(nanometer)
invBox = Vec3(1.0/box[0], 1.0/box[1], 1.0/box[2])
# Identify the ion types.
posIonElements = {'Cs+':elem.cesium, 'K+':elem.potassium, 'Li+':elem.lithium, 'Na+':elem.sodium, 'Rb+':elem.rubidium}
negIonElements = {'Cl-':elem.chlorine, 'Br-':elem.bromine, 'F-':elem.fluorine, 'I-':elem.iodine}
if positiveIon not in posIonElements:
raise ValueError('Illegal value for positive ion: %s' % positiveIon)
if negativeIon not in negIonElements:
raise ValueError('Illegal value for negative ion: %s' % negativeIon)
positiveElement = posIonElements[positiveIon]
negativeElement = negIonElements[negativeIon]
# Load the pre-equilibrated water box.
vdwRadiusPerSigma = 0.5612310241546864907
if model == 'tip3p':
waterRadius = 0.31507524065751241*vdwRadiusPerSigma
elif model == 'spce':
waterRadius = 0.31657195050398818*vdwRadiusPerSigma
elif model == 'tip4pew':
waterRadius = 0.315365*vdwRadiusPerSigma
elif model == 'tip5p':
waterRadius = 0.312*vdwRadiusPerSigma
else:
raise ValueError('Unknown water model: %s' % model)
pdb = PDBFile(os.path.join(os.path.dirname(__file__), 'data', model+'.pdb'))
pdbTopology = pdb.getTopology()
pdbPositions = pdb.getPositions().value_in_unit(nanometer)
pdbResidues = list(pdbTopology.residues())
pdbBoxSize = pdbTopology.getUnitCellDimensions().value_in_unit(nanometer)
# Have the ForceField build a System for the solute from which we can determine van der Waals radii.
system = forcefield.createSystem(self.topology)
nonbonded = None
for i in range(system.getNumForces()):
if isinstance(system.getForce(i), NonbondedForce):
nonbonded = system.getForce(i)
if nonbonded is None:
raise ValueError('The ForceField does not specify a NonbondedForce')
cutoff = [nonbonded.getParticleParameters(i)[1].value_in_unit(nanometer)*vdwRadiusPerSigma+waterRadius for i in range(system.getNumParticles())]
waterCutoff = waterRadius
if len(cutoff) == 0:
maxCutoff = waterCutoff
else:
maxCutoff = max(waterCutoff, max(cutoff))
# Copy the solute over.
newTopology = Topology()
newTopology.setUnitCellDimensions(box)
newAtoms = {}
newPositions = []*nanometer
for chain in self.topology.chains():
newChain = newTopology.addChain()
for residue in chain.residues():
newResidue = newTopology.addResidue(residue.name, newChain)
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():
newTopology.addBond(newAtoms[bond[0]], newAtoms[bond[1]])
# Sort the solute atoms into cells for fast lookup.
if len(self.positions) == 0:
positions = []
else:
positions = self.positions.value_in_unit(nanometer)
cells = {}
numCells = tuple((max(1, int(floor(box[i]/maxCutoff))) for i in range(3)))
cellSize = tuple((box[i]/numCells[i] for i in range(3)))
for i in range(len(positions)):
cell = tuple((int(floor(positions[i][j]/cellSize[j]))%numCells[j] for j in range(3)))
if cell in cells:
cells[cell].append(i)
else:
cells[cell] = [i]
# Create a generator that loops over atoms close to a position.
def neighbors(pos):
centralCell = tuple((int(floor(pos[i]/cellSize[i])) for i in range(3)))
offsets = (-1, 0, 1)
for i in offsets:
for j in offsets:
for k in offsets:
cell = ((centralCell[0]+i+numCells[0])%numCells[0], (centralCell[1]+j+numCells[1])%numCells[1], (centralCell[2]+k+numCells[2])%numCells[2])
if cell in cells:
for atom in cells[cell]:
yield atom
# Define a function to compute the distance between two points, taking periodic boundary conditions into account.
def periodicDistance(pos1, pos2):
delta = pos1-pos2
delta = [delta[i]-floor(delta[i]*invBox[i]+0.5)*box[i] for i in range(3)]
return norm(delta)
# Find the list of water molecules to add.
newChain = newTopology.addChain()
if len(positions) == 0:
center = Vec3(0, 0, 0)
else:
center = [(max((pos[i] for pos in positions))+min((pos[i] for pos in positions)))/2 for i in range(3)]
center = Vec3(center[0], center[1], center[2])
numBoxes = [int(ceil(box[i]/pdbBoxSize[i])) for i in range(3)]
addedWaters = []
for boxx in range(numBoxes[0]):
for boxy in range(numBoxes[1]):
for boxz in range(numBoxes[2]):
offset = Vec3(boxx*pdbBoxSize[0], boxy*pdbBoxSize[1], boxz*pdbBoxSize[2])
for residue in pdbResidues:
oxygen = [atom for atom in residue.atoms() if atom.element == elem.oxygen][0]
atomPos = pdbPositions[oxygen.index]+offset
if not any((atomPos[i] > box[i] for i in range(3))):
# This molecule is inside the box, so see how close to it is to the solute.
atomPos += center-box/2
for i in neighbors(atomPos):
if periodicDistance(atomPos, positions[i]) < cutoff[i]:
break
else:
# Record this water molecule as one to add.
addedWaters.append((residue.index, atomPos))
# There could be clashes between water molecules at the box edges. Find ones to remove.
upperCutoff = center+box/2-Vec3(waterCutoff, waterCutoff, waterCutoff)
lowerCutoff = center-box/2+Vec3(waterCutoff, waterCutoff, waterCutoff)
lowerSkinPositions = [pos for index, pos in addedWaters if pos[0] < lowerCutoff[0] or pos[1] < lowerCutoff[1] or pos[2] < lowerCutoff[2]]
filteredWaters = []
cells = {}
for i in range(len(lowerSkinPositions)):
cell = tuple((int(floor(lowerSkinPositions[i][j]/cellSize[j]))%numCells[j] for j in range(3)))
if cell in cells:
cells[cell].append(i)
else:
cells[cell] = [i]
for entry in addedWaters:
pos = entry[1]
if pos[0] < upperCutoff[0] and pos[1] < upperCutoff[1] and pos[2] < upperCutoff[2]:
filteredWaters.append(entry)
else:
if not any((periodicDistance(lowerSkinPositions[i], pos) < waterCutoff and norm(lowerSkinPositions[i]-pos) > waterCutoff for i in neighbors(pos))):
filteredWaters.append(entry)
addedWaters = filteredWaters
# Add ions to neutralize the system.
totalCharge = int(floor(0.5+sum((nonbonded.getParticleParameters(i)[0].value_in_unit(elementary_charge) for i in range(system.getNumParticles())))))
if abs(totalCharge) > len(addedWaters):
raise Exception('Cannot neutralize the system because the charge is greater than the number of available positions for ions')
def addIon(element):
# Replace a water by an ion.
index = random.randint(0, len(addedWaters)-1)
newResidue = newTopology.addResidue(element.symbol.upper(), newChain)
newTopology.addAtom(element.symbol, element, newResidue)
newPositions.append(addedWaters[index][1]*nanometer)
del addedWaters[index]
for i in range(abs(totalCharge)):
addIon(positiveElement if totalCharge < 0 else negativeElement)
# Add ions based on the desired ionic strength.
numIons = len(addedWaters)*ionicStrength/(55.4*molar) # Pure water is about 55.4 molar (depending on temperature)
numPairs = int(floor(numIons/2+0.5))
for i in range(numPairs):
addIon(positiveElement)
for i in range(numPairs):
addIon(negativeElement)
# Add the water molecules.
for index, pos in addedWaters:
newResidue = newTopology.addResidue(residue.name, newChain)
residue = pdbResidues[index]
oxygen = [atom for atom in residue.atoms() if atom.element == elem.oxygen][0]
oPos = pdbPositions[oxygen.index]
molAtoms = []
for atom in residue.atoms():
molAtoms.append(newTopology.addAtom(atom.name, atom.element, newResidue))
newPositions.append((pos+pdbPositions[atom.index]-oPos)*nanometer)
for atom1 in molAtoms:
if atom1.element == elem.oxygen:
for atom2 in molAtoms:
if atom2.element == elem.hydrogen:
newTopology.addBond(atom1, atom2)
newTopology.setUnitCellDimensions(deepcopy(box)*nanometer)
self.topology = newTopology
self.positions = newPositions
# coding=utf-8
"""Pre-configured OpenMM Topology object for use with the default protons forcefield."""
from simtk.openmm.app import Topology
import os
PACKAGE_ROOT = os.path.abspath(os.path.dirname(__file__))
# Patch topology to unload standard bond definitions
def unloadStandardBonds(cls):
"""
Resets _standardBonds and _hasLoadedStandardBonds to original state.
"""
cls._hasLoadedStandardBonds = False
cls._standardBonds = dict()
Topology.unloadStandardBonds = classmethod(unloadStandardBonds)
Topology.unloadStandardBonds()
Topology.loadBondDefinitions(
os.path.join(PACKAGE_ROOT, "data", "bonds-amber10-constph.xml")
)
def __init__(self, file):
"""Load a prmtop file."""
top = Topology()
## The Topology read from the prmtop file
self.topology = top
self.elements = []
# Load the prmtop file
prmtop = amber_file_parser.PrmtopLoader(file)
self._prmtop = prmtop
# Add atoms to the topology
PDBFile._loadNameReplacementTables()
lastResidue = None
c = top.addChain()
for index in range(prmtop.getNumAtoms()):
resNumber = prmtop.getResidueNumber(index)
if resNumber != lastResidue:
lastResidue = resNumber
resName = prmtop.getResidueLabel(iAtom=index).strip()
if resName in PDBFile._residueNameReplacements:
resName = PDBFile._residueNameReplacements[resName]
r = top.addResidue(resName, c)
if resName in PDBFile._atomNameReplacements:
atomReplacements = PDBFile._atomNameReplacements[resName]
else:
atomReplacements = {}
atomName = prmtop.getAtomName(index).strip()
if atomName in atomReplacements:
atomName = atomReplacements[atomName]
# Get the element from the prmtop file if available
if prmtop.has_atomic_number:
try:
element = elem.Element.getByAtomicNumber(int(prmtop._raw_data['ATOMIC_NUMBER'][index]))
except KeyError:
element = None
else:
# Try to guess the element from the atom name.
upper = atomName.upper()
if upper.startswith('CL'):
element = elem.chlorine
elif upper.startswith('NA'):
element = elem.sodium
elif upper.startswith('MG'):
element = elem.magnesium
elif upper.startswith('ZN'):
element = elem.zinc
else:
try:
element = elem.get_by_symbol(atomName[0])
except KeyError:
element = None
top.addAtom(atomName, element, r)
self.elements.append(element)
# Add bonds to the topology
atoms = list(top.atoms())
for bond in prmtop.getBondsWithH():
top.addBond(atoms[bond[0]], atoms[bond[1]])
for bond in prmtop.getBondsNoH():
top.addBond(atoms[bond[0]], atoms[bond[1]])
# Set the periodic box size.
if prmtop.getIfBox():
box = prmtop.getBoxBetaAndDimensions()
top.setPeriodicBoxVectors(computePeriodicBoxVectors(*(box[1:4] + box[0:1]*3)))
def add(self, addTopology, addPositions):
"""Add chains, residues, atoms, and bonds to the model.
Specify what to add by providing a new Topology object and the corresponding atomic positions.
All chains, residues, atoms, and bonds contained in the Topology are added to the model.
Parameters:
- addTopoology (Topology) a Topology whose contents should be added to the model
- addPositions (list) the positions of the atoms to add
"""
# Copy over the existing model.
newTopology = Topology()
newTopology.setUnitCellDimensions(deepcopy(self.topology.getUnitCellDimensions()))
newAtoms = {}
newPositions = []*nanometer
for chain in self.topology.chains():
newChain = newTopology.addChain()
for residue in chain.residues():
newResidue = newTopology.addResidue(residue.name, newChain)
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():
newTopology.addBond(newAtoms[bond[0]], newAtoms[bond[1]])
# Add the new model
newAtoms = {}
for chain in addTopology.chains():
newChain = newTopology.addChain()
for residue in chain.residues():
newResidue = newTopology.addResidue(residue.name, newChain)
for atom in residue.atoms():
newAtom = newTopology.addAtom(atom.name, atom.element, newResidue)
newAtoms[atom] = newAtom
newPositions.append(deepcopy(addPositions[atom.index]))
for bond in addTopology.bonds():
newTopology.addBond(newAtoms[bond[0]], newAtoms[bond[1]])
self.topology = newTopology
self.positions = newPositions
def __init__(self, file):
"""Load a prmtop file."""
top = Topology()
## The Topology read from the prmtop file
self.topology = top
# Load the prmtop file
prmtop = amber_file_parser.PrmtopLoader(file)
self._prmtop = prmtop
# Add atoms to the topology
PDBFile._loadNameReplacementTables()
lastResidue = None
c = top.addChain()
for index in range(prmtop.getNumAtoms()):
resNumber = prmtop.getResidueNumber(index)
if resNumber != lastResidue:
lastResidue = resNumber
resName = prmtop.getResidueLabel(iAtom=index).strip()
if resName in PDBFile._residueNameReplacements:
resName = PDBFile._residueNameReplacements[resName]
r = top.addResidue(resName, c)
if resName in PDBFile._atomNameReplacements:
atomReplacements = PDBFile._atomNameReplacements[resName]
else:
atomReplacements = {}
atomName = prmtop.getAtomName(index).strip()
if atomName in atomReplacements:
atomName = atomReplacements[atomName]
# Try to guess the element.
upper = atomName.upper()
if upper.startswith('CL'):
element = elem.chlorine
elif upper.startswith('NA'):
element = elem.sodium
elif upper.startswith('MG'):
element = elem.magnesium
else:
try:
element = elem.get_by_symbol(atomName[0])
except KeyError:
element = None
top.addAtom(atomName, element, r)
# Add bonds to the topology
atoms = list(top.atoms())
for bond in prmtop.getBondsWithH():
top.addBond(atoms[bond[0]], atoms[bond[1]])
for bond in prmtop.getBondsNoH():
top.addBond(atoms[bond[0]], atoms[bond[1]])
# Set the periodic box size.
if prmtop.getIfBox():
top.setUnitCellDimensions(tuple(x.value_in_unit(unit.nanometer) for x in prmtop.getBoxBetaAndDimensions()[1:4])*unit.nanometer)
def __init__(self, file, extraParticleIdentifier='EP'):
"""Load a PDB file.
The atom positions and Topology can be retrieved by calling getPositions() and getTopology().
Parameters
----------
file : string
the name of the file to load
extraParticleIdentifier : string='EP'
if this value appears in the element column for an ATOM record, the Atom's element will be set to None to mark it as an extra particle
"""
metalElements = ['Al','As','Ba','Ca','Cd','Ce','Co','Cs','Cu','Dy','Fe','Gd','Hg','Ho','In','Ir','K','Li','Mg',
'Mn','Mo','Na','Ni','Pb','Pd','Pt','Rb','Rh','Sm','Sr','Te','Tl','V','W','Yb','Zn']
top = Topology()
## The Topology read from the PDB file
self.topology = top
# Load the PDB file
if isinstance(file, PdbStructure):
pdb = file
else:
inputfile = file
own_handle = False
if isinstance(file, str):
inputfile = open(file)
own_handle = True
pdb = PdbStructure(inputfile, load_all_models=True, extraParticleIdentifier=extraParticleIdentifier)
if own_handle:
inputfile.close()
PDBFile._loadNameReplacementTables()
# Build the topology
atomByNumber = {}
for chain in pdb.iter_chains():
c = top.addChain(chain.chain_id)
for residue in chain.iter_residues():
resName = residue.get_name()
if resName in PDBFile._residueNameReplacements:
resName = PDBFile._residueNameReplacements[resName]
r = top.addResidue(resName, c, str(residue.number))
if resName in PDBFile._atomNameReplacements:
atomReplacements = PDBFile._atomNameReplacements[resName]
else:
atomReplacements = {}
for atom in residue.atoms:
atomName = atom.get_name()
if atomName in atomReplacements:
atomName = atomReplacements[atomName]
atomName = atomName.strip()
element = atom.element
if element == 'EP':
element = None
elif element is None:
# Try to guess the element.
upper = atomName.upper()
while len(upper) > 1 and upper[0].isdigit():
upper = upper[1:]
if upper.startswith('CL'):
element = elem.chlorine
elif upper.startswith('NA'):
element = elem.sodium
elif upper.startswith('MG'):
element = elem.magnesium
elif upper.startswith('BE'):
element = elem.beryllium
elif upper.startswith('LI'):
element = elem.lithium
elif upper.startswith('K'):
element = elem.potassium
elif upper.startswith('ZN'):
element = elem.zinc
elif( len( residue ) == 1 and upper.startswith('CA') ):
element = elem.calcium
else:
try:
element = elem.get_by_symbol(upper[0])
except KeyError:
pass
newAtom = top.addAtom(atomName, element, r, str(atom.serial_number))
atomByNumber[atom.serial_number] = newAtom
self._positions = []
for model in pdb.iter_models(True):
coords = []
for chain in model.iter_chains():
for residue in chain.iter_residues():
for atom in residue.atoms:
pos = atom.get_position().value_in_unit(nanometers)
coords.append(Vec3(pos[0], pos[1], pos[2]))
self._positions.append(coords*nanometers)
## The atom positions read from the PDB file. If the file contains multiple frames, these are the positions in the first frame.
self.positions = self._positions[0]
self.topology.setPeriodicBoxVectors(pdb.get_periodic_box_vectors())
self.topology.createStandardBonds()
self.topology.createDisulfideBonds(self.positions)
self._numpyPositions = None
# Add bonds based on CONECT records. Bonds between metals of elements specified in metalElements and residues in standardResidues are not added.
connectBonds = []
for connect in pdb.models[-1].connects:
i = connect[0]
for j in connect[1:]:
if i in atomByNumber and j in atomByNumber:
if atomByNumber[i].element is not None and atomByNumber[j].element is not None:
if atomByNumber[i].element.symbol not in metalElements and atomByNumber[j].element.symbol not in metalElements:
connectBonds.append((atomByNumber[i], atomByNumber[j]))
elif atomByNumber[i].element.symbol in metalElements and atomByNumber[j].residue.name not in PDBFile._standardResidues:
connectBonds.append((atomByNumber[i], atomByNumber[j]))
elif atomByNumber[j].element.symbol in metalElements and atomByNumber[i].residue.name not in PDBFile._standardResidues:
connectBonds.append((atomByNumber[i], atomByNumber[j]))
else:
connectBonds.append((atomByNumber[i], atomByNumber[j]))
if len(connectBonds) > 0:
# Only add bonds that don't already exist.
existingBonds = set(top.bonds())
for bond in connectBonds:
if bond not in existingBonds and (bond[1], bond[0]) not in existingBonds:
top.addBond(bond[0], bond[1])
existingBonds.add(bond)
def remove_molecules(self, simulation_old, system_options, ensemble_options):
topology_old = simulation_old.topology
system_old = simulation_old.system
state = simulation_old.context.getState(getPositions=True, getVelocities=True)
positions_old = state.getPositions(asNumpy=True)
velocities_old = state.getVelocities(asNumpy=True)
periodic_box_vectors = state.getPeriodicBoxVectors(asNumpy=True)
# randomly determine which molecules are removed
removed_molecules = random.sample(range(topology_old.getNumChains()), self.numVoid)
# create new topology and dictionary mapping old atom indices to new atom indices
removed_atoms = []
topology_new = Topology()
old_to_new = {}
atom_index_new = 0
for chain_index, chain_old in enumerate(topology_old.chains()):
if chain_index not in removed_molecules:
chain_id = chain_old.id.split('-', 1)[-1]
chain_new = topology_new.addChain(id="{}-{}".format(topology_new.getNumChains()+1, chain_id))
for residue_old in chain_old.residues():
residue_new = topology_new.addResidue(residue_old.name, chain_new)
for atom_old in residue_old.atoms():
topology_new.addAtom(atom_old.name, atom_old.element, residue_new)
old_to_new[atom_old.index] = atom_index_new
atom_index_new += 1
else:
for atom_old in chain_old.atoms():
removed_atoms.append(atom_old.index)
# add bonds to new topology
atoms_new = list(topology_new.atoms())
for bond_old in topology_old.bonds():
atom1_index_old = bond_old[0].index
atom2_index_old = bond_old[1].index
try:
atom1_new = atoms_new[old_to_new[atom1_index_old]]
atom2_new = atoms_new[old_to_new[atom2_index_old]]
topology_new.addBond(atom1_new, atom2_new)
except KeyError:
pass
# set box vectors for topology
topology_new.setPeriodicBoxVectors(periodic_box_vectors)
# create system
system_new = system_options.create_system_with_new_topology(topology_new)
# check if old system had barostat and add to new system if applicable
if self._has_barostat(system_old):
barostat_old = self._get_barostat(system_old)
defaultPressure = barostat_old.getDefaultPressure()
defaultTemperature = barostat_old.getDefaultTemperature()
frequency = barostat_old.getFrequency()
if isinstance(barostat_old, MonteCarloAnisotropicBarostat):
scaleX = barostat_old.getScaleX()
scaleY = barostat_old.getScaleY()
scaleZ = barostat_old.getScaleZ()
barostat_new = MonteCarloAnisotropicBarostat(defaultPressure, defaultTemperature,
scaleX, scaleY, scaleZ, frequency)
else:
barostat_new = MonteCarloBarostat(defaultPressure, defaultTemperature, frequency)
system_new.addForce(barostat_new)
barostat_new.setForceGroup(system_new.getNumForces() - 1)
# create integrator
integrator = ensemble_options.create_integrator()
# create new positions and velocities arrays
positions_new = np.delete(positions_old, removed_atoms, axis=0)
velocities_new = np.delete(velocities_old, removed_atoms, axis=0)
# create new simulation
simulation_new = Simulation(topology_new, system_new, integrator)
simulation_new.context.setPositions(positions_new)
simulation_new.context.setVelocities(velocities_new)
simulation_new.context.setPeriodicBoxVectors(*periodic_box_vectors)
# move reporters from old simulation to new simulation
while simulation_old.reporters:
simulation_new.reporters.append(simulation_old.reporters.pop(0))
# create pdb file if specified
if self.file is not None:
PDBFile.writeFile(topology_new, positions_new, open(self.file, 'w'))
return simulation_new
