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(): """ creates a poly-glycine variant of a pdbfile by removing all sidechains """ parser = OptionParser() parser.add_option("-p", dest="pdbfile", help="pdbfile") parser.add_option("-o", dest="outfile", help="outfile") parser.add_option("-r", dest="replace", help="replace", action="store_true") parser.set_description(main.__doc__) (options, args) = parser.parse_args() if not options.pdbfile or not options.outfile: parser.print_help() sys.exit() selection = Selection() selection.makeSelection("BB") protein = Molecule() protein.readPDB(options.pdbfile) newmol = selection.apply_selection(protein) for chain in newmol.chain: for res in chain.residue: res.name = "GLY" newmol.writePDB(options.outfile)
def main(): """ reports the maximal distance between two sets of atoms """ 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.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 = Molecule() probe = Molecule() target.readPDB(options.target) mysel = None tlist = [] if options.selection: mysel = Selection() mysel.makeSelection(options.selection) target = mysel.apply_selection(target) tlist = target.atomList() nlist = len(tlist) plist = [] for probefile in probes: maxdist = 0.0 probe.readPDB(probefile) if options.selection: probe = mysel.apply_selection(probe) plist = probe.atomList() if len(plist) != nlist: print "differing number of atoms" sys.exit() for i in range(nlist): dist = tlist[i].distance(plist[i]) if dist > maxdist: maxdist = dist print probefile, maxdist probe.clear()
def main(): """ reads in a pdbfile and writes out the protein sequence """ parser = OptionParser() parser.add_option("-p", dest="pdbfile", help="pdbfile") parser.add_option("-P", dest="pdblist", help="pdblist") parser.add_option("-t", dest="transpose", help="transpose", action="store_true") parser.add_option("-n", dest="number", help="number", action="store_true") parser.add_option("-r", dest="range", help="range") 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() if options.selection: sele = Selection() sele.makeSelection(options.selection) seq_min = 1 seq_max = 1 if options.range: (min, max) = string.split(arg, "-") seq_min = int(min) seq_max = int(max) protein = Molecule() Seq = "" for pdb in pdbfiles: protein.readPDB(pdb) if options.selection: newmol = sele.apply_selection(protein) Seq = newmol.sequence() else: Seq = protein.sequence() if options.range: Seq = Seq[seq_min:seq_max] if options.transpose: for i in range(len(Seq)): print Seq[i] else: print Seq protein.clear()
def GenerateOffspring(parents): offspring = [] while (len(offspring) != len(parents)): parentA, parentB = Selection.Selection(parents) childA, childB = Crossover.Crossover(parentA, parentB) childA = Mutation.Mutation(childA) childB = Mutation.Mutation(childB) offspring.append(childA) offspring.append(childB) return offspring
def main(): """ list the hydrogen bonds in a protein that have a score less than a given threshold """ 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("-S", dest="summary", help="summary", action="store_true") 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() sele = Selection() if options.selection: sele.makeSelection(options.selection) protein = Enzyme() HBN = HBnetwork() for pdbfile in pdbfiles: protein.readPDB(pdbfile) newprot = protein if options.selection: newprot = sele.apply_selection(protein) HBN.createNetwork(newprot) HBN.findHbonds(cutoff=float(options.cutoff)) found = False if options.summary: print pdbfile, len(HBN.hbonds) found = True else: for hb in HBN.hbonds: print pdbfile, hb found = True if not found: print pdbfile, "NONE" protein.clear() HBN.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(): """ given a match output file creates an output file of the catalytic site only """ parser = OptionParser() parser.add_option("-p", dest="pdbfile", help="pdbfile") parser.add_option("-o", dest="outfile", help="outfile") parser.set_description(main.__doc__) (options, args) = parser.parse_args() if not options.outfile or not options.pdbfile: parser.print_help() sys.exit() # read remark remark = re.compile("REMARK") try: pdb = open(options.pdbfile) except: print "unable to open pdbfile" sys.exit() resline = "resi=" read = False for line in pdb.readlines(): if remark.match(line): cols = line.split() resi = cols[5] if read: resline += "," resline += resi read = True pdb.close() selection = Selection() selection.makeSelection(resline) # --- extract out the residue selections --- # protein = Molecule() protein.readPDB(options.pdbfile) newmol = selection.apply_selection(protein) selection.clear() # --- extract out the hetero atoms --- # selection.makeSelection("type=HETATM") hetatm = selection.apply_selection(protein) reslist = hetatm.residueList() newchain = newmol.newChain() newchain.addResidueList(reslist) newmol.writePDB("dumb.pdb")
def main(): """ trims a grid for a given selection and cutoff values """ parser = OptionParser() parser.add_option("-p", dest="pdbfile", help="pdbfile") parser.add_option("-s", dest="sele", help="sele") parser.add_option("-g", dest="grid", help="grid") parser.add_option("-o", dest="outfile", help="outfile") parser.add_option("-r", dest="replace", help="replace", action="store_true") parser.add_option("-e", dest="exclude", help="exclude", action="store_true") parser.add_option("-c", dest="cutoff", help="cutoff", default=3.0) (options, args) = parser.parse_args() if not options.pdbfile or not options.grid: parser.print_help() sys.exit() if options.outfile: outgrid = options.outfile elif options.replace: outgrid = options.grid else: parser.print_help() sys.exit() protein = Molecule() protein.readPDB(options.pdbfile) if options.sele: selection = Selection() selection.makeSelection(options.sele) newmol = selection.apply_selection(protein) else: newmol = protein.clone() mygrid = grid() mygrid.read(options.grid) atomlist = newmol.atomList() if options.exclude: gridTrimExclude(mygrid, atomlist, float(options.cutoff)) else: gridTrimInclude(mygrid, atomlist, float(options.cutoff)) mygrid.write(outgrid)
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 __init__(self, params): self.epochs = params['epochs'] self.Crossover = Crossover(params['crossover_type'], params['crossover_prob']) self.Population = Population(booth_function, params['population_size'], 2, -10, 10, params['population_precision']) self.Mutation = Mutation(params['mutation_type'], params['mutation_prob']) self.Inversion = Inversion(params['inversion_type'], params['inversion_prob']) self.Selection = Selection(params['selection_type'], params['selection_prob']) self.EliteStrategy = EliteStrategy(params['elite_prob'])
def main(): """ builds new atoms onto existing pdbfiles. EXPERIMENTAL AND UNTESTED """ parser = OptionParser() parser.add_option("-p", dest="pdbfile", help="pdbfile") parser.add_option("-o", dest="outfile", help="outfile") parser.add_option("--dist", dest="distance", help="distance") parser.add_option("--ang", dest="angle", help="angle") parser.add_option("--tor", dest="torsion", help="torsion") parser.add_option("-s", "--selection", dest="selection", help="selection") parser.add_option("-b", "--build", dest="build", help="build") parser.set_description(main.__doc__) (options, args) = parser.parse_args() if not options.pdbfile or not options.selection: parser.print_help() sys.exit() if not options.outfile: parser.print_help() sys.exit() mol = Molecule() mol.readPDB(options.pdbfile) selector = Selection() selector.makeSelection(options.selection) mysel = selector.apply_selection(mol) builder = Builder() atomlist = mysel.atomList() if len(atomlist) != 3: print "must select three atoms. ", len(atomlist) newatom = Atom() newatom.name = "new" dist = float(options.distance) ang = float(options.angle) tor = float(options.torsion) builder.buildAtom(newatom, atomlist[0], atomlist[1], atomlist[2], dist, ang, tor) mol.chain[0].residue[0].addAtom(newatom) mol.writePDB(options.outfile)
def main(): """ prints a list of unsatisfied hydrogen bonds in a protein """ 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.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 = Molecule() HBN = HBnetwork() sele = None if options.selection: sele = Selection() sele.makeSelection(options.selection) for pdbfile in pdbfiles: protein.readPDB(pdbfile) HBN.createNetwork(protein) HBN.findHbonds() unsat = HBN.unsatisfiedHbonds() if options.selection: atmlist = sele.apply_selection(protein, return_mol=False) for atm in unsat: if atm in atmlist: print atm else: for atm in unsat: print atm protein.clear() HBN.clear()
def generatePlayer(cls): """ Desc: Class method, creates a character and fills in parameters with user input when called Input: None Output: Character() instance """ mySelection = Selection() raceObj = mySelection.race_select() classObj = mySelection.class_select() print("What is your name?\n") return cls( input(">> "), # name raceObj, # race choice classObj, # class choice classObj.statsList, # stats raceObj.movesList # moves )
def main(): """ switches tautomers of histidine in a selection of residues """ parser = OptionParser() parser.add_option("-p", dest="pdbfile", help="pdbfile") parser.add_option("-o", dest="outfile", help="outfile") parser.add_option("-r", dest="replace", help="replace", action="store_true") parser.add_option("-s", dest="selection", help="selection") parser.set_description(main.__doc__) (options, args) = parser.parse_args() if not options.pdbfile: parser.print_help() sys.exit() if options.outfile: outfile = options.outfile elif options.replace: outfile = options.pdbfile else: parser.print_help() sys.exit() sele = Selection() if options.selection: sele.makeSelection(options.selection) else: sele.makeSelection("resn=HIS") protein = Molecule() protein.readPDB(options.pdbfile) his_prot = sele.apply_selection(protein) his_list = his_prot.residueList() for his in his_list: switchHisTautomer(his) protein.writePDB(outfile, resRenumber=False, atomRenumber=False)
def main(): """ finds the residue-based 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("-s", dest="selection", help="selection") parser.add_option("-c", dest="cutoff", help="cutoff") parser.set_description(main.__doc__) (options, args) = parser.parse_args() if not options.target or not options.probe: parser.print_help() sys.exit() target = Molecule() probe = Molecule() target.readPDB(options.target) probe.readPDB(options.probe) if options.selection: mysel = Selection() mysel.makeSelection(options.selection) target = mysel.apply_selection(target) probe = mysel.apply_selection(probe) rms = res_fit(target, probe) for line in rms: if options.cutoff: if float(line[1]) > float(options.cutoff): print line[0], line[1] else: print line[0], line[1]
def main(): """ program that prints out selections from a pdbfile """ parser = OptionParser() parser.add_option("-p", dest="pdbfile", help="pdbfile") parser.add_option("-s", dest="selection", help="selection") (options, args) = parser.parse_args() if not options.pdbfile or not options.selection: parser.print_help() sys.exit() protein = Molecule() protein.readPDB(options.pdbfile) sele = Selection() sele.makeSelection(options.selection) smol = sele.apply_selection(protein) reslist = smol.residueList() for res in reslist: print res
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(): """ 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 run(playlist_files): # Init pygame pygame.mixer.pre_init(44100, -16, 2, 2048) # setup mixer to avoid sound lag print "Init pygame, version = ", pygame.version.ver pygame.init() if not pygame.display.get_init(): print "Error during pygame init." print "Quit." sys.exit(1) # Init Screen fullscreen = False if fullscreen: size = width, height = 1366,768 else: size = width, height = 1366/2,760 screen = pygame.display.set_mode(size, (pygame.FULLSCREEN | pygame.HWSURFACE if fullscreen else pygame.RESIZABLE)) pygame.display.set_caption("Ardent'Scene studio") #pygame.mouse.set_visible(False) # Init modules DrawText.init() # Init entities ball = pygame.image.load(ressources_dir + "ball.gif") ballrect = ball.get_rect() speed = [20, 18] # *** cmanager = CManager.CManager() # --- tmanagers = Loader.load_playlists(playlist_files) tman_i = 0 cur_tmanager = tmanagers[0] # --- keys = [pygame.K_a, pygame.K_z, pygame.K_e, pygame.K_r, pygame.K_t, pygame.K_y, pygame.K_u, pygame.K_i, pygame.K_o, pygame.K_p ] selection = Selection.Selection(keys, pygame.K_ASTERISK) # --- commands = [ Commands.Play(cmanager, pygame.K_v), Commands.Stop(cmanager, pygame.K_n), Commands.Fadein(cmanager, pygame.K_g), Commands.Fadeout(cmanager, pygame.K_j), Commands.UpTracks(cmanager, pygame.K_DOWN), Commands.DownTracks(cmanager, pygame.K_UP) ] # to know when exiting the soft quitting = 0 while 1: for event in pygame.event.get(): if event.type == pygame.QUIT: quit() # --- elif event.type == pygame.KEYDOWN: quitting = quitting-1 if event.key == pygame.K_ESCAPE: quit() elif event.key == pygame.K_BACKSPACE: if quitting < 0: quitting = 0 quitting = quitting + 2 if quitting >= 5: quit() elif event.key == pygame.K_SPACE: pass # select a track elif selection.is_selection(event.key): selection.treat_key(event.key, cur_tmanager) # change current tmanager elif event.key == pygame.K_LEFT: if tman_i > 0: print 'Previous playlist' tman_i -= 1 cur_tmanager = tmanagers[tman_i] elif event.key == pygame.K_RIGHT: if tman_i < len(tmanagers)-1: print 'Next playlist' tman_i += 1 cur_tmanager = tmanagers[tman_i] # execute a command else: for cmd in commands: if cmd.is_this_command(event.key): cmd.execute(cur_tmanager) # --- elif event.type == pygame.locals.USEREVENT: print 'Event : Sound has finished' # Channel event cmanager.has_finished() ballrect = ballrect.move(speed) if ballrect.left < 0 or ballrect.right > width: speed[0] = -speed[0] if ballrect.top < 0 or ballrect.bottom > height: speed[1] = -speed[1] screen.fill(Color.black) screen.blit(ball, ballrect) cur_tmanager.draw(screen) draw_playlist_index(screen, tman_i) pygame.display.flip() pygame.time.delay(50)
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(): """ 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(): parser = OptionParser() parser.add_option("-t", dest="target", help="target") parser.add_option("-P", dest="probe", help="probe") parser.add_option("-s", dest="sele", help="sele") (options, args) = parser.parse_args() if not options.target or not options.probe: parser.print_help() sys.exit() try: PROBE = open(options.probe, 'r') except: print "unable to open probe list" sys.exit() prbMol = Molecule() trgMol = Molecule() [trg_start, trg_end] = options.sele.split("-") sel = Selection() sel_str = "resi=" + trg_start + ";name= N , CA , C , O " sel.makeSelection(sel_str) trgMol.readPDB(options.target) target = sel.apply_selection(trgMol) [base, rest] = options.target.split(".") newMol = 0 for line in PROBE.readlines(): line = string.rstrip(line) [file, start, end] = line.split() [id, rest] = file.split("_",1) [tmp, num] = rest.split("SLH_") outfile = base + "_" + id + "_" + num size = int(end) - int(start) + 1 start = int(start)-1 prb_start = start+1 prb_end = int(end)+1 print file prbMol.readPDB(file) sel_str = "resi=" + str(start) + ";name= N , CA , C , O " sel.clear() sel.makeSelection(sel_str) probe = sel.apply_selection(prbMol) superimpose_molecule(target, probe, prbMol) iprb1 = prbMol.chain[0].getResidueIndex(prb_start) iprb2 = prbMol.chain[0].getResidueIndex(prb_end) if iprb1 == None or iprb2 == None: print "cannot get index of ",prb_start iprb1 = int(iprb1) iprb2 = int(iprb2) prbslice = prbMol.chain[0].residue[iprb1:iprb2] newMol = trgMol.clone() beg = int(trg_start) end = int(trg_end) newMol.chain[0].slice(beg+1,end-1) newMol.chain[0].insertResidues(prbslice, beg) newMol.addRemark("REMARK LOOP INSERTION " + str(beg+1) + " " + str(beg+size)) newMol.writePDB(outfile) probe.clear() prbMol.clear() newMol.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(): """ 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 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(): """ 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(): parser = OptionParser() parser.add_option("-p", dest="pdbfile", help="pdbfile") parser.add_option("-t", dest="TIMfile", help="TIMfile") (options, args) = parser.parse_args() if not options.pdbfile or not options.TIMfile: parser.print_help() sys.exit() # === read the TIMfile === # try: TIMFILE = open(options.TIMfile, 'r') except: print "unable to open TIMfile" (basename, other) = options.pdbfile.split(".", 2) print "basename = ", basename Sel = Selection() protein = Molecule() protein.readPDB(options.pdbfile) cols = [] stripped = 0 nHLS = 0 nSLH = 0 for line in TIMFILE.readlines(): line = string.strip(line) cols = line.split() if len(cols) == 0: if stripped: stripped.writePDB(outname) continue if cols[0] == "SLH": nSLH += 1 startX = cols[2] endX = cols[3] Sel.clear() Sel.makeSelection("resi=" + str(startX) + "-" + str(endX)) stripped = Sel.apply_selection(protein) outname = basename + "_SLH_" + str(nSLH) + ".pdb" if cols[0] == "HLS": nHLS += 1 startX = cols[2] endX = cols[3] Sel.clear() Sel.makeSelection("resi=" + str(startX) + "-" + str(endX)) stripped = Sel.apply_selection(protein) outname = basename + "_HLS_" + str(nHLS) + ".pdb" if cols[0] == "HELIX": startH = cols[2] endH = cols[3] myStart = int(startH) - int(startE) + 1 myEnd = int(endH) - int(startE) + 1 mySize = myEnd - myStart + 1 stripped.addRemark("REMARK HELIX " + str(mySize) + " " + str(myStart) + " " + str(myEnd)) if cols[0] == "LOOP": startL = cols[2] endL = cols[3] myStart = int(startL) - int(startE) + 1 myEnd = int(endL) - int(startE) + 1 mySize = myEnd - myStart + 1 #stripped.addRemark("REM LOOP " + startL + " " + endL) stripped.addRemark("REMARK LOOP " + str(mySize) + " " + str(myStart) + " " + str(myEnd)) if cols[0] == "SHEET": startE = cols[2] endE = cols[3] myEnd = int(endE) - int(startE) + 1 mySize = myEnd #stripped.addRemark("REM SHEET " + startE + " " + endE) stripped.addRemark("REMARK SHEET " + str(mySize) + " 1 " + str(myEnd)) TIMFILE.close()
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(): """ 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()