for name, resnum, hBondNumberList, antiHBondNumberList, phipsiNums in hairpin_data:
# description
hairpin = ChainDescription({"chainID" : name})
hairpin.createResidues(resnum)
hairpin.createBackboneHBondConditions(hBondNumberList, maxHO, minHOC, minNHO)
# antibonds
for i, j in antiHBondNumberList:
bond = hairpin.createBackboneHBondCondition(i, j, maxHO, minHOC, minNHO)
bond.negate()
# measures
measures = []
measures.extend(hairpin.createPhiPsiMeasures(phipsiNums))
# either this line or the other 3 would do...
#measures.extend(hairpin.createBackboneHBondMeasures(hBondNumberList))
# ...but this latter is arguably more efficient, since it means less calculations
for i, j in hBondNumberList:
measures.append(PropertyMeasure(hairpin, "NH(%i)->CO(%i):H_A" % (i, j), float))
measures.append(PropertyMeasure(hairpin, "NH(%i)->CO(%i):DHA" % (i, j), float))
measures.append(PropertyMeasure(hairpin, "NH(%i)->CO(%i):HAA" % (i, j), float))
fileOut = open("%s.txt" % name, 'w')
pipe = Pipe(hairpin, measures, fileOut)
pipes.append(pipe)
# run
path = sys.argv[1]
catmat3 = ChainDescription({"chainID" : "c3"})
catmat3.createResidues(4)
for i in range(1, 5):
print(catmat3.getResidue(i).children.pop())
catmat3.createPhiBoundCondition(2, -85, 45)
catmat3.createPsiBoundCondition(2, -5, 45)
catmat3.createPhiBoundCondition(3, -70, 40)
catmat3.createPsiBoundCondition(3, 135, 45)
measures3 = []
measures3.extend(catmat3.createPhiPsiMeasures([2, 3]))
catmat4 = ChainDescription({"chainID" : "c4"})
catmat4.createResidues(5)
for i in range(1, 6):
print(catmat4.getResidue(i).children.pop())
catmat4.createPhiBoundCondition(2, -75, 45)
catmat4.createPsiBoundCondition(2, -15, 45)
catmat4.createPhiBoundCondition(3, -95, 45)
catmat4.createPsiBoundCondition(3, -5, 45)
catmat4.createPhiBoundCondition(4, -100, 60)
catmat4.createPsiBoundCondition(4, 135, 45)
measures4 = []
import sys
from Tailor.Condition import HBondCondition, NoneCombiner
from Tailor.Description import ChainDescription, AtomDescription
from Tailor.Measure import PropertyMeasure, DistanceMeasure
from Tailor.Run import Run, Pipe
path = sys.argv[1]
maxHO = 3.5
minHOC = 90.0
minNHO = 90.0
helixTerm = ChainDescription({"chainID" : "h"})
helixTerm.createResidues(9)
helixTerm.createBackboneHBondCondition(6, 2, maxHO, minHOC, minNHO)
helixTerm.createBackboneHBondCondition(7, 3, maxHO, minHOC, minNHO)
helixTerm.getResidue(8).addPropertyCondition("resname", "PRO")
helixTerm.getResidue(8).children.pop()
helixTerm.getResidue(8).children.append(AtomDescription({"name" : "2HD"}))
measures = []
measures.extend(helixTerm.createPhiPsiMeasures([6, 7, 8]))
o = helixTerm.selectResidue(5).selectAtom("O")
h = helixTerm.selectResidue(8).selectAtom("2HD")
measures.append(DistanceMeasure(o, h))
pipes = [Pipe(helixTerm, measures, sys.stdout)]
run = Run(pipes, path)
run.run()
path = sys.argv[1]
rlNest = ChainDescription({"chainID" : "RL"})
rlNest.createResidues(4)
for i in range(1, 5):
print(rlNest.getResidue(i).children.pop())
rlNest.createPhiBoundCondition(2, -90, 45)
rlNest.createPsiBoundCondition(2, 0, 45)
rlNest.createPhiBoundCondition(3, 80, 45)
rlNest.createPsiBoundCondition(3, 10, 45)
measuresRL = []
measuresRL.extend(rlNest.createPhiPsiMeasures([2, 3]))
lrNest = ChainDescription({"chainID" : "LR"})
lrNest.createResidues(4)
for i in range(1, 5):
print(lrNest.getResidue(i).children.pop())
lrNest.createPhiBoundCondition(2, 80, 45)
lrNest.createPsiBoundCondition(2, 10, 45)
lrNest.createPhiBoundCondition(3, -90, 45)
lrNest.createPsiBoundCondition(3, 0, 45)
measuresLR = []
measuresLR.extend(lrNest.createPhiPsiMeasures([2, 3]))
minHOC = 90.0
minNHO = 120.0
helixTerm = ChainDescription({"chainID" : "h"})
helixTerm.createResidues(7)
helixTerm.createBackboneHBondCondition(4, 1, maxHO, minHOC, minNHO)
helixTerm.createBackboneHBondCondition(5, 2, maxHO, minHOC, minNHO)
helixTerm.createPhiBoundCondition(2, -90, 60)
helixTerm.createPsiBoundCondition(2, 0, 60)
helixTerm.createPhiBoundCondition(3, -90, 60)
helixTerm.createPsiBoundCondition(3, 0, 60)
helixTerm.createPhiBoundCondition(4, -90, 60)
helixTerm.createPsiBoundCondition(4, 0, 60)
hbond = helixTerm.createBackboneHBondCondition(6, 3, maxHO, minHOC, minNHO)
hbond.negate()
# for proline searches
#helixTerm.getResidue(6).addPropertyCondition("resname", "PRO")
#helixTerm.getResidue(6).children.pop()
#helixTerm.getResidue(6).children.append(AtomDescription({"name" : "2HD"}))
measures = []
measures.extend(helixTerm.createPhiPsiMeasures([4, 5, 6]))
pipes = [Pipe(helixTerm, measures, sys.stdout)]
run = Run(pipes, pipes)
run.run()
minHOC = 90.0
minNHO = 120.0
helixTerm = ChainDescription({"chainID" : "h"})
helixTerm.createResidues(8)
helixTerm.createBackboneHBondCondition(5, 1, maxHO, minHOC, minNHO)
helixTerm.createBackboneHBondCondition(6, 2, maxHO, minHOC, minNHO)
helixTerm.createPhiBoundCondition(2, -90, 60)
helixTerm.createPsiBoundCondition(2, 0, 60)
helixTerm.createPhiBoundCondition(3, -90, 60)
helixTerm.createPsiBoundCondition(3, 0, 60)
helixTerm.createPhiBoundCondition(4, -90, 60)
helixTerm.createPsiBoundCondition(4, 0, 60)
hbond = helixTerm.createBackboneHBondCondition(7, 3, maxHO, minHOC, minNHO)
hbond.negate()
# for proline searches
#helixTerm.getResidue(7).addPropertyCondition("resname", "PRO")
#helixTerm.getResidue(7).children.pop()
#helixTerm.getResidue(7).children.append(AtomDescription({"name" : "2HD"}))
measures = []
measures.extend(helixTerm.createPhiPsiMeasures([5, 6, 7]))
pipes = [Pipe(helixTerm, measures, sys.stdout)]
run = Run(pipes, path)
run.run()
helixTerm.createResidues(12)
helixTerm.createBackboneHBondCondition(6, 2, maxHO, minHOC, minNHO)
helixTerm.createBackboneHBondCondition(7, 3, maxHO, minHOC, minNHO)
helixTerm.createBackboneHBondCondition(8, 4, maxHO, minHOC, minNHO)
helixTerm.createBackboneHBondCondition(9, 5, maxHO, minHOC, minNHO)
helixTerm.createBackboneHBondCondition(10, 6, maxHO, minHOC, minNHO)
helixTerm.getResidue(11).addPropertyCondition("resname", "PRO")
helixTerm.getResidue(11).children.pop()
#antiBond = helixTerm.createBackboneHBondCondition(11, 7, maxHO, minHOC, minNHO)
#antiBond.negate()
#antiPhiBound9 = helixTerm.createPhiBoundCondition(11, -90, 90)
#antiPsiBound9 = helixTerm.createPsiBoundCondition(11, -30, 60)
#helixTerm.conditions.remove(antiPhiBound9)
#helixTerm.conditions.remove(antiPsiBound9)
#antiPhiPsiBound9 = NoneCombiner([antiPhiBound9, antiPsiBound9])
#helixTerm.addCondition(antiPhiPsiBound9)
measures = []
measures.extend(helixTerm.createPhiPsiMeasures([9, 10, 11]))
measures.append(PropertyMeasure(helixTerm.selectResidue(9), "resname", str))
measures.append(PropertyMeasure(helixTerm.selectResidue(10), "resname", str))
measures.append(PropertyMeasure(helixTerm.selectResidue(11), "resname", str))
pipes = [Pipe(helixTerm, measures, sys.stdout)]
run = Run(pipes, path)
run.run()
path = sys.argv[1]
rlCatgrip = ChainDescription({"chainID": "RL"})
rlCatgrip.createResidues(4)
for i in range(1, 5):
print rlCatgrip.getResidue(i).children.pop()
rlCatgrip.createPhiBoundCondition(2, -90, 45)
rlCatgrip.createPsiBoundCondition(2, 135, 45)
rlCatgrip.createPhiBoundCondition(3, 90, 45)
rlCatgrip.createPsiBoundCondition(3, -135, 45)
measuresRL = []
measuresRL.extend(rlCatgrip.createPhiPsiMeasures([2, 3]))
lrCatgrip = ChainDescription({"chainID": "LR"})
lrCatgrip.createResidues(4)
for i in range(1, 5):
print lrCatgrip.getResidue(i).children.pop()
lrCatgrip.createPhiBoundCondition(2, 90, 45)
lrCatgrip.createPsiBoundCondition(2, -135, 45)
lrCatgrip.createPhiBoundCondition(3, -90, 45)
lrCatgrip.createPsiBoundCondition(3, 135, 45)
measuresLR = []
measuresLR.extend(lrCatgrip.createPhiPsiMeasures([2, 3]))
