def main():
"""
prints the list of catalytic residues in the enzme. (name and position)
"""
parser = OptionParser()
parser.add_option("-p", dest="pdbfile", help="pdbfile")
parser.add_option("-P", dest="pdblist", help="pdblist")
parser.set_description(main.__doc__)
(options,args) = parser.parse_args()
pdbfiles = []
if options.pdblist:
pdbfiles = files_from_list(options.pdblist)
elif options.pdbfile:
pdbfiles.append(options.pdbfile)
else:
parser.print_help()
sys.exit()
protein = Enzyme()
for pdbfile in pdbfiles:
protein.readPDB(pdbfile)
seq = ""
pos = ""
for cat in protein.catalytic:
seq += cat.name + "-"
for cat in protein.catalytic:
pos += cat.file_id + " "
print pdbfile,seq,pos
protein.clear()
def main():
"""
reports the ligand score (Eatr + Erep + EhbSC)
"""
parser = OptionParser()
parser.add_option("-p", dest="pdbfile", help="pdbfile")
parser.add_option("-P", dest="pdblist", help="pdblist")
parser.set_description(main.__doc__)
(options, args) = parser.parse_args()
pdbfiles = []
if options.pdblist:
pdbfiles = files_from_list(options.pdblist)
elif options.pdbfile:
pdbfiles.append(options.pdbfile)
else:
parser.print_help()
sys.exit()
protein = Enzyme()
for file in pdbfiles:
protein.readPDB(file)
lig = protein.ligand
if lig == None:
print "no ligand found for file:", file
sys.exit()
tot = lig.Erep + lig.Eatr + lig.EhbSC
print file, lig.Erep, lig.Eatr, lig.EhbSC, tot
protein.clear()
def main():
"""
reads a rosetta output pdbfile and reports residues that have a total Eres > cutoff
"""
parser = OptionParser()
parser.add_option("-p", dest="pdbfile", help="pdbfile")
parser.add_option("-P", dest="pdblist", help="pdblist")
parser.add_option("-o", dest="outfile", help="outfile")
parser.add_option("-O", dest="outlist", help="outlist")
parser.add_option("-r",
dest="replace",
help="replace",
action="store_true")
parser.add_option("-t", dest="type", help="atom type", default="CS1 ")
parser.add_option("-T", dest="type2", help="atom type", default="CS2 ")
parser.set_description(main.__doc__)
(options, args) = parser.parse_args()
pdbfiles = []
if options.pdblist:
pdbfiles = files_from_list(options.pdblist)
elif options.pdbfile:
pdbfiles.append(options.pdbfile)
else:
parser.print_help()
sys.exit()
outfiles = []
if options.outlist:
outfiles = files_from_list(options.outlist)
elif options.outfile:
outfiles.append(options.outfile)
elif options.replace:
for file in pdbfiles:
outfiles.append(file)
else:
parser.print_help()
sys.exit()
if len(pdbfiles) != len(outfiles):
print "number of pdbfiles and output files differ"
sys.exit()
mymol = Enzyme()
for i in range(len(pdbfiles)):
pdbfile = pdbfiles[i]
outfile = outfiles[i]
mymol.readPDB(pdbfile)
lig = mymol.ligand
lig.removeAtomsContaining(options.type)
lig.removeAtomsContaining(options.type2)
mymol.writePDB(outfile)
mymol.clear()
def main():
"""
reports the distance between two selected atoms in a pdbfile
"""
parser = OptionParser()
parser.add_option("-p", dest="pdbfile", help="pdbfile")
parser.add_option("-P", dest="pdblist", help="pdblist")
parser.add_option("--s1", dest="selection1", help="selection1")
parser.add_option("--s2", dest="selection2", help="selection2")
parser.set_description(main.__doc__)
(options, args) = parser.parse_args()
pdbfiles = []
if options.pdblist:
pdbfiles = files_from_list(options.pdblist)
elif options.pdbfile:
pdbfiles.append(options.pdbfile)
else:
parser.print_help()
sys.exit()
if not options.selection1 or not options.selection2:
parser.print_help()
sys.exit()
sele1 = Selection()
sele2 = Selection()
sele1.makeSelection(options.selection1)
sele2.makeSelection(options.selection2)
protein = Enzyme()
for pdbfile in pdbfiles:
protein.readPDB(pdbfile)
mol1 = sele1.apply_selection(protein)
mol2 = sele2.apply_selection(protein)
alist1 = mol1.atomList()
alist2 = mol2.atomList()
if len(alist1) != 1:
print "selection 1 does not specify 1 atom"
print alist1
sys.exit()
if len(alist2) != 1:
print "selection 2 does not specify 1 atom"
sys.exit()
atm1 = alist1[0]
atm2 = alist2[0]
dist = atm1.distance(atm2)
print pdbfile, ":", atm1.name, "->", atm2.name, ":", dist
protein.clear()
def main():
"""
reports the hydrogen bonds made to catalytic residues in an enzyme
"""
parser = OptionParser()
parser.add_option("-p", dest="pdbfile", help="pdbfile")
parser.add_option("-P", dest="pdblist", help="pdblist")
parser.add_option("-c", dest="catalytic", help="catalytic")
parser.add_option("-x", dest="cutoff", help="cutoff", default=-0.3)
parser.add_option("-m", dest="mabo", help="mabo", action="store_true")
parser.add_option("-n",
dest="count",
help="report counts",
action="store_true")
parser.set_description(main.__doc__)
(options, args) = parser.parse_args()
if not options.catalytic:
parser.print_help()
sys.exit()
pdbfiles = []
if options.pdblist:
pdbfiles = files_from_list(options.pdblist)
elif options.pdbfile:
pdbfiles.append(options.pdbfile)
else:
parser.print_help()
sys.exit()
enz = Enzyme()
icat = int(options.catalytic)
HBN = HBnetwork()
for pdbfile in pdbfiles:
enz.readPDB(pdbfile)
cres = enz.catalytic[icat - 1]
if cres == None:
print "cannot find catalytic residue"
sys.exit()
HBN.createNetwork(enz)
HBN.findHbonds(float(options.cutoff))
hlist = HBN.getHbondsToResidue(cres)
if options.count:
print pdbfile, len(hlist)
else:
for hb in hlist:
print pdbfile, hb
HBN.clear()
enz.clear()
def main():
"""
finds the rms between two pdbfiles without superimposing
"""
parser = OptionParser()
parser.add_option("-t", dest="target", help="target")
parser.add_option("-p", dest="probe", help="probe")
parser.add_option("-P", dest="probelist", help="probelist")
parser.add_option("-s", dest="selection", help="selection")
parser.add_option("-c",
dest="centroid",
help="center only",
action="store_true")
parser.set_description(main.__doc__)
(options, args) = parser.parse_args()
if not options.target:
parser.print_help()
sys.exit()
probes = []
if options.probelist:
probes = files_from_list(options.probelist)
elif options.probe:
probes.append(options.probe)
else:
parser.print_help()
sys.exit()
target = Enzyme()
probe = Enzyme()
target.readPDB(options.target)
mysel = None
if options.selection:
mysel = Selection()
mysel.makeSelection(options.selection)
target = mysel.apply_selection(target)
for probefile in probes:
probe.readPDB(probefile)
if options.selection:
probe = mysel.apply_selection(probe)
if options.centroid:
tar_com = target.com()
prb_com = probe.com()
rms = tar_com.distance(prb_com)
else:
rms = fit(target, probe)
print probefile, rms
probe.clear()
def main():
"""
performs a simple clash check (hard spheres)
"""
parser = OptionParser()
parser.add_option("-p", dest="pdbfile", help="pdbfile")
parser.add_option("-P", dest="pdblist", help="pdblist")
parser.add_option("-s", dest="scale", help="scale (0.60)", default=0.60)
parser.add_option("-S", dest="sele", help="selection")
parser.set_description(main.__doc__)
(options, args) = parser.parse_args()
pdbfiles = []
if options.pdbfile:
pdbfiles.append(options.pdbfile)
elif options.pdblist:
pdbfiles = files_from_list(options.pdblist)
else:
parser.print_help()
sys.exit()
myscale = float(options.scale)
mymol = Enzyme()
sele = None
if options.sele:
sele = Selection()
sele.makeSelection(options.sele)
for pdbfile in pdbfiles:
mymol.readPDB(pdbfile)
if options.sele:
reslist = sele.apply_selection(mymol).residueList()
else:
reslist = mymol.residueList()
nres = len(reslist)
bFail = False
for i in range(nres):
for j in range(i + 1, nres):
if (bResidue_Residue_clash_check(reslist[i], reslist[j],
myscale)):
print pdbfile, reslist[i].file_id, reslist[
j].file_id, "FAIL"
bFail = True
break
if bFail:
break
mymol.clear()
def main():
"""
removes the ligand
"""
parser = OptionParser()
parser.add_option("-p", dest="pdbfile", help="pdbfile")
parser.add_option("-P", dest="pdblist", help="pdblist")
parser.add_option("-o", dest="outfile", help="outfile")
parser.add_option("-O", dest="outlist", help="outlist")
parser.add_option("-r",
dest="replace",
help="replace",
action="store_true")
parser.set_description(main.__doc__)
(options, args) = parser.parse_args()
pdbfiles = []
if options.pdblist:
pdbfiles = files_from_list(options.pdblist)
elif options.pdbfile:
pdbfiles.append(options.pdbfile)
else:
parser.print_help()
sys.exit()
outfiles = []
if options.outlist:
outfiles = files_from_list(options.outlist)
elif options.outfile:
outfiles.append(options.outfile)
elif options.replace:
for file in pdbfiles:
outfiles.append(file)
else:
parser.print_help()
sys.exit()
enz = Enzyme()
for i in range(len(pdbfiles)):
enz.readPDB(pdbfiles[i])
for j in range(1, len(enz.chain)):
enz.chain[j] = 0
enz.chain.remove(0)
enz.writePDB(outfiles[i])
enz.clear()
def main():
"""
reports the scores for a catalytic residue
format: Erep,Eatr,Esol,EhbBB,EhbSC
"""
parser = OptionParser()
parser.add_option("-p", dest="pdbfile", help="pdbfile")
parser.add_option("-P", dest="pdblist", help="pdblist")
parser.add_option("-c", dest="catalytic", help="catalytic residue")
parser.set_description(main.__doc__)
(options, args) = parser.parse_args()
pdbfiles = []
if options.pdblist:
pdbfiles = files_from_list(options.pdblist)
elif options.pdbfile:
pdbfiles.append(options.pdbfile)
else:
parser.print_help()
sys.exit()
if not options.catalytic:
parser.print_help()
sys.exit()
cres = int(options.catalytic)
cres -= 1
protein = Enzyme()
for pdbfile in pdbfiles:
protein.readPDB(pdbfile)
if cres > len(protein.catalytic):
print "accessing catalytic residue out of bounds"
sys.exit()
catres = protein.catalytic[cres]
print pdbfile, catres.name, catres.Erep, catres.Eatr, catres.Esol, catres.EhbBB, catres.EhbSC
protein.clear()
def main():
"""
uses Will's packing 'holes' and reports the number of holes near a given selection
"""
parser = OptionParser()
parser.add_option("-p", dest="pdbfile", help="pdbfile")
parser.add_option("-P", dest="pdblist", help="pdblist")
parser.add_option("-s", dest="selection", help="selection")
parser.add_option("-c", dest="catalytic", help="catalytic")
parser.add_option("-x",
dest="cutoff",
help="hole radius cuotoff",
default="1.4")
parser.add_option("-r",
dest="radius",
help="radius around selection",
default="4.0")
parser.add_option("-v",
dest="verbose",
help="print holes",
action="store_true")
parser.set_description(main.__doc__)
(options, args) = parser.parse_args()
pdbfiles = []
if options.pdblist:
pdbfiles = files_from_list(options.pdblist)
elif options.pdbfile:
pdbfiles.append(options.pdbfile)
else:
parser.print_help()
sys.exit()
sele = Selection()
if options.selection:
sele.makeSelection(options.selection)
hole_sele = Selection()
hole_sele.makeSelection("resn=WSS")
hole_radius = float(options.cutoff)
protein = Enzyme()
for pdbfile in pdbfiles:
protein.readPDB(pdbfile)
holes = hole_sele.apply_selection(protein).atomList()
if len(holes) == 0:
print pdbfile, "no packing information found"
protein.clear()
continue
catres = []
if options.selection:
protein = sele.apply_selection(protein)
elif options.catalytic:
if len(protein.catalytic) == 0:
print "no catalytic information found!"
sys.exit()
catindex = int(options.catalytic) - 1
if catindex < 0 or catindex >= len(protein.catalytic):
print "accessing catalytic residue out of bounds: ", catindex
sys.exit()
catres = protein.catalytic[catindex]
if options.catalytic:
protList = catres.atom
else:
protList = protein.atomList()
surrounding = atomsAroundAtoms(atms=protList,
atomList=holes,
cutoff=float(options.radius))
# filter based on radius of sphere
outholes_b = []
outholes = []
for atm in surrounding:
if atm.bfactor > hole_radius:
if not atm.occupancy in outholes_b:
outholes.append(atm)
outholes_b.append(atm.occupancy)
print pdbfile, len(outholes)
if options.verbose:
for atm in outholes:
print atm
print "------------------------------------------------------"
protein.clear()
def main():
"""
prints a list of mutations between a designed sequence and a native sequence
"""
parser = OptionParser()
parser.add_option("-p", dest="pdbfile", help="pdbfile")
parser.add_option("-P", dest="pdblist", help="pdblist")
parser.add_option("-n", dest="native", help="native")
parser.add_option("-t", dest="type", help="type")
parser.add_option("-T", dest="origType", help="original type")
parser.add_option("-s", dest="summary", help="print pdbfile only", action="store_true")
parser.add_option("-c", dest="count", help="count", action="store_true")
parser.set_description(main.__doc__)
(options,args) = parser.parse_args()
pdbfiles = []
if options.pdblist:
pdbfiles = files_from_list(options.pdblist)
elif options.pdbfile:
pdbfiles.append(options.pdbfile)
else:
parser.print_help()
sys.exit()
if not options.native:
parser.print_help()
sys.exit()
native = Enzyme()
native.readPDB(options.native)
protein = Enzyme()
natseq = native.sequence()
for pdbfile in pdbfiles:
nmut = 0
mut_found = False
protein.readPDB(pdbfile)
mutseq = protein.sequence()
mysize = min(len(natseq), len(mutseq))
for i in range(mysize):
if natseq[i] != mutseq[i]:
if options.type:
if not (mutseq[i] in options.type):
continue
if options.origType:
if not (natseq[i] in options.origType):
continue
mut_found = True
nmut += 1
if not options.summary:
print i+1,natseq[i],"->",mutseq[i]
if options.summary and mut_found:
if options.count:
print pdbfile,nmut
else:
print pdbfile
protein.clear()
native.clear()
def main():
"""
reports the residues with polar sidechain atoms contacting a given selection
"""
parser = OptionParser()
parser.add_option("-p", dest="pdbfile", help="pdbfile")
parser.add_option("-P", dest="pdblist", help="pdblist")
parser.add_option("-s", dest="selection", help="selection")
parser.add_option("-c", dest="catalytic", help="catalytic")
parser.add_option("-x",
dest="cutoff",
help="cutoff (default 3.5)",
default=3.5)
parser.add_option("-n",
dest="number",
help="number only",
action="store_true")
parser.add_option("--charged_only",
dest="charged",
help="charged residues only",
action="store_true")
parser.add_option("--ignore_catalytic",
dest="no_cat",
help="ignore catalytic residues",
action="store_true")
parser.set_description(main.__doc__)
(options, args) = parser.parse_args()
cutoff = float(options.cutoff)
if not options.selection and not options.catalytic:
parser.print_help()
sys.exit()
pdbfiles = []
if options.pdblist:
pdbfiles = files_from_list(options.pdblist)
elif options.pdbfile:
pdbfiles.append(options.pdbfile)
else:
parser.print_help()
sys.exit()
sele = Selection()
if options.selection:
sele.makeSelection(options.selection)
protein = Enzyme()
protSel = Selection()
protSel.makeSelection("SC;type=ATOM ")
for pdbfile in pdbfiles:
protein.readPDB(pdbfile)
if options.catalytic:
icat = int(options.catalytic)
if icat == 0 or icat > len(protein.catalytic):
print "accessing catalytic out of bounds"
sys.exit()
mysel = protein.catalytic[icat - 1].atomList()
else:
mysel = sele.apply_selection(protein).atomList()
protAtoms = protSel.apply_selection(protein)
nearby_atoms = atomsAroundAtoms(mysel, protAtoms, cutoff=cutoff)
reslist = []
for atm in nearby_atoms:
if options.no_cat:
catFound = False
for cat in protein.catalytic:
if int(atm.resi) == int(cat.file_id):
catFound = True
break
if catFound:
continue
if not atm.parentResidue in reslist:
reslist.append(atm.parentResidue)
if options.number:
print pdbfile, len(reslist)
else:
for res in reslist:
#if options.charged:
# if res.name != "ARG" and res.name != "LYS" and res.name != "GLU" and res.name != "ASP":
# continue
if res.name == "PHE" or res.name == "TRP" or res.name == "TYR" or res.name == "MET":
print res.file_id, res.name
protein.clear()
def main():
"""
reads a rosetta output pdbfile and reports residues that have a lig_dun > cutoff
"""
parser = OptionParser()
parser.add_option("-p", dest="pdbfile", help="pdbfile")
parser.add_option("-P", dest="pdblist", help="pdblist")
parser.add_option("-x", dest="cutoff", help="cutoff", default=3.0)
parser.add_option("-s",
dest="summary",
help="summary",
action="store_true")
parser.add_option("-c", dest="catalytic", help="catalytic residues")
parser.add_option("-l",
dest="ligand",
help="only ligand",
action="store_true")
parser.add_option("-n", dest="name", help="residue name (unique)")
parser.add_option("-C",
dest="catall",
help="catalytic and ligand",
action="store_true")
parser.set_description(main.__doc__)
(options, args) = parser.parse_args()
pdbfiles = []
if options.pdblist:
pdbfiles = files_from_list(options.pdblist)
elif options.pdbfile:
pdbfiles.append(options.pdbfile)
else:
parser.print_help()
sys.exit()
cutoff = float(options.cutoff)
bCat = False
if options.catalytic or options.ligand or options.catall:
bCat = True
protein = Enzyme()
for pdbfile in pdbfiles:
protein.readPDB(pdbfile)
tot_value = 0
tot_atr = 0
max_val = -1
catres = []
if options.catall:
for cat in protein.catalytic:
catres.append(cat)
if options.catalytic:
icat = int(options.catalytic) - 1
if icat >= len(protein.catalytic):
print pdbfile, "catalytic out of bounds"
sys.exit()
catres.append(protein.catalytic[icat])
if options.ligand or options.catall:
catres.append(protein.ligand)
if options.name:
bCat = True
catres = protein.getResiduesByName(options.name)
if len(catres) != 1:
print "too many catalytic residues"
sys.exit()
for chn in protein.chain:
for res in chn.residue:
if bCat:
if not res in catres:
continue
edun = res.Edun
if edun > cutoff:
tot_value += edun
max_val = max(max_val, edun)
if options.summary:
print pdbfile
break
else:
print pdbfile, res.file_id, res.name, edun
#print pdbfile,tot_value,max_val
protein.clear()
def main():
"""
finds the rms between two pdbfiles without superimposing
"""
parser = OptionParser()
parser.add_option("-t", dest="target", help="target")
parser.add_option("-p", dest="probe", help="probe")
parser.add_option("-P", dest="probelist", help="probelist")
parser.add_option("-c", dest="catalytic", help="catalytic residue")
parser.add_option("-H",
dest="heavy",
help="heavy atom only",
action="store_true")
parser.set_description(main.__doc__)
(options, args) = parser.parse_args()
if not options.target:
parser.print_help()
sys.exit()
probes = []
if options.probelist:
probes = files_from_list(options.probelist)
elif options.probe:
probes.append(options.probe)
else:
parser.print_help()
sys.exit()
if not options.catalytic:
parser.print_help()
sys.exit()
target = Enzyme()
probe = Enzyme()
target.readPDB(options.target)
icat = int(options.catalytic) - 1
if icat > len(target.catalytic):
print "accessing catalytic residue out of bounds"
sys.exit()
tar_cat = target.catalytic[icat]
tlist = []
if options.heavy:
for atm in tar_cat.atom:
if atm.element != "H":
tlist.append(atm)
else:
tlist = tar_cat.atom
for probefile in probes:
probe.readPDB(probefile)
if icat > len(probe.catalytic):
print "accessing catalytic residue out of bounds"
sys.exit()
prb_cat = probe.catalytic[icat]
plist = []
if options.heavy:
for atm in prb_cat.atom:
if atm.element != "H":
plist.append(atm)
else:
plist = prb_cat.atom
rms = fitAtomList(tlist, plist)
print probefile, rms
probe.clear()
def main():
"""
reads a rosetta output pdbfile and reports residues that have a lig_rep > cutoff
"""
parser = OptionParser()
parser.add_option("-p", dest="pdbfile", help="pdbfile")
parser.add_option("-P", dest="pdblist", help="pdblist")
parser.add_option("-x", dest="cutoff", help="cutoff", default=3.0)
parser.add_option("-s", dest="summary", help="summary", action="store_true")
parser.add_option("-c", dest="catalytic", help="catalytic residues", action="store_true")
parser.add_option("-l", dest="ligand", help="only ligand", action="store_true")
parser.add_option("-n", dest="name", help="residue name (unique)")
parser.add_option("-C", dest="catall", help="catalytic and ligand", action="store_true")
parser.add_option("-t", dest="total", help="total", action="store_true")
parser.add_option("-r", dest="radius", help="include residues within radius")
parser.set_description(main.__doc__)
(options,args) = parser.parse_args()
pdbfiles = []
if options.pdblist:
pdbfiles = files_from_list(options.pdblist)
elif options.pdbfile:
pdbfiles.append(options.pdbfile)
else:
parser.print_help()
sys.exit()
cutoff = float(options.cutoff)
bCat = False
if options.catalytic or options.ligand or options.catall:
bCat = True
bRad = False
if options.radius:
bRad = True
rad_cutoff = float(options.radius)
protein = Enzyme()
for pdbfile in pdbfiles:
protein.readPDB(pdbfile)
tot_value = 0
tot_atr = 0
catres = []
if options.catalytic or options.catall:
for cat in protein.catalytic:
catres.append(cat)
if options.ligand or options.catall:
catres.append(protein.ligand)
if options.name:
bCat = True
catres = protein.getResiduesByName(options.name)
if len(catres) != 1:
print "too many catalytic residues"
sys.exit()
for chn in protein.chain:
if bRad:
ligAtms = protein.ligand.atom
near_res = residuesAroundAtoms(ligAtms, protein, rad_cutoff)
for res in chn.residue:
if bCat and not bRad:
if not res in catres:
continue
if bRad:
if not res in catres:
if not res in near_res:
continue
erep = res.Erep
if erep > cutoff:
tot_value += erep
tot_atr += res.Eatr
if options.summary:
print pdbfile
break
if not options.total:
myE = res.Erep + res.Eatr + res.EhbSC + res.Esol + res.Edun
print pdbfile,res.name,res.file_id,res.Erep,res.Eatr,res.EhbSC,res.Esol,res.Edun,myE
if options.total:
print pdbfile,tot_value,tot_atr
protein.clear()
def main():
"""
creates a resfile from an enzyme
"""
parser = OptionParser()
parser.add_option("-P", dest="pdblist", help="pdblist")
parser.add_option("-p", dest="pdbfile", help="pdbfile")
parser.add_option("-o", dest="outfile", help="outfile")
parser.add_option("-O", dest="outlist", help="outlist")
parser.add_option("--no_gly",
dest="no_gly",
help="no glycine at ss",
action="store_true")
parser.set_description(main.__doc__)
(options, args) = parser.parse_args()
pdbfiles = []
if options.pdblist:
pdbfiles = files_from_list(options.pdblist)
elif options.pdbfile:
pdbfiles.append(options.pdbfile)
else:
parser.print_help()
sys.exit()
outfiles = []
if options.outlist:
outfiles = files_from_list(options.outlist)
elif options.outfile:
outfiles.append(options.outfile)
else:
parser.print_help()
sys.exit()
nfiles = len(pdbfiles)
if len(outfiles) != nfiles:
print "number of files differ"
parser.print_help()
sys.exit()
enz = Enzyme()
resfile = Resfile()
for ifile in range(nfiles):
enz.clear()
resfile.clear()
enz.readPDB(pdbfiles[ifile])
resfile.setMolecule(enz)
if options.no_gly:
natss = getSecondaryStructure(pdbfiles[ifile])
if len(natss) < enz.protein.numResidues():
print "number of residues and secondary structure do no match"
sys.exit()
prot = enz.protein
lig = enz.ligand
nres = len(prot.residue)
designable = [False] * nres
repackable = [False] * nres
for i in range(nres):
res = prot.residue[i]
if enz.isCatalytic(res):
resfile.setCatalytic(i)
else:
if res.name == "GLY":
CB = res.getAtom(" CA ")
else:
CB = res.getAtom(" CB ")
#if options.only_cat:
# --- get distance to ligand --- #
distCB = closestApproachToResidue(CB, lig)
if distCB < 6.0:
designable[i] = True
elif distCB < 8.0:
if isResPointingToRes(res, lig, cutoff=60):
designable[i] = True
else:
repackable[i] = True
elif distCB < 10.0:
repackable[i] = True
# --- get distance to residue
focusedRes = None
mindist = 5000
for cres in enz.catalytic:
dist = closestApproachToResidue(CB, cres)
if dist < mindist:
focusedRes = cres
mindist = dist
if focusedRes != None:
if mindist < 5.5:
if isResPointingToRes(res, focusedRes, cutoff=60):
designable[i] = True
else:
repackable[i] = True
elif mindist < 7.0:
repackable[i] = True
for i in range(nres):
res = enz.protein.residue[i]
if designable[i]:
if options.no_gly and res.name != "GLY":
if natss[i] == "H" or natss[i] == "E":
resfile.designNoGly(i)
else:
resfile.designOnly(i)
else:
resfile.designOnly(i)
elif repackable[i]:
resfile.repackOnly(i)
resfile.write(outfiles[ifile])
def main():
"""
checks for hydrogen bonds to ligands. Ligands differ because we don't know
the acceptor antecedants
"""
parser = OptionParser()
parser.add_option("-p", dest="pdbfile", help="pdbfile")
parser.add_option("-P", dest="pdblist", help="pdblist")
parser.add_option("-a", dest="acceptors", help="ligand acceptors")
parser.add_option("-d", dest="donors", help="ligand donors")
parser.add_option("-c", dest="catalytic", help="catalytic")
parser.add_option("-x", dest="cutoff", help="cutoff", default=-0.3)
parser.set_description(main.__doc__)
(options, args) = parser.parse_args()
pdbfiles = []
if options.pdblist:
pdbfiles = files_from_list(options.pdblist)
elif options.pdbfile:
pdbfiles.append(options.pdbfile)
else:
parser.print_help()
sys.exit()
protein = Enzyme()
HBN = HBnetwork()
if options.donors:
donor_sel = Selection()
donor_sel.makeSelection(options.donors)
if options.acceptors:
acceptor_sel = Selection()
acceptor_sel.makeSelection(options.acceptors)
for pdbfile in pdbfiles:
protein.readPDB(pdbfile)
ligands = protein.getHeteroAtoms()
lig = ligands[0]
residues = []
if options.catalytic:
cres = protein.catalytic[int(options.catalytic) - 1]
#cres = getCatalyticResidue(protein,int(options.catalytic))
if cres == None:
print "unable to find catalytic residue!"
sys.exit()
residues.append(cres)
else:
residues = protein.residueList()
HBN.createNetwork(reslist=residues)
if options.donors:
donors = donor_sel.apply_selection(protein).atomList()
if options.acceptors:
acceptors = acceptor_sel.apply_selection(protein).atomList()
if len(acceptors) == 0:
print "unable to find acceptors"
sys.exit()
for a in acceptors:
HBN.newAcceptor(A=a, res=lig)
HBN.findHbonds(cutoff=float(options.cutoff), function=1)
hblist = HBN.getHbondsToResidue(lig)
if len(hblist) > 0:
for Hb in hblist:
print pdbfile, Hb
else:
print pdbfile, " none"
HBN.clear()
protein.clear()
def main():
"""
reports the buried unsatisfied hydrogen bonds in a pdbfile.
REQUIRES NACCESS
"""
parser = OptionParser()
parser.add_option("-p", dest="pdbfile", help="pdbfile")
parser.add_option("-P", dest="pdblist", help="pdblist")
parser.add_option("-s", dest="selection", help="selection")
parser.add_option("-c", dest="catalytic", help="catalytic")
parser.add_option("-x",
dest="cutoff",
help="surface area cutoff",
default=5.0)
parser.add_option("-X",
dest="hcutoff",
help="hbond energy ctuoff",
default=-0.1)
parser.add_option("-r",
dest="report",
help="report number only",
action="store_true")
parser.set_description(main.__doc__)
(options, args) = parser.parse_args()
pdbfiles = []
if options.pdblist:
pdbfiles = files_from_list(options.pdblist)
elif options.pdbfile:
pdbfiles.append(options.pdbfile)
else:
parser.print_help()
sys.exit()
protein = Enzyme()
HBN = HBnetwork()
surfout = Molecule()
sele = Selection()
sele_string = ""
if options.selection:
sele.makeSelection(options.selection)
sele_string += options.selection
for pdbfile in pdbfiles:
outlist = []
protein.readPDB(pdbfile)
catid = -1
if options.catalytic:
icat = int(options.catalytic) - 1
if icat >= len(protein.catalytic):
print "accessing catalytic out of bounds"
continue
catres = protein.catalytic[icat]
catid = int(catres.file_id)
HBN.createNetwork(protein)
HE = float(options.hcutoff)
HBN.findHbonds(cutoff=HE)
unsat = HBN.unsatisfiedHbonds()
get_surface_area(pdbfile, "surf")
surfout.readPDB("surf.asa")
if surfout.numResidues == 0:
print "surf.asa not found"
sys.exit()
if options.selection:
newMol = sele.apply_selection(mol=surfout)
surfout.clear()
newMol.clone(surfout)
for atm in unsat:
myres = surfout.getResidue(int(atm.resi))
if myres == None:
continue
myatm = myres.getAtom(atm.name)
if myatm == None:
continue
if catid != -1:
if int(myres.file_id) != catid:
continue
if myatm.occupancy <= float(options.cutoff):
outlist.append(myatm)
if options.report:
print pdbfile, len(outlist)
else:
for atm in outlist:
print atm
protein.clear()
HBN.clear()
surfout.clear()
# clear out intermediate files
os.system("rm -f surf.log")
os.system("rm -f surf.pdb")
os.system("rm -f surf.rsa")
os.system("rm -f surf.asa")
def main():
"""
reads a rosetta output pdbfile and reports residues that have a total Eres > cutoff
"""
parser = OptionParser()
parser.add_option("-p", dest="pdbfile", help="pdbfile")
parser.add_option("-P", dest="pdblist", help="pdblist")
parser.add_option("-x", dest="cutoff", help="cutoff", default=3.0)
parser.add_option("-s",
dest="summary",
help="summary",
action="store_true")
parser.add_option("-c",
dest="catalytic",
help="only catalytic residues",
action="store_true")
parser.add_option("-l",
dest="ligand",
help="only ligand",
action="store_true")
parser.add_option("-C",
dest="catall",
help="catalytic and ligand",
action="store_true")
parser.add_option("-t", dest="total", help="total", action="store_true")
parser.set_description(main.__doc__)
(options, args) = parser.parse_args()
pdbfiles = []
if options.pdblist:
pdbfiles = files_from_list(options.pdblist)
elif options.pdbfile:
pdbfiles.append(options.pdbfile)
else:
parser.print_help()
sys.exit()
cutoff = float(options.cutoff)
bCat = False
if options.catalytic or options.ligand or options.catall:
bCat = True
protein = Enzyme()
for pdbfile in pdbfiles:
protein.readPDB(pdbfile)
tot_value = 0
catres = []
if options.catalytic or options.catall:
for cat in protein.catalytic:
catres.append(cat)
if options.ligand or options.catall:
catres.append(protein.ligand)
for chn in protein.chain:
for res in chn.residue:
if bCat:
if not res in catres:
continue
if res.Erep > cutoff:
tot_value += res.Eres
if options.summary:
print pdbfile
break
if not options.total:
print pdbfile, res.name, res.file_id, res.Eres
if options.total:
print pdbfile, tot_value
protein.clear()
def main():
"""
adds a centroid
"""
parser = OptionParser()
parser.add_option("-p", dest="pdbfile", help="pdbfile")
parser.add_option("-P", dest="pdblist", help="pdblist")
parser.add_option("-o", dest="outfile", help="outfile")
parser.add_option("-O", dest="outlist", help="outlist")
parser.add_option("-r",
dest="replace",
help="replace",
action="store_true")
parser.add_option("-t", dest="type", help="atom type", default="CS1 ")
parser.add_option("-s", dest="selection", help="selection")
parser.add_option("-w", dest="wobble", help="wobble", action="store_true")
parser.set_description(main.__doc__)
(options, args) = parser.parse_args()
pdbfiles = []
if options.pdblist:
pdbfiles = files_from_list(options.pdblist)
elif options.pdbfile:
pdbfiles.append(options.pdbfile)
else:
parser.print_help()
sys.exit()
outfiles = []
if options.outlist:
outfiles = files_from_list(options.outlist)
elif options.outfile:
outfiles.append(options.outfile)
elif options.replace:
for file in pdbfiles:
outfiles.append(file)
else:
parser.print_help()
sys.exit()
nfiles = len(pdbfiles)
if nfiles != len(outfiles):
print "number of input and output files differ"
sys.exit()
if not options.selection:
parser.print_help()
sys.exit()
mymol = Enzyme()
sele = Selection()
sele.makeSelection(options.selection)
for i in range(nfiles):
pdbfile = pdbfiles[i]
outfile = outfiles[i]
mymol.readPDB(pdbfile)
alist = sele.apply_selection(mymol).atomList()
if len(alist) == 0:
print "pdbfile: no atoms"
continue
com = vector3d()
for atm in alist:
com += atm.coord
com /= float(len(alist))
newatm = mymol.ligand.newAtom()
newatm.name = options.type
newatm.coord.x = com.x
newatm.coord.y = com.y
newatm.coord.z = com.z
newatm.kind = "HETATM"
if options.wobble:
newatm.coord.x += 0.001
newatm.coord.y -= 0.001
newatm.coord.z += 0.001
mymol.writePDB(outfile)
mymol.clear()
def main():
"""
returns the surface area of a protein (or selection).
REQUIRES EXTERNAL BINARY "NACCESS".
This looks for naccess in ~/code/naccess/nacess
or in /net/local/bin/naccess
"""
parser = OptionParser()
parser.add_option("-p", dest="pdbfile", help="pdbfile")
parser.add_option("-P", dest="pdblist", help="pdblist")
parser.add_option("-s", dest="selection", help="selection")
parser.add_option("-c", dest="catalytic", help="catalytic")
parser.add_option("-t",
dest="total",
help="report total surface area",
action="store_true")
parser.set_description(main.__doc__)
(options, args) = parser.parse_args()
pdbfiles = []
if options.pdblist:
pdbfiles = files_from_list(options.pdblist)
elif options.pdbfile:
pdbfiles.append(options.pdbfile)
else:
parser.print_help()
sys.exit()
# if not options.selection and not options.catalytic:
# parser.print_help()
# sys.exit()
sasafile = Molecule()
sele = Selection()
if options.selection:
sele.makeSelection(options.selection)
enz = Enzyme()
outbase = "clean"
outpdb = outbase + ".asa"
for pdbfile in pdbfiles:
if options.catalytic:
enz.readPDB(pdbfile)
icat = int(options.catalytic) - 1
cres = int(enz.catalytic[icat].file_id)
newsele = "resi=" + str(cres)
if options.selection:
newsele += ";" + options.selection
sele.clear()
sele.makeSelection(newsele)
enz.clear()
get_surface_area(pdbfile, outbase)
sasafile.readPDB(outpdb)
if options.selection or options.catalytic:
atmlist = sele.apply_selection(sasafile).atomList()
else:
atmlist = sasafile.atomList()
if options.total:
tot_sas = 0.0
for atm in atmlist:
tot_sas += atm.occupancy
print pdbfile, ":", tot_sas
else:
print pdbfile, ":"
for atm in atmlist:
#print atm
print atm.file_id, atm.name, atm.resn, atm.resi, atm.occupancy, atm.bfactor
sasafile.clear()
def main():
"""
checks for shape complementarity for the enzyme
"""
parser = OptionParser()
parser.add_option("-P", dest="pdblist", help="pdblist")
parser.add_option("-p", dest="pdbfile", help="pdbfile")
parser.set_description(main.__doc__)
(options, args) = parser.parse_args()
pdbfiles = []
if options.pdblist:
pdbfiles = files_from_list(options.pdblist)
elif options.pdbfile:
pdbfiles.append(options.pdbfile)
else:
parser.print_help()
sys.exit()
# --- read in dot information --- #
home = os.environ["pyScriptsDir"]
dotfile = home + "/data/sa64.dat"
dotlib = DotLib()
dotlib.read(dotfile)
protein = Enzyme()
for pdbfile in pdbfiles:
protein.readPDB(pdbfile)
ligAtoms = protein.ligand.atom
atomlist = []
for a in ligAtoms:
if a.radius == 0:
continue
atomlist.append(a)
# --- get nearby atoms --- #
prot = protein.protein
nearbyatoms = atomsAroundAtoms(atms=atomlist,
atomList=prot.atomList(),
cutoff=7.0)
ligand_molsurf = MolSurface(dotlib)
ligand_molsurf.setAtoms(atomlist)
ligand_molsurf.extractSurface()
mypnts = ligand_molsurf.identifyExposed(atomlist=nearbyatoms)
ligand_molsurf.removePoints(mypnts, buffer=1.5)
ligand_molsurf.extractNormals()
#ligand_molsurf.printSurfacePoints(" O ")
#ligand_molsurf.printNormals(" N ")
#return
active_molsurf = MolSurface(dotlib)
active_molsurf.setAtoms(nearbyatoms)
active_molsurf.extractSurface()
active_molsurf.restrictToNearby(atomlist=atomlist, buffer=2.8)
mypnts = active_molsurf.identifyExposed(atomlist)
active_molsurf.removePoints(mypnts, buffer=1.5)
active_molsurf.extractNormals()
#active_molsurf.printSurfacePoints(" N ")
#active_molsurf.printNormals(" O ")
#return
# --- get shape complementarity --- #
S_ab = []
for ilig in range(ligand_molsurf.numPoints()):
xa = ligand_molsurf.points[ilig]
# must be shielded from solvent
iactive = active_molsurf.closestPoint(xa)
if iactive == -1:
continue
xb = active_molsurf.points[iactive]
na = ligand_molsurf.normals[ilig]
tb = active_molsurf.normals[iactive]
nb = vector3d(-tb.x, -tb.y, -tb.z)
dist2 = -0.5 * xa.dist2(xb)
dotp = na * nb
ans = dotp * math.exp(dist2)
S_ab.append(float(ans))
S_ba = []
for iAct in range(active_molsurf.numPoints()):
xb = active_molsurf.points[iAct]
# must be shielded from solvent
ilig = ligand_molsurf.closestPoint(xb)
if ilig == -1:
continue
xb = active_molsurf.points[iAct]
nb = active_molsurf.normals[iAct]
xa = ligand_molsurf.points[ilig]
ta = ligand_molsurf.normals[ilig]
na = vector3d(-ta.x, -ta.y, -ta.z)
dist2 = -0.5 * xa.dist2(xb)
dotp = math.fabs(na * nb)
ans = dotp * math.exp(dist2)
S_ba.append(float(ans))
S_ab.sort()
S_ba.sort()
med_index_ab = len(S_ab) / 2
med_index_ba = len(S_ba) / 2
print med_index_ab
print "Sab = ", S_ab[med_index_ab]
SC = 0.5 * (S_ab[med_index_ab] + S_ba[med_index_ba])
print "SC = ", SC
protein.clear()
def main():
"""
reports a list of unique matches. This is defined by the identity of the
catalytic residues and the position of space of the ligand (discreteness defined
by the "fineness" option)
"""
parser = OptionParser()
parser.add_option("-p", dest="pdbfile", help="pdbfile")
parser.add_option("-P", dest="pdblist", help="pdblist")
parser.add_option("-f",
dest="fineness",
help="fineness (0.25)",
default=0.25)
parser.add_option("-s",
dest="seq_only",
help="sequence only",
action="store_true")
parser.add_option("--heavy_atom_only",
dest="heavy_only",
help="only heavy atoms considered",
action="store_true")
parser.add_option("-r",
dest="report",
help="report unique matches only",
action="store_true")
parser.add_option("-i",
dest="inverse",
help="inverse",
action="store_true")
parser.set_description(main.__doc__)
(options, args) = parser.parse_args()
pdbfiles = []
if options.pdblist:
pdbfiles = files_from_list(options.pdblist)
elif options.pdbfile:
pdbfiles.append(options.pdbfile)
else:
parser.print_help()
sys.exit()
protein = Enzyme()
fineness = float(options.fineness)
seen = {}
for pdbfile in pdbfiles:
name = ""
protein.readPDB(pdbfile)
com = vector3d()
if options.heavy_only:
natom = 0
for atm in protein.chain[0].atomList():
if atm.element != "H":
com.x += atm.coord.x
com.y += atm.coord.y
com.z += atm.coord.z
natom += 1
if natom > 0:
com /= float(natom)
else:
com = protein.chain[0].com()
lcom = protein.ligand.com()
# get absolute value of ligand coordinates
rcom = vector3d()
nat = 0
for atm in protein.ligand.atom:
rcom.x += math.fabs(atm.coord.x - lcom.x)
rcom.y += math.fabs(atm.coord.y - lcom.y)
rcom.z += math.fabs(atm.coord.z - lcom.z)
nat += 1
if nat == 0:
print "no ligand atoms founds"
sys.exit()
for cat in protein.catalytic:
name += cat.aa1() + str(int(cat.file_id)) + "_"
# get the ligand position
if not options.seq_only:
lpoint = (lcom - com) / fineness
rcom /= fineness
name += str(int(lpoint.x)) + "_"
name += str(int(lpoint.y)) + "_"
name += str(int(lpoint.z)) + "_"
name += str(int(rcom.x)) + "_"
name += str(int(rcom.y)) + "_"
name += str(int(rcom.z))
if options.report:
if options.inverse:
if name in seen.keys():
print pdbfile, name
else:
if not (name in seen.keys()):
print pdbfile, name
else:
print pdbfile, name
seen[name] = 1
protein.clear()
def main():
"""
checks the shape complementarity of the ligand in an enzyme
"""
parser = OptionParser()
parser.add_option("-p", dest="pdbfile", help="pdbfile")
parser.add_option("-P", dest="pdblist", help="pdblist")
parser.set_description(main.__doc__)
(options, args) = parser.parse_args()
pdbfiles = []
if options.pdblist:
pdbfiles = files_from_list(options.pdblist)
elif options.pdbfile:
pdbfiles.append(options.pdbfile)
else:
parser.print_help()
sys.exit()
protein = Enzyme()
sele = Selection()
sele.makeSelection("element=C,N,O,S")
tmp_pdbfile = "_tmpscpdb.pdb"
input_file = "_sc_input"
output_file = "_sc_output"
try:
SC_INPUT = open(input_file, 'w')
except:
print "unable to create temporary SC_INPUT"
sys.exit()
SC_INPUT.write("molecule 1\n")
SC_INPUT.write("chain A\n")
SC_INPUT.write("molecule 2\n")
SC_INPUT.write("chain B\n")
SC_INPUT.write("END\n")
SC_INPUT.close()
for pdbfile in pdbfiles:
protein.readPDB(pdbfile)
if protein.numChains() != 2:
print pdbfile + ": not enough chains", protein.numChains()
protein.clear()
continue
protein.chain[0].name = "A"
protein.chain[1].name = "B"
newprot = sele.apply_selection(protein)
newprot.writePDB(tmp_pdbfile)
protein.clear()
newprot.clear()
commands.getoutput("sc XYZIN " + tmp_pdbfile +
" SCRADII rosetta_radii.lib < " + input_file +
" > " + output_file)
ans = commands.getoutput("grep 'Shape complementarity statistic Sc' " +
output_file)
cols = ans.split()
if len(cols) < 5:
continue
medSC = float(cols[5])
ans = commands.getoutput("grep 'molecule 2 after trim' " + output_file)
cols = ans.split()
if len(cols) < 11:
continue
ndots1 = float(cols[10])
print pdbfile, medSC, ndots1, medSC * ndots1
commands.getoutput("rm -f " + output_file)
commands.getoutput("rm -f " + tmp_pdbfile)
commands.getoutput("rm -f " + input_file)
def main():
"""
reports the angle between three uniquely identified atoms in a pdbfile
"""
parser = OptionParser()
parser.add_option("-p", dest="pdbfile", help="pdbfile")
parser.add_option("-P", dest="pdblist", help="pdblist")
parser.add_option("--s1", dest="selection1", help="selection1")
parser.add_option("--s2", dest="selection2", help="selection2")
parser.add_option("--s3", dest="selection3", help="selection3")
parser.add_option("--s4", dest="selection4", help="selection4")
parser.set_description(main.__doc__)
(options, args) = parser.parse_args()
pdbfiles = []
if options.pdblist:
pdbfiles = files_from_list(options.pdblist)
elif options.pdbfile:
pdbfiles.append(options.pdbfile)
else:
parser.print_help()
sys.exit()
if not options.selection1 or not options.selection2:
parser.print_help()
sys.exit()
sele1 = Selection()
sele2 = Selection()
sele3 = Selection()
sele4 = Selection()
sele1.makeSelection(options.selection1)
sele2.makeSelection(options.selection2)
sele3.makeSelection(options.selection3)
sele4.makeSelection(options.selection4)
protein = Enzyme()
for pdbfile in pdbfiles:
protein.readPDB(pdbfile)
mol1 = sele1.apply_selection(protein)
mol2 = sele2.apply_selection(protein)
mol3 = sele3.apply_selection(protein)
mol4 = sele4.apply_selection(protein)
alist1 = mol1.atomList()
alist2 = mol2.atomList()
alist3 = mol3.atomList()
alist4 = mol4.atomList()
if len(alist1) != 1:
print "selection 1 does not specify 1 atom"
sys.exit()
if len(alist2) != 1:
print "selection 2 does not specify 1 atom"
sys.exit()
if len(alist3) != 1:
print "selection 3 does not specify 1 atom"
sys.exit()
if len(alist4) != 1:
print "selection 4 does not specify 1 atom"
sys.exit()
atm1 = alist1[0]
atm2 = alist2[0]
atm3 = alist3[0]
atm4 = alist4[0]
tor = vector3d.torsion(atm1.coord, atm2.coord, atm3.coord, atm4.coord)
print pdbfile, ":", atm1.name, "->", atm2.name, "->", atm3.name, "->", atm4.name, ":", tor
protein.clear()
def main():
"""
reports cavities around selections
"""
parser = OptionParser()
parser.add_option("-p", dest="pdbfile", help="pdbfile")
parser.add_option("-P", dest="pdblist", help="pdblist")
parser.add_option("-x", dest="cutoff", help="cutoff", default=3.0)
parser.add_option("-c", dest="catalytic", help="only catalytic residues")
parser.add_option("-l", dest="ligand", help="only ligand", action="store_true")
parser.add_option("-C", dest="catall", help="all catalytic residues", action="store_true")
parser.add_option("-r", dest="radius", help="hole radius", default=1.4)
parser.add_option("-s", dest="selection", help="selection")
parser.set_description(main.__doc__)
(options,args) = parser.parse_args()
pdbfiles = []
if options.pdblist:
pdbfiles = files_from_list(options.pdblist)
elif options.pdbfile:
pdbfiles.append(options.pdbfile)
else:
parser.print_help()
sys.exit()
cutoff = float(options.cutoff)
bCat = False
if options.catalytic or options.ligand or options.catall:
bCat = True
re_cluster = re.compile("COMMENT CavClust")
sele = Selection()
if options.selection:
sele.makeSelection(options.selection)
protein = Enzyme()
for pdbfile in pdbfiles:
protein.readPDB(pdbfile)
cat_id = []
mysel = []
if options.catalytic:
icat = int(options.catalytic) -1
if icat < 0 or icat >= len(protein.catalytic):
print "accessing catalytic out of bounds"
sys.exit()
mysel.append(protein.catalytic[icat])
elif options.catall:
for cat in protein.catalytic:
mysel.append(cat)
if options.ligand:
for res in protein.chain[0].residue:
if res.name == "LG1":
mysel.append(res)
if options.selection:
tmp = sele.apply_selection(protein)
for chn in tmp.chain:
for res in chn.residue:
mysel.append(res)
# get cavities
cavities = []
for chn in protein.chain:
for res in chn.residue:
if res.name == "WSS":
cavities.append(res)
cav_atom_list = []
for res in cavities:
for atm in res.atom:
cav_atom_list.append(atm)
sel_atom_list = []
for res in mysel:
for atm in res.atom:
sel_atom_list.append(atm)
nearby_cav_atoms = atomsAroundAtoms(sel_atom_list, atomList=cav_atom_list, cutoff=cutoff)
cav_res = []
for atm in nearby_cav_atoms:
if not atm.parentResidue in cav_res:
cav_res.append(atm.parentResidue)
# get cavities
chainZ = protein.getChain("Z")
if chainZ == None:
print "cant' find chain Z"
sys.exit()
pdb_cav_list = []
icav = 1
for res in chainZ.residue:
if res in cav_res:
pdb_cav_list.append(icav)
icav += 1
protein.clear()
try:
PDBFILE = open(pdbfile)
except:
print "can't open pdbfile"
sys.exit()
tot_vol = 0.0
for line in PDBFILE.readlines():
if re_cluster.match(line):
cols = line.split()
if int(cols[2]) in pdb_cav_list:
tot_vol += float(cols[5])
print pdbfile,len(cav_res),tot_vol
PDBFILE.close()
def main():
"""
prints the number of CB's that are near atoms in a given selection
"""
parser = OptionParser()
parser.add_option("-p", dest="pdbfile", help="pdbfile")
parser.add_option("-P", dest="pdblist", help="pdblist")
parser.add_option("-c", dest="catalytic", help="catalytic")
parser.add_option("-s", dest="selection", help="selection")
parser.add_option("-x", dest="cutoff", help="distance cutoff", default=5.0)
parser.add_option("-d", dest="directionality", help="directionality")
parser.add_option("-S", dest="scaffold", help="scaffold")
parser.set_description(main.__doc__)
(options,args) = parser.parse_args()
pdbfiles = []
if options.pdblist:
pdbfiles = files_from_list(options.pdblist)
elif options.pdbfile:
pdbfiles.append(options.pdbfile)
else:
parser.print_help()
sys.exit()
if not options.selection and not options.catalytic:
parser.print_help()
sys.exit()
sele1 = Selection()
if options.selection:
sele1.makeSelection(options.selection)
sele2 = Selection()
sele2.makeSelection("name= CA , CB ")
if options.catalytic:
cres = int(options.catalytic)
cres -= 1
if options.directionality:
direction = float(options.directionality)
scaffold = None
if options.scaffold:
scaffold = Molecule()
scaffold.readPDB(options.scaffold)
cutoff = float(options.cutoff)
protein = Enzyme()
for pdbfile in pdbfiles:
protein.readPDB(pdbfile)
atmlist = []
if options.catalytic:
if cres >= len(protein.catalytic):
print "accessing catalytic residue out of bounds"
sys.exit()
atmlist = protein.catalytic[cres].atom
if options.selection:
mol1 = sele1.apply_selection(protein)
atmlist = mol1.atomList()
if len(atmlist) == 0:
print "selection does not specify any atoms"
sys.exit()
if options.scaffold:
mol2 = sele2.apply_selection(scaffold)
else:
mol2 = sele2.apply_selection(protein)
CBs = mol2.residueList()
taken = {}
if options.catalytic:
com = protein.catalytic[cres].com()
for atm in atmlist:
for myres in CBs:
cb = myres.getAtom(" CB ")
if cb == None:
continue
icb = int(cb.file_id)
if icb in taken.keys():
continue
dist = atm.distance(cb)
if dist < cutoff:
if options.directionality:
if not isResPointingToPoint(myres, com, direction):
continue
taken[icb] = 1
# subtract 1 from taken as it includes self
print pdbfile,len(taken)-1
protein.clear()
def main():
"""
reads a rosetta output pdbfile and reports residues that have a total Eres > cutoff
"""
parser = OptionParser()
parser.add_option("-p", dest="pdbfile", help="pdbfile")
parser.add_option("-P", dest="pdblist", help="pdblist")
parser.add_option("-o", dest="outfile", help="outfile")
parser.add_option("-O", dest="outlist", help="outlist")
parser.add_option("-r",
dest="replace",
help="replace",
action="store_true")
parser.add_option("-s", dest="ids", help="atom ids (comma separated)")
parser.add_option("-t", dest="type", help="atom type", default="CS1 ")
parser.set_description(main.__doc__)
(options, args) = parser.parse_args()
pdbfiles = []
if options.pdblist:
pdbfiles = files_from_list(options.pdblist)
elif options.pdbfile:
pdbfiles.append(options.pdbfile)
else:
parser.print_help()
sys.exit()
outfiles = []
if options.outlist:
outfiles = files_from_list(options.outlist)
elif options.outfile:
outfiles.append(options.outfile)
elif options.replace:
for file in pdbfiles:
outfiles.append(file)
else:
parser.print_help()
sys.exit()
if len(pdbfiles) != len(outfiles):
print "number of pdbfiles and output files differ"
sys.exit()
if not options.ids:
parser.print_help()
sys.exit()
ids = []
cols = options.ids.split(",")
for id in cols:
ids.append(int(id))
mymol = Enzyme()
for i in range(len(pdbfiles)):
pdbfile = pdbfiles[i]
outfile = outfiles[i]
mymol.readPDB(pdbfile)
lig = mymol.ligand
for id in ids:
myatm = mymol.getAtom(id)
if myatm == None:
print "cant find atom:", id
newatm = myatm.clone()
newatm.name = options.type
newatm.coord.x += 0.001
newatm.coord.y -= 0.001
newatm.coord.z += 0.001
lig.addAtom(newatm)
mymol.writePDB(outfile)
mymol.clear()
def main():
"""
creates a new pdbfile from a given selection (almost pymol-like selection format)
"""
parser = OptionParser()
parser.add_option("-p", dest="pdbfile", help="pdbfile")
parser.add_option("-P", dest="pdblist", help="pdblist")
parser.add_option("-o", dest="outfile", help="outfile")
parser.add_option("-O", dest="outlist", help="outlist")
parser.add_option("-s", dest="selection", help="selection")
parser.add_option("-r",
dest="replace",
help="replace",
action="store_true")
parser.add_option("-i",
dest="inverse",
help="inverse",
action="store_true")
parser.add_option("-n",
dest="renumber",
help="don't renumber residues",
action="store_true")
parser.add_option("-c",
dest="count",
help="report atom count only",
action="store_true")
parser.set_description(main.__doc__)
(options, args) = parser.parse_args()
pdbfiles = []
outfiles = []
if not options.selection:
parser.print_help()
sys.exit()
if options.pdblist:
pdbfiles = files_from_list(options.pdblist)
elif options.pdbfile:
pdbfiles.append(options.pdbfile)
else:
parser.print_help()
bFileOutput = True
if options.outlist:
outfiles = files_from_list(options.outlist)
elif options.outfile:
outfiles.append(options.outfile)
elif options.replace:
for file in pdbfiles:
outfiles.append(file)
else:
bFileOutput = False
selection = Selection()
selection.makeSelection(options.selection)
protein = Enzyme()
resRenumber = True
if options.renumber:
resRenumber = False
for i in range(len(pdbfiles)):
protein.readPDB(pdbfiles[i])
newmol = selection.apply_selection(protein)
if options.count:
print newmol.numAtoms()
elif bFileOutput:
newmol.writePDB(outfiles[i], resRenumber)
else:
for atm in newmol.atomList():
print atm
protein.clear()
newmol.clear()
def main():
"""
solvates a histidine
"""
parser = OptionParser()
parser.add_option("-p", dest="pdbfile", help="pdbfile")
parser.add_option("-P", dest="pdblist", help="pdblist")
parser.add_option("-o", dest="outfile", help="outfile")
parser.add_option("-O", dest="outlist", help="outlist")
parser.add_option("-r",
dest="replace",
help="replace",
action="store_true")
parser.add_option("-c", dest="catalytic", help="catalytic")
parser.set_description(main.__doc__)
(options, args) = parser.parse_args()
pdbfiles = []
if options.pdblist:
pdbfiles = files_from_list(options.pdblist)
elif options.pdbfile:
pdbfiles.append(options.pdbfile)
else:
parser.print_help()
sys.exit()
outfiles = []
if options.outlist:
outfiles = files_from_list(options.outlist)
elif options.outfile:
outfiles.append(options.outfile)
elif options.replace:
for file in pdbfiles:
outfiles.append(file)
else:
parser.print_help()
sys.exit()
if len(outfiles) != len(pdbfiles):
print "number of input and output files differ"
sys.exit()
if not options.catalytic:
parser.print_help()
sys.exit()
icat = int(options.catalytic) - 1
protein = Enzyme()
for i in range(len(pdbfiles)):
protein.readPDB(pdbfiles[i])
if icat < 0 or icat >= len(protein.catalytic):
print "accessing catalytic residue out of bounds"
sys.exit()
cat = protein.catalytic[icat]
if cat.name != "HIS":
print "catalytic residue is not a histidine"
sys.exit()
# check protonation state
if cat.getAtom(" HD1") != None:
A = cat.getAtom(" NE2")
B = cat.getAtom(" CD2")
C = cat.getAtom(" CG ")
elif cat.getAtom(" HE2") != None:
A = cat.getAtom(" ND1")
B = cat.getAtom(" CE1")
C = cat.getAtom(" NE2")
else:
print "unable to determine protonation state"
sys.exit()
if A == None or B == None or C == None:
print "cannot find all 3 atoms"
sys.exit()
length = 2.98
ang = 125.0
tor = 180.0
billder = Builder()
crd = billder.dbuildAtom(A, B, C, length, ang, tor)
newres = protein.chain[1].newResidue()
newres.name = "LG2"
newatm = newres.newAtom()
newatm.coord.x = crd[0]
newatm.coord.y = crd[1]
newatm.coord.z = crd[2]
newatm.name = "HOH "
newatm.kind = "HETATM"
protein.writePDB(outfiles[i])
protein.clear()