def __init__(self, blueprint, memo = None):
if type(blueprint) is type(()):
self.a1 = blueprint[0]
self.a2 = blueprint[1]
else:
self.a1 = Database.instantiate(blueprint.a1, memo)
self.a2 = Database.instantiate(blueprint.a2, memo)
if Utility.uniqueID(self.a2) < Utility.uniqueID(self.a1):
self.a1, self.a2 = self.a2, self.a1
Utility.uniqueID.registerObject(self)
def __init__(self, blueprint, memo=None):
if type(blueprint) is type(()):
self.a1 = blueprint[0]
self.a2 = blueprint[1]
else:
self.a1 = Database.instantiate(blueprint.a1, memo)
self.a2 = Database.instantiate(blueprint.a2, memo)
if Utility.uniqueID(self.a2) < Utility.uniqueID(self.a1):
self.a1, self.a2 = self.a2, self.a1
Utility.uniqueID.registerObject(self)
def __init__(self, blueprint, memo):
if isinstance(blueprint, basestring):
blueprint = self.blueprintclass(blueprint)
self.type = blueprint.type
if hasattr(blueprint, 'name'):
self.name = blueprint.name
if memo is None: memo = {}
memo[id(blueprint)] = self
for attr in blueprint.instance:
setattr(self, attr,
Database.instantiate(getattr(blueprint, attr), memo))
def __init__(self, blueprint, memo):
if isinstance(blueprint, basestring):
blueprint = self.blueprintclass(blueprint)
self.type = blueprint.type
if hasattr(blueprint, 'name'):
self.name = blueprint.name
if memo is None: memo = {}
memo[id(blueprint)] = self
for attr in blueprint.instance:
setattr(self, attr,
Database.instantiate(getattr(blueprint, attr), memo))
def _residueBlueprint(name, model):
try:
blueprint = _residue_blueprints[(name, model)]
except KeyError:
if model == 'polar':
name = name + '_uni'
elif model == 'polar_charmm':
name = name + '_uni2'
elif model == 'none':
name = name + '_noh'
blueprint = Database.BlueprintGroup(name)
_residue_blueprints[(name, model)] = blueprint
return blueprint
def __init__(self, file_or_filename, model = 0, alternate_code = 'A'):
"""
:param file_or_filename: the name of a PDB file, or a file object
:param model: the number of the model to be used from a
multiple model file
:type model: int
:param alternate_code: the alternate code to be used for atoms that
have multiple positions
:type alternate_code: str
"""
if isinstance(file_or_filename, basestring):
file_or_filename = Database.PDBPath(file_or_filename)
Scientific.IO.PDB.Structure.__init__(self, file_or_filename,
model, alternate_code)
self._numberAtoms()
self._convertUnits()
def _init(self):
# construct PDB map and alternative names
type = self.type
if not hasattr(type, 'pdbmap'):
pdb_dict = {}
type.pdbmap = [(type.symbol, pdb_dict)]
offset = 0
for g in type.groups:
for name, atom in g.pdbmap[0][1].items():
pdb_dict[name] = Database.AtomReference(atom.number + \
offset)
offset = offset + len(g.atoms)
if not hasattr(type, 'pdb_alternative'):
alt_dict = {}
for g in type.groups:
if hasattr(g, 'pdb_alternative'):
for key, value in g.pdb_alternative.items():
alt_dict[key] = value
setattr(type, 'pdb_alternative', alt_dict)
def setPreferences(prefs):
for k, v in prefs.items():
if k in PREFERENCES.keys():
if k == "database_version":
PREFERENCES[k] = v.lower()
if PREFERENCES[k] == "nmoldyn":
path = os.path.join(GVAR['nmoldyn_path'], 'Database')
else:
path = os.path.join(GVAR['mmtk_path'], 'Database')
if path not in Database.path:
Database.path.insert(0, path)
else:
idx = Database.path.index(path)
if idx != 0:
Database.path.insert(0, Database.path.pop(idx))
Database.atom_types = Database.Database(
'Atoms', Database.AtomType)
Database.group_types = Database.Database(
'Groups', Database.GroupType)
Database.molecule_types = Database.Database(
'Molecules', Database.MoleculeType)
Database.crystal_types = Database.Database(
'Crystals', Database.CrystalType)
Database.complex_types = Database.Database(
'Complexes', Database.ComplexType)
Database.protein_types = Database.Database(
'Proteins', Database.ProteinType)
Proteins._residue_blueprints = {}
elif k in ["documentation_style", "warning_check_for_new_version"]:
PREFERENCES[k] = v.lower()
else:
PREFERENCES[k] = v
def __init__(self, *items, **properties):
"""
:param items: either a sequence of peptide chain objects, or
a string, which is interpreted as the name of a
database definition for a protein.
If that definition does not exist, the string
is taken to be the name of a PDB file, from which
all peptide chains are constructed and
assembled into a protein.
:keyword model: one of "all" (all-atom), "no_hydrogens" or "none"
(no hydrogens),"polar_hydrogens" or "polar"
(united-atom with only polar hydrogens),
"polar_charmm" (like "polar", but defining
polar hydrogens like in the CHARMM force field),
"polar_opls" (like "polar", but defining
polar hydrogens like in the latest OPLS force field),
"calpha" (only the |C_alpha| atom of each residue).
Default is "all".
:type model: str
:keyword position: the center-of-mass position of the protein
:type position: Scientific.Geometry.Vector
:keyword name: a name for the protein
:type name: str
"""
if items == (None,):
return
self.name = ''
if len(items) == 1 and type(items[0]) == type(''):
try:
filename = Database.databasePath(items[0], 'Proteins')
found = 1
except IOError:
found = 0
if found:
blueprint = Database.BlueprintProtein(items[0])
items = blueprint.chains
for attr, value in vars(blueprint).items():
if attr not in ['type', 'chains']:
setattr(self, attr, value)
else:
import PDB
conf = PDB.PDBConfiguration(items[0])
model = properties.get('model', 'all')
items = conf.createPeptideChains(model)
molecules = []
for i in items:
if ChemicalObjects.isChemicalObject(i):
molecules.append(i)
else:
molecules = molecules + list(i)
for m, i in zip(molecules, range(len(molecules))):
m._numbers = [i]
if not m.name:
m.name = 'chain'+`i`
ss = self._findSSBridges(molecules)
new_mol = {}
for m in molecules:
new_mol[m] = ([m],[])
for bond in ss:
m1 = new_mol[bond[0].topLevelChemicalObject()]
m2 = new_mol[bond[1].topLevelChemicalObject()]
if m1 == m2:
m1[1].append(bond)
else:
combined = (m1[0] + m2[0], m1[1] + m2[1] + [bond])
for m in combined[0]:
new_mol[m] = combined
self.molecules = []
while new_mol:
m = new_mol.values()[0]
for i in m[0]:
del new_mol[i]
bonds = m[1]
if len(m[0]) == 1:
m = m[0][0]
m._addSSBridges(bonds)
else:
numbers = sum((i._numbers for i in m[0]), [])
m = ConnectedChains(m[0])
m._numbers = numbers
m._addSSBridges(bonds)
m._finalize()
for c in m:
c.parent = self
m.parent = self
self.molecules.append(m)
self.atoms = []
self.chains = []
for m in self.molecules:
self.atoms.extend(m.atoms)
if hasattr(m, 'is_connected_chains'):
for c, name, i in zip(range(len(m)),
m.chain_names, m._numbers):
self.chains.append((m, c, name, i))
else:
try: name = m.name
except AttributeError: name = ''
self.chains.append((m, None, name, m._numbers[0]))
self.chains.sort(lambda c1, c2: cmp(c1[3], c2[3]))
self.chains = map(lambda c: c[:3], self.chains)
self.parent = None
self.type = None
self.configurations = {}
try:
self.name = properties['name']
del properties['name']
except KeyError: pass
if properties.has_key('position'):
self.translateTo(properties['position'])
del properties['position']
self.addProperties(properties)
undefined = 0
for a in self.atoms:
if a.position() is None:
undefined += 1
if undefined > 0 and undefined != len(self.atoms):
Utility.warning('Some atoms in a protein ' +
'have undefined positions.')
module.Line(p2, p2 - bond_vector, material=material2))
else:
objects.append(
module.Cylinder(p1,
p1 + bond_vector,
radius,
material=material1))
objects.append(
module.Cylinder(p2,
p2 - bond_vector,
radius,
material=material2))
return objects
Database.registerInstanceClass(Bond.blueprintclass, Bond)
#
# Bond angles
#
class BondAngle(object):
"""
Bond angle
A bond angle is the angle between two bonds that share a common atom.
It is defined by two bond objects (attributes b1 and b2) and an atom
object (the common atom, attribute ca).
"""
def __init__(self, b1, b2, ca):
self.b1 = b1 # bond 1
def createMolecules(self, names = None, permit_undefined=True):
"""
:param names: If a list of molecule names (as defined in the
chemical database) and/or PDB residue names,
only molecules mentioned in this list will be
constructed. If a dictionary, it is used to map
PDB residue names to molecule names. With the
default (None), only water molecules are
built.
:type names: list
:param permit_undefined: If False, an exception is raised
when a PDB residue is encountered for
which no molecule name is supplied
in names. If True, an AtomCluster
object is constructed for each unknown
molecule.
:returns: a collection of :class:~MMTK.ChemicalObjects.Molecule objects,
one for each molecule in the PDB file. Each PDB residue not
describing an amino acid or nucleotide residue is considered a
molecule.
:rtype: :class:~MMTK.Collections.Collection
"""
collection = Collections.Collection()
mol_dicts = [molecule_names]
if type(names) == type({}):
mol_dicts.append(names)
names = None
for name in self.molecules.keys():
full_name = None
for dict in mol_dicts:
full_name = dict.get(name, None)
if names is None or name in names or full_name in names:
if full_name is None and not permit_undefined:
raise ValueError("no definition for molecule " + name)
for molecule in self.molecules[name]:
if full_name:
m = ChemicalObjects.Molecule(full_name)
setConfiguration(m, [molecule])
else:
pdbdict = {}
atoms = []
i = 0
for atom in molecule:
aname = atom.name
while aname[0] in string.digits:
aname = aname[1:] + aname[0]
try:
element = atom['element'].strip()
a = ChemicalObjects.Atom(element, name = aname)
except KeyError:
try:
a = ChemicalObjects.Atom(aname[:2].strip(),
name = aname)
except IOError:
a = ChemicalObjects.Atom(aname[:1],
name = aname)
a.setPosition(atom.position)
atoms.append(a)
pdbdict[atom.name] = Database.AtomReference(i)
i += 1
m = ChemicalObjects.AtomCluster(atoms, name = name)
if len(pdbdict) == len(molecule):
# pdbmap is correct only if the AtomCluster has
# unique atom names
m.pdbmap = [(name, pdbdict)]
setConfiguration(m, [molecule])
collection.addObject(m)
return collection
def getReference(self, atom):
if atom.__class__ is Database.AtomReference:
return atom
return Database.AtomReference(self.atoms.index(atom))
if toplevel:
return ['<molecule ref="%s"/>' % name]
else:
return None
def getXMLAtomOrder(self):
if self.type is None:
atoms = []
for molecule in self.molecules:
atoms.extend(molecule.getXMLAtomOrder())
return atoms
else:
return ChemicalObject.getXMLAtomOrder(self)
Database.registerInstanceClass(Atom.blueprintclass, Atom)
Database.registerInstanceClass(Group.blueprintclass, Group)
Database.registerInstanceClass(Molecule.blueprintclass, Molecule)
Database.registerInstanceClass(Crystal.blueprintclass, Crystal)
Database.registerInstanceClass(Complex.blueprintclass, Complex)
class AtomCluster(CompositeChemicalObject, ChemicalObject):
"""
An agglomeration of atoms
An atom cluster acts like a molecule without any bonds or atom
properties. It can be used to represent a group of atoms that
are known to form a chemical unit but whose chemical properties
are not sufficiently known to define a molecule.
"""
ChemicalObject.writeXML(self, file, memo, toplevel)
if toplevel:
return ['<molecule ref="%s"/>' % name]
else:
return None
def getXMLAtomOrder(self):
if self.type is None:
atoms = []
for molecule in self.molecules:
atoms.extend(molecule.getXMLAtomOrder())
return atoms
else:
return ChemicalObject.getXMLAtomOrder(self)
Database.registerInstanceClass(Atom.blueprintclass, Atom)
Database.registerInstanceClass(Group.blueprintclass, Group)
Database.registerInstanceClass(Molecule.blueprintclass, Molecule)
Database.registerInstanceClass(Crystal.blueprintclass, Crystal)
Database.registerInstanceClass(Complex.blueprintclass, Complex)
class AtomCluster(CompositeChemicalObject, ChemicalObject):
"""
An agglomeration of atoms
An atom cluster acts like a molecule without any bonds or atom
properties. It can be used to represent a group of atoms that
are known to form a chemical unit but whose chemical properties
are not sufficiently known to define a molecule.
def __init__(self, *items, **properties):
"""
:param items: either a sequence of peptide chain objects, or
a string, which is interpreted as the name of a
database definition for a protein.
If that definition does not exist, the string
is taken to be the name of a PDB file, from which
all peptide chains are constructed and
assembled into a protein.
:keyword model: one of "all" (all-atom), "no_hydrogens" or "none"
(no hydrogens),"polar_hydrogens" or "polar"
(united-atom with only polar hydrogens),
"polar_charmm" (like "polar", but defining
polar hydrogens like in the CHARMM force field),
"polar_opls" (like "polar", but defining
polar hydrogens like in the latest OPLS force field),
"calpha" (only the |C_alpha| atom of each residue).
Default is "all".
:type model: str
:keyword position: the center-of-mass position of the protein
:type position: Scientific.Geometry.Vector
:keyword name: a name for the protein
:type name: str
"""
if items == (None,):
return
self.name = ''
if len(items) == 1 and type(items[0]) == type(''):
try:
filename = Database.databasePath(items[0], 'Proteins')
found = 1
except IOError:
found = 0
if found:
blueprint = Database.BlueprintProtein(items[0])
items = blueprint.chains
for attr, value in vars(blueprint).items():
if attr not in ['type', 'chains']:
setattr(self, attr, value)
else:
import PDB
conf = PDB.PDBConfiguration(items[0])
model = properties.get('model', 'all')
items = conf.createPeptideChains(model)
molecules = []
for i in items:
if ChemicalObjects.isChemicalObject(i):
molecules.append(i)
else:
molecules = molecules + list(i)
for m, i in zip(molecules, range(len(molecules))):
m._numbers = [i]
if not m.name:
m.name = 'chain'+`i`
ss = self._findSSBridges(molecules)
new_mol = {}
for m in molecules:
new_mol[m] = ([m],[])
for bond in ss:
m1 = new_mol[bond[0].topLevelChemicalObject()]
m2 = new_mol[bond[1].topLevelChemicalObject()]
if m1 == m2:
m1[1].append(bond)
else:
combined = (m1[0] + m2[0], m1[1] + m2[1] + [bond])
for m in combined[0]:
new_mol[m] = combined
self.molecules = []
while new_mol:
m = new_mol.values()[0]
for i in m[0]:
del new_mol[i]
bonds = m[1]
if len(m[0]) == 1:
m = m[0][0]
m._addSSBridges(bonds)
else:
numbers = sum((i._numbers for i in m[0]), [])
m = ConnectedChains(m[0])
m._numbers = numbers
m._addSSBridges(bonds)
m._finalize()
for c in m:
c.parent = self
m.parent = self
self.molecules.append(m)
self.atoms = []
self.chains = []
for m in self.molecules:
self.atoms.extend(m.atoms)
if hasattr(m, 'is_connected_chains'):
for c, name, i in zip(range(len(m)),
m.chain_names, m._numbers):
self.chains.append((m, c, name, i))
else:
try: name = m.name
except AttributeError: name = ''
self.chains.append((m, None, name, m._numbers[0]))
self.chains.sort(lambda c1, c2: cmp(c1[3], c2[3]))
self.chains = map(lambda c: c[:3], self.chains)
self.parent = None
self.type = None
self.configurations = {}
try:
self.name = properties['name']
del properties['name']
except KeyError: pass
if properties.has_key('position'):
self.translateTo(properties['position'])
del properties['position']
self.addProperties(properties)
undefined = 0
for a in self.atoms:
if a.position() is None:
undefined += 1
if undefined > 0 and undefined != len(self.atoms):
Utility.warning('Some atoms in a protein ' +
'have undefined positions.')
objects.append(module.Cylinder(p1, p2, radius,
material = material1))
else:
if radius is None:
objects.append(module.Line(p1, p1+bond_vector,
material = material1))
objects.append(module.Line(p2, p2-bond_vector,
material = material2))
else:
objects.append(module.Cylinder(p1, p1+bond_vector, radius,
material = material1))
objects.append(module.Cylinder(p2, p2-bond_vector, radius,
material = material2))
return objects
Database.registerInstanceClass(Bond.blueprintclass, Bond)
#
# Bond angles
#
class BondAngle(object):
"""
Bond angle
A bond angle is the angle between two bonds that share a common atom.
It is defined by two bond objects (attributes b1 and b2) and an atom
object (the common atom, attribute ca).
"""
def __init__(self, b1, b2, ca):