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)
