def _setupChain(self, circular, properties, conf):
self.atoms = []
self.bonds = []
for g in self.groups:
self.atoms.extend(g.atoms)
self.bonds.extend(g.bonds)
for i in range(len(self.groups)-1):
link1 = self.groups[i].chain_links[1]
link2 = self.groups[i+1].chain_links[0]
self.bonds.append(Bonds.Bond((link1, link2)))
if circular:
link1 = self.groups[-1].chain_links[1]
link2 = self.groups[0].chain_links[0]
self.bonds.append(Bonds.Bond((link1, link2)))
self.bonds = Bonds.BondList(self.bonds)
self.parent = None
self.type = None
self.configurations = {}
try:
self.name = properties['name']
del properties['name']
except KeyError:
self.name = ''
if conf:
conf.applyTo(self)
try:
self.translateTo(properties['position'])
del properties['position']
except KeyError:
pass
self.addProperties(properties)
def replaceResidue(self, r_old, r_new):
for a in r_old.atoms:
self.atoms.remove(a)
obsolete_bonds = []
for b in self.bonds:
if b.a1 in r_old.atoms or b.a2 in r_old.atoms:
obsolete_bonds.append(b)
for b in obsolete_bonds:
self.bonds.remove(b)
n = self.groups.index(r_old)
if n > 0:
for b in self.bonds.bondsOf(r_old.peptide.N):
self.bonds.remove(b)
if n < len(self.groups)-1:
for b in self.bonds.bondsOf(r_old.peptide.C):
self.bonds.remove(b)
PeptideChain.replaceResidue(self.part_of, r_old, r_new)
self.groups[n] = r_new
self.atoms.extend(r_new.atoms)
self.bonds.extend(r_new.bonds)
if n > 0:
self.bonds.append(Bonds.Bond((self.groups[n-1].peptide.C,
self.groups[n].peptide.N)))
if n < len(self.groups)-1:
self.bonds.append(Bonds.Bond((self.groups[n].peptide.C,
self.groups[n+1].peptide.N)))
def replaceResidue(self, r_old, r_new):
"""
:param r_old: the residue to be replaced (must be part of the chain)
:type r_old: Residue
:param r_new: the residue that replaces r_old
:type r_new: Residue
"""
n = self.groups.index(r_old)
for a in r_old.atoms:
self.atoms.remove(a)
obsolete_bonds = []
for b in self.bonds:
if b.a1 in r_old.atoms or b.a2 in r_old.atoms:
obsolete_bonds.append(b)
for b in obsolete_bonds:
self.bonds.remove(b)
r_old.parent = None
self.atoms.extend(r_new.atoms)
self.bonds.extend(r_new.bonds)
r_new.sequence_number = n + 1
if r_old.name.startswith(r_old.symbol):
r_new.name = r_new.symbol + r_old.name[len(r_old.symbol):]
else:
r_new.name = r_new.symbol + ` n + 1 `
r_new.parent = self
self.groups[n] = r_new
if n > 0:
peptide_old = self.bonds.bondsOf(r_old.peptide.N)
if peptide_old:
self.bonds.remove(peptide_old[0])
if not (self.groups[n - 1].isCTerminus()
or self.groups[n].isNTerminus()):
# ConnectedChain objects can have N/C-terminal
# residues inside the (virtual) chain, so the
# test is necessary.
self.bonds.append(
Bonds.Bond((self.groups[n - 1].peptide.C,
self.groups[n].peptide.N)))
if n < len(self.groups) - 1:
peptide_old = self.bonds.bondsOf(r_old.peptide.C)
if peptide_old:
self.bonds.remove(peptide_old[0])
if not (self.groups[n].isCTerminus()
or self.groups[n + 1].isNTerminus()):
self.bonds.append(
Bonds.Bond((self.groups[n].peptide.C,
self.groups[n + 1].peptide.N)))
if isinstance(self.parent, ChemicalObjects.Complex):
self.parent.recreateAtomList()
universe = self.universe()
if universe is not None:
universe._changed(True)
def __init__(self, m, ident, owner):
from MMTK import Bonds
self.chimeraMolecule = m
self.needParmchk = set([])
self.frcmod = None
self.atomMap = owner.atomMap
self.name = m.name
self.parent = None
self.type = None
self.groups = []
for r in m.residues:
v = self._findStandardResidue(r)
if v is None:
self._makeNonStandardResidue(r)
else:
self._makeStandardResidue(r, *v)
atoms = []
bonds = []
for g in self.groups:
atoms.extend(g.atoms)
bonds.extend(g.bonds)
from chimera import Bond
for b in m.bonds:
if b.display == Bond.Never:
continue
a0, a1 = b.atoms
if a0.residue is a1.residue:
continue
mb = Bonds.Bond((self.atomMap[a0], self.atomMap[a1]))
bonds.append(mb)
self.atoms = atoms
self.bonds = Bonds.BondList(bonds)
if self.needParmchk:
self._runParmchk(ident, owner.getTempDir())
def addGroup(self, group, bond_atom_pairs):
for a1, a2 in bond_atom_pairs:
o1 = a1.topLevelChemicalObject()
o2 = a2.topLevelChemicalObject()
if set([o1, o2]) != set([self, group]):
raise ValueError("bond %s-%s outside object" %
(str(a1), str(a2)))
self.groups.append(group)
self.atoms = self.atoms + group.atoms
group.parent = self
self.clearBondAttributes()
for a1, a2 in bond_atom_pairs:
self.bonds.append(Bonds.Bond((a1, a2)))
for b in group.bonds:
self.bonds.append(b)
def _addSSBridges(self, bonds):
for b in bonds:
cys1 = b[0]
if cys1.symbol.lower() == 'cyx':
cys_ss1 = cys1
else:
cys_ss1 = cys1._makeCystine()
self.replaceResidue(cys1, cys_ss1)
cys2 = b[1]
if cys2.symbol.lower() == 'cyx':
cys_ss2 = cys2
else:
cys_ss2 = cys2._makeCystine()
self.replaceResidue(cys2, cys_ss2)
self.bonds.append(Bonds.Bond((cys_ss1.sidechain.S_gamma,
cys_ss2.sidechain.S_gamma)))
def __init__(self, chain, groups, name = ''):
self.groups = groups
self.atoms = []
self.bonds = []
for g in self.groups:
self.atoms = self.atoms + g.atoms
self.bonds = self.bonds + g.bonds
for i in range(len(self.groups)-1):
self.bonds.append(Bonds.Bond((self.groups[i].sugar.O_3,
self.groups[i+1].phosphate.P)))
self.bonds = Bonds.BondList(self.bonds)
self.name = name
self.parent = chain.parent
self.type = None
self.configurations = {}
self.part_of = chain
def __init__(self, chain=None, groups=None, name = ''):
if chain is not None:
self.groups = groups
self.atoms = []
self.bonds = []
for g in self.groups:
self.atoms.extend(g.atoms)
self.bonds.extend(g.bonds)
for i in range(len(self.groups)-1):
link1 = self.groups[i].chain_links[1]
link2 = self.groups[i+1].chain_links[0]
self.bonds.append(Bonds.Bond((link1, link2)))
self.bonds = Bonds.BondList(self.bonds)
self.name = name
self.model = chain.model
self.parent = chain.parent
self.type = None
self.configurations = {}
self.part_of = chain
def makeChemicalObjects(self, template, top_level):
self.groups[template.name].locked = True
if top_level:
if template.attributes.has_key('sequence'):
object = ChemicalObjects.ChainMolecule(None)
else:
object = ChemicalObjects.Molecule(None)
else:
object = ChemicalObjects.Group(None)
object.atoms = []
object.bonds = Bonds.BondList([])
object.groups = []
object.type = self.groups[template.name]
object.parent = None
child_objects = []
for child in template.children:
if isinstance(child, GroupTemplate):
group = self.makeChemicalObjects(child, False)
object.groups.append(group)
object.atoms.extend(group.atoms)
object.bonds.extend(group.bonds)
group.parent = object
child_objects.append(group)
else:
atom = ChemicalObjects.Atom(child.element)
object.atoms.append(atom)
atom.parent = object
child_objects.append(atom)
for name, index in template.names.items():
setattr(object, name, child_objects[index])
child_objects[index].name = name
for name, value in template.attributes.items():
path = name.split('.')
setattr(self.namePath(object, path[:-1]), path[-1], value)
for atom1, atom2 in template.bonds:
atom1 = self.namePath(object, atom1)
atom2 = self.namePath(object, atom2)
object.bonds.append(Bonds.Bond((atom1, atom2)))
for name, vector in template.positions.items():
path = name.split('.')
self.namePath(object, path).setPosition(vector)
return object