def main(): usage = """ Usage... """ parser = EMAN2.EMArgumentParser(usage=usage,version=EMAN2.EMANVERSION) parser.add_argument("--output", type=str,help="Output pdb file") parser.add_argument("--mrcin", type=str,help="mrc file for input",default=None) parser.add_argument("--pdbin", type=str,help="pdb file for input",default=None) parser.add_argument("--lenthr", type=int,help="length threshold of helixes",default=13) parser.add_argument("--denthr", type=float,help="density threshold of helixes",default=4) parser.add_argument("--mapwohelix", type=str,help="Write a map without helix density",default=None) parser.add_argument("--dirs", type=int,help="Counting from one direction?",default=0) parser.add_argument("--edgefile", type=str,help="Existing helixes file",default=None) (options, args) = parser.parse_args() eg=[] if options.edgefile<>None: edge=read_fixed(options.edgefile) eg.append(edge[0][0]) for i in range(1,len(edge)): if edge[i][0]<>edge[i-1][1]: eg.append(edge[i-1][1]) eg.append(edge[i][0]) eg.append(edge[len(edge)-1][1]) atomnumber=read_pdb(options.pdbin) print eg for i in range(len(eg)): for j in range(len(atomnumber)): if atomnumber[j]==eg[i]: eg[i]=j break print eg #exit() mrc=EMData(options.mrcin) atoms=PointArray() atoms.read_from_pdb(options.pdbin) #atoms.reverse_chain() #mrc.process_inplace("filter.lowpass.gauss",{"cutoff_abs":0.5}) hlx=atoms.fit_helix(mrc,options.lenthr,options.denthr,eg,options.dirs) for i in range(len(hlx)/8): print hlx[i*8],hlx[i*8+1] atoms.save_pdb_with_helix(options.output,hlx) #atoms.save_to_pdb(options.output) if options.mapwohelix<>None: atoms.remove_helix_from_map(mrc,hlx) mrc.write_image(options.mapwohelix)
def main(): usage = """ Usage... """ parser = EMAN2.EMArgumentParser(usage=usage, version=EMAN2.EMANVERSION) parser.add_argument("--output", type=str, help="Output pdb file") parser.add_argument("--mapin", type=str, help="mapin file for input", default=None) parser.add_argument("--pdbin", type=str, help="pdb file for input", default=None) parser.add_argument("--edgefile", type=str, help="Fixed edges", default=None) parser.add_argument("--thr", type=float, help="Threshold for removing Ca atoms", default=-1) parser.add_argument("--dochange", type=int, help="Just mark the sidechain atoms or remove them", default=0) parser.add_argument("--mode", type=str, help="Mode: e/s/d/c") (options, args) = parser.parse_args() eval_atom = 0 shaking = 0 decision = 0 crossbond = 0 if options.mode.startswith("e"): eval_atom = 1 elif options.mode.startswith("s"): shaking = 1 elif options.mode.startswith("d"): decision = 1 elif options.mode.startswith("c"): crossbond = 1 points, count, atomnumber = read_pdb(options.pdbin) if options.edgefile <> None: hlxid = read_helix(options.edgefile) else: hlxid = set() bondl = 0 #3.78 naa = count dochange = 1 mrc = EMData(options.mapin) SX = mrc.get_xsize() SY = mrc.get_ysize() SZ = mrc.get_zsize() apix_x = mrc["apix_x"] apix_y = mrc["apix_y"] apix_z = mrc["apix_z"] mrcdata = np.empty((SX, SY, SZ), float) for i in range(SX): for j in range(SY): for k in range(SZ): mrcdata[i, j, k] = mrc.get_value_at(i, j, k) ncent = np.empty((naa, 3), float) for i in range(naa): ncent[i, :] = points[i] / np.array([apix_x, apix_y, apix_z ]) #+np.array([SX/2,SY/2,SZ/2]) thresh = .3 neark = 5 noiset = 1000 gaussig = 1 atomcolor = np.zeros(naa, float) #neighbors=find_neighbors(ncent) if crossbond == 1: csbd = np.empty(naa, int) for i in range(1, naa - 1): pos1 = (ncent[i] + ncent[i + 1]) / 2 mind = 10 for j in range(i + 2, naa - 1): pos2 = (ncent[j] + ncent[j + 1]) / 2 dp = distance(pos1, pos2) dl = distance_lines(ncent[i], ncent[i + 1], ncent[j], ncent[j + 1]) if (dp < 3): dd = dl else: dd = dp if (dd < mind): mind = dd csbd[i] = j atomcolor[i] = mind if (options.thr < 0): options.thr = np.mean(atomcolor) + 2 * np.std(atomcolor) print options.thr if (atomcolor[i] < options.thr): print i, csbd[i], atomcolor[i] atomcolor[i] = options.thr atomcolor[i + 1] = options.thr atomcolor[csbd[i]] = options.thr atomcolor[csbd[i] + 1] = options.thr for j in range(i + 1, (1 + csbd[i] + i + 1) / 2): k = csbd[i] + i + 1 - j tmp = np.copy(ncent[j]) ncent[j] = ncent[k] ncent[k] = tmp #print j,ncent[j],k,ncent[k] if decision == 1: # delete side chains ( sharp angle, two neighbors are close to each other) dellist = [] orina = naa for i in range(1, naa - 1): ang = calc_score(ncent, i, mrcdata, 0, 0, 1) wid = calc_score(ncent, i, mrcdata, 0, 0, 0, 1) inhlx = (atomnumber[i + 1] in hlxid) and (atomnumber[i - 1] in hlxid) and (atomnumber[i - 1] in hlxid) if ang > cos(options.thr) and wid < 4 and inhlx == False: atomcolor[i] = 10 dellist.append(i) print np.hstack((atomnumber[dellist], atomcolor[dellist])) ncent = np.delete(ncent, dellist, axis=0) atomnumber = np.delete(atomnumber, dellist) atomcolor = np.delete(atomcolor, dellist) naa = len(ncent) # long bonds acent = np.copy(ncent) k = 1 nn = max(atomnumber) distb = np.empty(naa, float) for i in range(1, naa - 2): posi = ncent[i] #print i+1 posf = ncent[i + 1] distb[i] = abs(distance(posi, posf)) srtdst = np.sort(distb) thr = srtdst[naa * 2 - orina - 1] for i in range(1, naa - 2): posi = ncent[i] posf = ncent[i + 1] if (distb[i] > thr and posi[0] > 0 and posf[0] > 0): pos = (posi + posf) / 2 print i, k, distb[i], get_density(mrc, pos, posi, posf) acent = np.insert(acent, i + k, pos, axis=0) atomnumber = np.insert(atomnumber, i + k, nn + 1) atomcolor = np.insert(atomcolor, i + k, 100) nn += 1 k += 1 ncent = np.copy(acent) print len(ncent) #for i in range(1,naa-1): #posi=ncent[i] #posb=ncent[i-1] #posf=ncent[i+1] #dista=abs(distance(posb,posi)) #distb=abs(distance(posi,posf)) #atomcolor[i]=max(dista,distb) if shaking == 1: mrc = EMData(options.mrcin) atoms = PointArray() atoms.read_from_pdb(options.pdbin) atoms.sim_set_pot_parms(3.78, 10, 5, 0, 0.0, 10, mrc, 2, 0) for iters in range(500): print iters atoms.sim_printstat() atoms.sim_minstep_seq(.01) #if iters%100==0: #atoms.save_to_pdb("a"+str(iters)+".pdb") atoms.save_to_pdb(options.output) exit() if eval_atom == 1: #if options.dochange: #dellist=[] #for i in range(1,naa-1): #ang=calc_score(ncent,i,mrcdata,0,0,1) #wid=calc_score(ncent,i,mrcdata,0,0,0,1) #inhlx=(atomnumber[i+1] in hlxid) and (atomnumber[i-1] in hlxid) and (atomnumber[i-1] in hlxid) #if ang>cos(.6) and wid<4 and inhlx==False: #atomcolor[i]=10 #dellist.append(i) #print np.hstack((atomnumber[dellist],atomcolor[dellist])) #ncent=np.delete(ncent,dellist,axis=0) #atomnumber=np.delete(atomnumber,dellist) #atomcolor=np.delete(atomcolor,dellist) #naa= len(ncent) thresh = options.thr while 1: maxscore = 0 for i in range(1, naa - 1): score = calc_score(ncent, i, mrcdata, 3, 2, 1, -3) if (atomnumber[i] in hlxid): score = 0 atomcolor[i] = score if score > maxscore: maxscore = score dellist = i if thresh == -1: thresh = np.mean(atomcolor) + np.std(atomcolor) * 2 if (options.dochange == 0): break maxscore = max(atomcolor) if maxscore < thresh: break print np.hstack((atomnumber[dellist], atomcolor[dellist])) ncent = np.delete(ncent, dellist, axis=0) atomnumber = np.delete(atomnumber, dellist) atomcolor = np.delete(atomcolor, dellist) #print atomnumber[dochange],maxscore #ncent=np.delete(ncent,dochange,axis=0) naa -= 1 #atomcolor-=min(atomcolor) #atomcolor=atomcolor/max(atomcolor)*99.9 print np.mean(atomcolor) + np.std(atomcolor) * 2 write_pdb(options.output, ncent, 0, 0, 0, atomcolor, atomnumber, [apix_x, apix_y, apix_z])
def main(): usage = """ e2pwhelixfit.py --pdbin <input pdb file> --mapin <input map file> --output <output file> [options] Fit alpha helices on a backbone model generated by e2pathwalker.py """ parser = EMAN2.EMArgumentParser(usage=usage, version=EMAN2.EMANVERSION) parser.add_argument("--output", type=str, help="Output pdb file") parser.add_argument("--mapin", type=str, help="mrc file for input", default=None) parser.add_argument("--pdbin", type=str, help="pdb file for input", default=None) parser.add_argument("--lenthr", type=int, help="length threshold of helixes", default=13) parser.add_argument("--minlen", type=int, help="minimun length helixes", default=10) parser.add_argument("--denthr", type=float, help="density threshold of helixes", default=4) parser.add_argument("--angthr", type=float, help="bond angle threshold of helixes", default=.01) parser.add_argument("--mapwohelix", type=str, help="Write a map without helix density", default=None) parser.add_argument("--dirs", type=int, help="Counting from one direction?", default=0) parser.add_argument("--edgefile", type=str, help="Existing helixes file", default=None) parser.add_argument( "--ppid", type=int, help="Set the PID of the parent process, used for cross platform PPID", default=-1) (options, args) = parser.parse_args() logid = E2init(sys.argv) eg = [] if options.edgefile != None: edge = read_fixed(options.edgefile) eg.append(edge[0][0]) for i in range(1, len(edge)): if edge[i][0] != edge[i - 1][1]: eg.append(edge[i - 1][1]) eg.append(edge[i][0]) eg.append(edge[len(edge) - 1][1]) atomnumber = read_pdb(options.pdbin) print(eg) for i in range(len(eg)): for j in range(len(atomnumber)): if atomnumber[j] == eg[i]: eg[i] = j break print(eg) #exit() mrc = EMData(options.mapin) atoms = PointArray() atoms.read_from_pdb(options.pdbin) #atoms.reverse_chain() #mrc.process_inplace("filter.lowpass.gauss",{"cutoff_abs":0.5}) allhlx = np.array([0, 0, 0, 0, 0, 0]) allhlx = np.vstack((allhlx, allhlx)) for ii in range(1): newhlx = 0 hlx = atoms.fit_helix(mrc, options.lenthr, options.denthr, eg, options.dirs, options.minlen) for i in range(len(hlx) / 8): h = [ hlx[i * 8 + 2], hlx[i * 8 + 3], hlx[i * 8 + 4], hlx[i * 8 + 5], hlx[i * 8 + 6], hlx[i * 8 + 7] ] mindist = min(np.sum((allhlx - h) * (allhlx - h), axis=1)) print(h, mindist) if mindist > 100: allhlx = np.vstack((allhlx, h)) newhlx = 1 if newhlx == 0: break allhlx = np.delete(allhlx, [0, 1], axis=0) print(allhlx) hlx = [] n = atoms.get_number_points() inhlx = -1 for i in range(1, n - 1): p1 = atoms.get_vector_at(i - 1) p2 = atoms.get_vector_at(i) p3 = atoms.get_vector_at(i + 1) l1 = p2 - p1 l2 = p2 - p3 #print l1.length(),l2.length(),i, a = (l1.dot(l2)) / (l1.length() * l2.length()) a = min(a, 1) a = max(a, -1) #print a, ang = acos(a) #print i,ang if inhlx < 0: if abs(ang - 1.585) < options.angthr: inhlx = i inp = p2 else: if abs(ang - 1.585) > options.angthr: if i - inhlx > options.minlen: hlx.extend([ inhlx, i, inp[0], inp[1], inp[2], p2[0], p2[1], p2[2] ]) inhlx = -1 #for h in allhlx: #print h #p1=Vec3f(h[0],h[1],h[2]) #p2=Vec3f(h[3],h[4],h[5]) #n1=0 #n2=0 #minl1=10000 #minl2=10000 #for i in range(atoms.get_number_points()): #p=atoms.get_vector_at(i) #dp=p-p1 #l=dp.length() #if l<minl1: #minl1=l #n1=i #for i in range(max(0,n1-100),min(n1+100,atoms.get_number_points())): #p=atoms.get_vector_at(i) #dp=p-p2 #l=dp.length() #if l<minl2: #minl2=l #n2=i #print n1,n2 #if n2>n1: #hlx.extend([n1+1,n2-1,h[0],h[1],h[2],h[3],h[4],h[5]]) #else: #hlx.extend([n2+1,n1-1,h[3],h[4],h[5],h[0],h[1],h[2]]) #print hlx #for i in range(len(hlx)/8): #print hlx[i*8],hlx[i*8+1] atoms.save_pdb_with_helix(options.output, hlx) #atoms.save_to_pdb(options.output) #hlx=[] #for h in allhlx: #hlx.extend([0,0,h[0],h[1],h[2],h[3],h[4],h[5]]) print(hlx) if options.mapwohelix != None: atoms.remove_helix_from_map(mrc, hlx) mrc.write_image(options.mapwohelix) E2end(logid)
def main(): usage = """e2pathwalker.py [options] <pdb file> Find paths between two atoms in a PDB model. You can also specify two PDB files to calculate an RMSD. Use "--solve=<solver>" to run the TSP solver and save the output. Use "--output" to save the output to a PDB file. Use "--mapfile" to input the density map. Pathwalker wiki: http://blake.bcm.edu/emanwiki/Pathwalker """ parser = EMAN2.EMArgumentParser(usage=usage,version=EMAN2.EMANVERSION) parser.add_argument("--output", type=str,help="Output file") parser.add_argument("--mapfile", type=str,help="Density map file", default=None) parser.add_argument("--start", type=int,help="Start ATOM") parser.add_argument("--end", type=int,help="End ATOM") parser.add_argument("--average", type=float,help="Average Ca-Ca length", default=3.78) parser.add_argument("--mapweight", type=float,help="Weight of density, to balance between geometry and density score", default=1000) parser.add_argument("--mapthresh", type=float,help="Density threshold, bonds on density lower than threshold is not prefered", default=0) parser.add_argument("--dmin", type=float,help="Mininum Ca-Ca length", default=2.0) parser.add_argument("--dmax", type=float,help="Maximum Ca-Ca length", default=10.0) parser.add_argument("--noise", type=float,help="Add Gaussian Noise", default=0.0) parser.add_argument("--solver", type=str ,help="Run TSP Solver: concorde or lkh") parser.add_argument("--atomtype", type=str ,help="Load Atom Type. Default: 'CA'. Options: 'C' or 'all'", default="CA") parser.add_argument("--chain", type=str ,help="Load Chain. Default: load all chains") parser.add_argument("--edgefile", type=str ,help="Load fixed fragment file; one sequence of forced connections per line, separated by space.") parser.add_argument("-e", "--edge", action="append", help="Forced edge: e.g. -e1,3") parser.add_argument("--fixed", type=str, help="Same as --edgefile.") parser.add_argument("--iterations", type=int,help="Iterations", default=1) parser.add_argument("--json", type=int, help="If writing output pdb, also write JSON metadata. Default: 1. Options: 0, 1", default=1) parser.add_argument("--overwrite", action="store_true", help="Overwrite files without prompting") parser.add_argument("--verbose", "-v", dest="verbose", action="store", metavar="n",type=int, default=0, help='verbose level [0-9], higher number means higher level of verboseness') parser.add_argument("--ppid", type=int, help="Set the PID of the parent process, used for cross platform PPID",default=-1) parser.add_argument("--subunit", type=int, help="Number of subunits.",default=1) (options, args) = parser.parse_args() if len(args) == 1: filename = args[0] # for j in range(options.iterations): # if options.iterations > 1: # print "Iteration:", j if options.iterations > 1: print("Warning: Iterations currently unsupported.") pw = PathWalker( filename=filename, start=options.start, end=options.end, edgefile=options.edgefile or options.fixed, dmin=options.dmin, dmax=options.dmax, average=options.average, noise=options.noise, atomtype=options.atomtype, chain=options.chain, json=options.json, solver=options.solver, overwrite=options.overwrite, outfile=options.output, mrcfile=options.mapfile, mrcweight=options.mapweight, mapthresh=options.mapthresh, subunit=options.subunit ) pw.run() elif len(args) == 2: ca = CaRMSD(args[0], args[1], outfile=options.output, atomtype=options.atomtype, overwrite=options.overwrite) ca.run() else: #print "Not enough arguments!" pass
counter = 0 # Loop through classes with open(classmap) as r: for idx, line in enumerate(r.readlines()): with open(classdoc.format(idx), 'w') as w: w.write('\n'.join(line[1:-3].split(', '))) counter += 1 print_log_msg("Wrote %s class selection files\n" % counter, log, verbose) if __name__ == "__main__": # Command-line arguments parser = EMAN2.EMArgumentParser(usage=USAGE, version=EMAN2_meta.EMANVERSION) parser.add_argument('classavgs', help='Input class averages') parser.add_argument('instack', help='Input image stack') parser.add_argument('outdir', type=str, help='Output directory') parser.add_argument( '--filtrad', type=float, help= 'For optional filtered images, low-pass filter radius (1/px or, if pixel size specified, Angstroms)' ) parser.add_argument( '--pxsz', type=float, default=None, help='Pixel size, Angstroms (might be downsampled by ISAC)') parser.add_argument('--shrink',
def main(): usage = """ e2pwsheetfit.py --pdbin <input file> --output <output file> [options] Fit beta sheets on a backbone model generated by e2pathwalker.py """ parser = EMAN2.EMArgumentParser(usage=usage, version=EMAN2.EMANVERSION) parser.add_argument("--output", type=str, help="Output pdb file") parser.add_argument("--pdbin", type=str, help="pdb file for input", default=None) parser.add_argument("--nsht", type=int, help="max number of beta sheet strains", default=5) parser.add_argument("--minlen", type=int, help="minimum length of a beta sheet strain", default=5) parser.add_argument( "--cutoff", type=float, help= "cutoff threshold for sheet score. program will stop when the next highest score is lower than cutoff*std+mean", default=1) parser.add_argument( "--ppid", type=int, help="Set the PID of the parent process, used for cross platform PPID", default=-1) (options, args) = parser.parse_args() logid = E2init(sys.argv) pts, na, atomnumber, header = read_pdb(options.pdbin) #calculate angle between bond pairs ang = np.zeros((na, na), float) for i in range(1, na - 1): for j in range(1, na - 1): p1 = pts[i - 1, :] p2 = pts[i + 1, :] q1 = pts[j - 1, :] q2 = pts[j + 1, :] l1 = p2 - p1 l2 = q2 - q1 ang[i, j] = abs( old_div(np.dot(l1, l2), (np.linalg.norm(l1) * np.linalg.norm(l2)))) #calculate score based on the angle between neighbor bonds score = np.zeros(na, float) dist = np.empty(na, float) nnb = 10 # number of neighbors considered for i in range(na): for j in range(na): dist[j] = np.linalg.norm(pts[i, :] - pts[j, :]) srti = np.argsort(dist) for j in range(nnb): d = dist[srti[j]] wt = gaussianpdf(d, 5) score[i] += ang[i, srti[j]] * wt #print score maxsheet = options.nsht # max number of sheet chains sheets = {} insht = np.zeros(na, int) for nsheet in range(maxsheet): nonsht = np.where(insht == 0) nonsht = nonsht[0] topi = np.where( score > np.average(score[nonsht]) + np.std(score[nonsht])) topi = topi[0] topi = np.sort(topi) maxlen = len(topi) nl = 0 maxnl = 0 maxstart = -1 for i in range(maxlen - 1): if (topi[i + 1] - topi[i] > 1): if (maxnl < nl): maxnl = nl maxstart = i - nl nl = 0 else: nl += 1 shtstart = topi[maxstart] + 1 shtend = topi[maxstart] + maxnl sht = np.array(list(range(shtstart, shtend))) print( shtstart, shtend, np.average(score[sht]), np.average(score[nonsht]) + np.std(score[nonsht]) * options.cutoff) if maxnl < options.minlen: break if np.average(score[sht]) < np.average(score[nonsht]) + np.std( score[nonsht]) * options.cutoff: #stop criteria ... break #enlong the chain for i in range(maxnl - 2): ni = shtstart + i nj = shtstart + i + 2 #print ni,ang[ni,nj] if (ang[ni, nj] < .5): break shtend = ni + 1 for term in [-1, 1]: if term < 0: t = shtstart else: t = shtend for i in range(20): ni = t + term * (i - 2) nj = t + term * (i + 1) #print ni,ang[ni,nj] if (ang[ni, nj] < .7): break if term < 0: shtstart -= i else: shtend += i sheets[nsheet] = [shtstart, shtend] sht = np.array(list(range(shtstart, shtend))) insht[sht] = 1 #recalc the score score = np.zeros(na, float) dist = np.empty(na, float) nnb = 10 # number of neighbors considered for i in range(na): if insht[i] == 1: continue for j in range(na): dist[j] = np.linalg.norm(pts[i, :] - pts[j, :]) srti = np.argsort(dist) for j in range(nnb): d = dist[srti[j]] wt = gaussianpdf(d, 5) if insht[srti[j]] == 1: wt *= 2 score[i] += ang[i, srti[j]] * wt print(sheets) write_pdb(options.output, pts, score, atomnumber, sheets, header) E2end(logid)