Example #1
0
def makeNTerminalResidue(psi):
    N_CA_C_O_torsion = invertTorsion(psi)
    nitrogen = Vector(0.0, 0.0, 0.0) 
    cAlpha = Vector(N_CA_distance, 0.0, 0.0)
    carbonylCarbon = makeXYZFromAngle(nitrogen, cAlpha, CA_C_distance, N_CA_C_angle, Y)
    oxygen = makeXYZ(carbonylCarbon, C_O_distance, cAlpha, CA_C_O_angle, nitrogen, N_CA_C_O_torsion)

    r = Residue(1, "GLY")
    r.subFeatures = [Atom("N", 1, nitrogen), Atom("CA", 2, cAlpha), Atom("C", 3, carbonylCarbon), Atom("O", 4, oxygen)]
    return r
Example #2
0
def makeResidue(previousResidue, phi, psi, lastPsi):
    previousNitrogen = previousResidue.getAtomPosition("N")
    previousCAlpha = previousResidue.getAtomPosition("CA")
    previousC = previousResidue.getAtomPosition("C")
    N_CA_C_O_torsion = invertTorsion(psi)

    nitrogen = makeXYZ(previousC, C_N_distance, previousCAlpha, CA_C_N_angle, previousNitrogen, lastPsi)
    cAlpha = makeXYZ(nitrogen, N_CA_distance, previousC, C_N_CA_angle, previousCAlpha, 180)
    carbonylCarbon = makeXYZ(cAlpha, CA_C_distance, nitrogen, N_CA_C_angle, previousC, phi)
    oxygen = makeXYZ(carbonylCarbon, C_O_distance, cAlpha, CA_C_O_angle, nitrogen, N_CA_C_O_torsion)

    residueNumber = previousResidue.number + 1
    r = Residue(residueNumber, "GLY")
    r.subFeatures = [Atom("N", nitrogen), Atom("CA", cAlpha), Atom("C", carbonylCarbon), Atom("O", oxygen)]
    return r
Example #3
0
def makeFragment(phiPsiList):
    c_pos = Vector(0, 0, 0)
    o_pos = Vector(C_O_distance, 0, 0)
    ca_pos = makeXYZFromAngle(o_pos, c_pos, CA_C_distance, CA_C_O_angle, -Y)
    nCap = Residue(1, "GLY") 
    nCap.subFeatures = [Atom("CA", ca_pos), Atom("C", c_pos), Atom("O", o_pos)]

    (phi, psi) = phiPsiList[0]
    N_CA_C_O_torsion = invertTorsion(psi)

    n_pos = makeXYZFromAngle(o_pos, c_pos, C_N_distance, O_C_N_angle, Y)
    ca_pos = makeXYZ(n_pos, N_CA_distance, c_pos, C_N_CA_angle, o_pos, 0)
    c_pos = makeXYZ(ca_pos, CA_C_distance, n_pos, N_CA_C_angle, c_pos, phi)
    o_pos = makeXYZ(c_pos, C_O_distance, ca_pos, CA_C_O_angle, n_pos, N_CA_C_O_torsion)
    firstResidue = Residue(2, "GLY")
    firstResidue.subFeatures = [Atom("N", n_pos), Atom("CA", ca_pos), Atom("C", c_pos), Atom("O", o_pos)]

    chain = Chain("A")
    chain.add(nCap)
    chain.add(firstResidue)
    extendChain(phiPsiList[1:], psi, chain)
    
    last = chain.subFeatures[-1]
    lastPsi = phiPsiList[-1][1]
    n_pos = last.getAtomPosition("N")
    ca_pos = last.getAtomPosition("CA")
    c_pos = last.getAtomPosition("C")
    o_pos = last.getAtomPosition("O")
    n_pos = makeXYZ(c_pos, C_N_distance, ca_pos, CA_C_N_angle, n_pos, lastPsi)
    cCap = Residue(last.number + 1, "GLY")
    cCap.subFeatures = [Atom("N", n_pos)]
    chain.add(cCap)

    return chain
Example #4
0
    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
Example #5
0
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)
Example #6
0
 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)