def asuToUnitCell(self, asu_contents, compact=True): """ :param asu_contents: the molecules in the asymmetric unit, usually obtained from :func:~MMTK.PDB.PDBConfiguration.createAll(). :param compact: if True, all molecules images are shifted such that their centers of mass lie inside the unit cell. :type compact: bool :returns: a collection containing all molecules in the unit cell, obtained by copying and moving the molecules from the asymmetric unit according to the crystallographic symmetry operations. :rtype: :class:~MMTK.Collections.Collection """ unit_cell_contents = Collections.Collection() for symop in self.cs_transformations: transformation = symop.asLinearTransformation() rotation = transformation.tensor translation = transformation.vector image = copy.deepcopy(asu_contents) for atom in image.atomList(): atom.setPosition(symop(atom.position())) if compact: cm = image.centerOfMass() cm_fr = self.to_fractional(cm) cm_fr = Vector(cm_fr[0] % 1., cm_fr[1] % 1., cm_fr[2] % 1.) \ - Vector(0.5, 0.5, 0.5) cm = self.from_fractional(cm_fr) image.translateTo(cm) unit_cell_contents.addObject(image) return unit_cell_contents
def setConfiguration(object, pdb_residues, map='pdbmap', alt='pdb_alternative', atom_map=None, toplevel=True): defined = 0 if hasattr(object, 'is_protein'): i = 0 for chain in object: l = len(chain) defined += setConfiguration(chain, pdb_residues[i:i + l], map, alt, atom_map, False) i = i + l elif hasattr(object, 'is_chain'): for i in range(len(object)): defined += setConfiguration(object[i], pdb_residues[i:i + 1], map, alt, atom_map, False) elif hasattr(object, map): pdbmap = getattr(object, map) try: altmap = getattr(object, alt) except AttributeError: altmap = {} nres = len(pdb_residues) if len(pdbmap) != nres: raise IOError('PDB configuration does not match object ' + object.fullName()) for i in range(nres): defined += setResidueConfiguration(object, pdb_residues[i], pdbmap[i], altmap, atom_map) elif Collections.isCollection(object): nres = len(pdb_residues) if len(object) != nres: raise IOError('PDB configuration does not match object ' + object.fullName()) for i in range(nres): defined += setConfiguration(object[i], [pdb_residues[i]], map, alt, atom_map, False) else: try: name = object.fullName() except AttributeError: try: name = object.name except AttributeError: name = '???' raise IOError('PDB configuration does not match object ' + name) if toplevel and defined < object.numberOfAtoms(): name = '[unnamed object]' try: name = object.fullName() except: pass if name: name = ' in ' + name Utility.warning( ` object.numberOfAtoms() - defined ` + ' atom(s)' + name + ' were not assigned (new) positions.') return defined
def backbone(self): """ :returns: the sugar and phosphate groups :rtype: :class:~MMTK.ChemicalObjects.Group """ bb = self.sugar if hasattr(self, 'phosphate'): bb = Collections.Collection([bb, self.phosphate]) return bb
def __init__(self, system, grid_size, values): self.system = system if isinstance(grid_size, tuple): self.box, self.field, self.points, self.colors = grid_size else: if values.data_rank != 1: raise TypeError("data not a particle variable") self.box = Collections.PartitionedAtomCollection(grid_size, system) self._setField(values)
def sidechains(self): """ :returns: the sidechain groups of all residues in all chains :rtype: :class:~MMTK.Collections.Collection """ rlist = Collections.Collection([]) for m in self.molecules: if isPeptideChain(m): rlist = rlist + m.sidechains() return rlist
def backbone(self): """ :returns: the peptide groups of all residues in all chains :rtype: :class:`~MMTK.Collections.Collection` """ rlist = Collections.Collection([]) for m in self.molecules: if isPeptideChain(m): rlist = rlist + m.backbone() return rlist
def residues(self): """ :returns: all residues in all chains :rtype: :class:`~MMTK.Collections.Collection` """ rlist = Collections.Collection([]) for m in self.molecules: if isPeptideChain(m): rlist = rlist + m.residues() return rlist
def residuesOfType(self, *types): """ :param types: residue type codes :type types: str :returns: a collection that contains all residues whose type (residue code) is contained in types :rtype: :class:`~MMTK.Collections.Collection` """ types = [t.lower() for t in types] rlist = [r for r in self.groups if r.type.symbol.lower() in types] return Collections.Collection(rlist)
def setConfiguration(object, pdb_residues, map = 'pdbmap', alt = 'pdb_alternative', atom_map = None, toplevel = True): defined = 0 if hasattr(object, 'is_protein'): i = 0 for chain in object: l = len(chain) defined += setConfiguration(chain, pdb_residues[i:i+l], map, alt, atom_map, False) i = i + l elif hasattr(object, 'is_chain'): for i in range(len(object)): defined += setConfiguration(object[i], pdb_residues[i:i+1], map, alt, atom_map, False) elif hasattr(object, map): pdbmap = getattr(object, map) try: altmap = getattr(object, alt) except AttributeError: altmap = {} nres = len(pdb_residues) if len(pdbmap) != nres: raise IOError('PDB configuration does not match object ' + object.fullName()) for i in range(nres): defined += setResidueConfiguration(object, pdb_residues[i], pdbmap[i], altmap, atom_map) elif Collections.isCollection(object): nres = len(pdb_residues) if len(object) != nres: raise IOError('PDB configuration does not match object ' + object.fullName()) for i in range(nres): defined += setConfiguration(object[i], [pdb_residues[i]], map, alt, atom_map, False) else: try: name = object.fullName() except AttributeError: try: name = object.name except AttributeError: name = '???' raise IOError('PDB configuration does not match object ' + name) if toplevel and defined < object.numberOfAtoms(): name = '[unnamed object]' try: name = object.fullName() except: pass if name: name = ' in ' + name Utility.warning(`object.numberOfAtoms()-defined` + ' atom(s)' + name + ' were not assigned (new) positions.') return defined
def sidechains(self): """ :returns: the sidechain groups of all residues :rtype: :class:`~MMTK.Collections.Collection` """ sidechains = Collections.Collection() for r in self.groups: try: sidechains.addObject(r.sidechain) except AttributeError: pass return sidechains
def backbone(self): """ :returns: the peptide groups of all residues :rtype: :class:`~MMTK.Collections.Collection` """ backbone = Collections.Collection() for r in self.groups: try: backbone.addObject(r.peptide) except AttributeError: pass return backbone
def backbone(self): """ :returns: the sugar and phosphate groups of all nucleotides :rtype: :class:~MMTK.Collections.Collection """ bb = Collections.Collection([]) for residue in self.groups: try: bb.addObject(residue.phosphate) except AttributeError: pass bb.addObject(residue.sugar) return bb
def residuesOfType(self, *types): """ :param types: a sequence of residue codes (one- or three-letter) :type types: sequence of str :returns: all residues whose type (one- or three-letter code) is contained in types :rtype: :class:`~MMTK.Collections.Collection` """ rlist = Collections.Collection([]) for m in self.molecules: if isPeptideChain(m): rlist = rlist + apply(m.residuesOfType, types) return rlist
def _findSSBridges(self, molecules): molecules = filter(lambda m: hasattr(m, 'is_peptide_chain'), molecules) cys = Collections.Collection([]) for m in molecules: if m.version_spec['model'] != 'calpha': cys = cys + m.residuesOfType('cys') + m.residuesOfType('cyx') s = cys.map(lambda r: r.sidechain.S_gamma) ns = len(s) ss = [] for i in xrange(ns-1): for j in xrange(i+1,ns): r1 = s[i].position() r2 = s[j].position() if r1 and r2 and (r1-r2).length() < self._ss_bond_max: ss.append((cys[i], cys[j])) return ss
def createAll(self, molecule_names = None, permit_undefined=True): """ :returns: a collection containing all objects contained in the PDB file, i.e. the combination of the objects returned by :func:~MMTK.PDB.PDBConfiguration.createPeptideChains, :func:~MMTK.PDB.PDBConfiguration.createNucleotideChains, and :func:~MMTK.PDB.PDBConfiguration.createMolecules. The parameters have the same meaning as for :func:~MMTK.PDB.PDBConfiguration.createMolecules. :rtype: :class:~MMTK.Collectionc.Collection """ collection = Collections.Collection() peptide_chains = self.createPeptideChains() if peptide_chains: import Proteins collection.addObject(Proteins.Protein(peptide_chains)) nucleotide_chains = self.createNucleotideChains() collection.addObject(nucleotide_chains) molecules = self.createMolecules(molecule_names, permit_undefined) collection.addObject(molecules) return collection
def residues(self): """ :returns: a collection containing all residues :rtype: :class:`~MMTK.Collections.Collection` """ return Collections.Collection(self.groups)
def bases(self): """ :returns: the base groups of all nucleotides :rtype: :class:~MMTK.Collections.Collection """ return Collections.Collection([r.base for r in self.groups])
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