def findAll(self, structure):
""" Use the description of this matcher to find all examples in structure.
"""
matches = []
# top level is Structure -> search through combinations of Chains
if self.description.levelCode == "S":
logging.debug("structure description")
# select chains of a particular type and get matches
matchMap = {}
chainIDLists = []
for chainDescription in self.description:
chainIDs = []
for chain in structure.chainsOfType(chainDescription.chainType):
matchMap[chain.chainID] = self.findMatchesInChain(chainDescription, chain)
logging.debug("adding chain %s" % chain.chainID)
chainIDs.append(chain.chainID)
chainIDLists.append(chainIDs)
# work on tuples of chains
chainCombinations = combine(*chainIDLists)
for chainCombo in chainCombinations:
logging.debug("trying chains: %s" % chainCombo)
# combine these matches into whole motifs
# TODO XXX this should really be cross-product!
# currently only works with pairs...
for matchA in matchMap[chainCombo[0]]:
for matchB in matchMap[chainCombo[1]]:
# XXX AARGH! : we make the fragment before testing??!
fragment = Structure(self.description.name)
model = Model(0)
fragment.add(model)
model.add(matchA)
model.add(matchB)
if self.matchConditions(fragment):
matches.append(fragment)
# top level is Chain -> search through combinations of Residues
elif self.description.levelCode == "C":
logging.debug("chain description")
# find the next suitable chain to look through
for chain in structure.chainsOfType(self.description.chainType):
logging.debug("finding matches in chain %s" % chain.chainID)
possibles = self.findMatchesInChain(self.description, chain)
for p in possibles:
if self.matchConditions(p):
matches.append(p)
return matches
def initModel(self):
if self.modelID is None:
self.modelID = 0
else:
self.modelID += 1
self.model = Model(self.modelID)
self.structure.add(self.model)
self.chainID = None
self.chainType = None
def findIn(self, structure):
example = Structure(self.pdbid)
# TODO : implement model stuff :(
model = structure[0]
modelFeature = Model(0)
example.add(modelFeature)
for chain in model:
if chain.chainID == self.chain or self.chain == " ":
#print("[%s]" % chain.chainID)
chainFeature = Chain(chain.chainID, chainType="Protein")
# XXX obviously better to access by index...
for residue in chain:
if self.residueStart <= int(residue.number) <= self.residueEnd:
# XXX better to use copy()?
residueFeature = Residue(residue.number, residue.resname)
for atom in residue:
residueFeature.add(copy(atom))
chainFeature.add(residueFeature)
modelFeature.add(chainFeature)
else:
continue
# now add the ligand (as of this moment, a water molecule) XXX ugh!
waterChain = Chain("Water", "Water")
waterResidue = Residue(self.ligand_num, "HOH")
#print("getting", self.ligand_num)
waterchains = structure.chainsOfType("Water")
#print("chains", waterchains)
existingWater = waterchains[0].getResidueNumber(self.ligand_num)
waterResidue.add(copy(existingWater.getAtom("O")))
waterChain.add(waterResidue)
modelFeature.add(waterChain)
return example
class StructureBuilder:
def __init__(self):
self.reset()
def reset(self):
self.structure = None
self.model = None
self.chain = None
self.residue = None
self.modelID = None
self.chainID = None
self.chainType = None
self.segID = None
self.residueID = None
self.resname = None
def getStructure(self):
structure = self.structure
self.reset()
return structure
def initStructure(self, structureID):
self.structure = Structure(structureID)
self.initModel()
def initModel(self):
if self.modelID is None:
self.modelID = 0
else:
self.modelID += 1
self.model = Model(self.modelID)
self.structure.add(self.model)
self.chainID = None
self.chainType = None
def initChain(self, chainID, chainType):
self.chainID = chainID
self.chainType = chainType
self.chain = Chain(chainID, chainType)
self.model.add(self.chain)
def registerLine(self, residueID, resname, resseq, icode, segID, chainID, chainType):
if self.chainID != chainID or chainType != self.chainType:
self.initChain(chainID, chainType)
self.initResidue(residueID, resname, resseq, icode)
elif self.residueID != residueID or self.resname != resname:
self.initResidue(residueID, resname, resseq, icode)
if self.segID != segID:
self.segID = segID
def initResidue(self, residueID, resname, resnum, icode):
self.residueID = residueID
self.resname = resname
self.residue = Residue(residueID, resname, self.segID)
self.chain.add(self.residue)
def initAtom(self, name, coord, b_factor, occupancy, altloc):
atom = Atom(name, coord, b_factor, occupancy, altloc)
self.residue.add(atom)