def main():
if sys.argv[-1].startswith("usefs="): sys.argv = sys.argv[:-1] # remove the runpar fileserver info
(options,args) = parse_command_line()
if not options.nolog and (not mpi or (mpi and mpi.rank==0)): EMAN.appinit(sys.argv)
inputParm = EMAN.ccmlInputParm()
sf = EMAN.XYData()
if options.sfFileName != "" :
readsf = sf.readFile(options.sfFileName)
if ((readsf == -1) and (options.verbose > 0)) :
print "The file of scattering factor does NOT exist"
inputParm.scateringFactor = sf
startNumOfRawImages = options.startNumOfRawImages
#endNumOfRawImages = options.endNumOfRawImages
refImageFileName = args[-1]
numOfRefImages = options.numOfRefImages
solutionFile = options.solutionFile
# write log info to .emanlog file so that eman program can browse the history
if not options.nolog and (not mpi or (mpi and mpi.rank==0)):
pid = EMAN.LOGbegin(sys.argv)
for f in args[0:-1]: EMAN.LOGInfile(pid,f)
EMAN.LOGReffile(pid,args[-1])
if options.solutionFile: EMAN.LOGOutfile(pid,options.solutionFile)
if options.listFile: EMAN.LOGOutfile(pid,options.listFile)
if options.mrcSolutionFile: EMAN.LOGOutfile(pid,options.mrcSolutionFile)
inputParm.sym = options.sym
inputParm.FFTOverSampleScale = options.FFTOverSampleScale
inputParm.pftStepSize = options.pftStepSize
inputParm.deltaR = options.deltaR
inputParm.RMin = options.RMin
inputParm.RMax = options.RMax
inputParm.searchMode = options.searchMode
inputParm.scalingMode = options.scalingMode
inputParm.residualMode = options.residualMode
inputParm.weightMode = options.weightMode
# inputParm.rawImageFN will be set later
inputParm.refImagesFN = refImageFileName
inputParm.rawImageIniParmFN = options.rawImageIniParmFN
inputParm.rawImagePhaseCorrected = options.phasecorrected
inputParm.maxNumOfRun = options.maxNumOfRun
inputParm.zScoreCriterion = options.zScoreCriterion
inputParm.residualCriterion = options.residualCriterion
inputParm.solutionCenterDiffCriterion = options.solutionCenterDiffCriterion
inputParm.solutionOrientationDiffCriterion = options.solutionOrientationDiffCriterion/180.0*pi
inputParm.maxNumOfIteration = options.maxNumOfIteration
inputParm.numOfRandomJump = options.numOfRandomJump
inputParm.numOfFastShrink = options.numOfFastShrink
inputParm.numOfStartConfigurations = options.numOfStartConfigurations
inputParm.orientationSearchRange = options.orientationSearchRange/180.0*pi
inputParm.centerSearchRange = options.centerSearchRange
inputParm.numOfRefImages = options.numOfRefImages
inputParm.refEulerConvention = options.refEulerConvention
#maskR = options.maskR
#if (maskR<=0): maskR = refImageSizeY/2
inputParm.verbose = options.verbose
verbose = options.verbose
#verboseSolution = options.verboseSolution
updataHeader = options.updataHeader
solutionFile = options.solutionFile
mrcSolutionFile = options.mrcSolutionFile
iniCenterOrientationMode = options.iniCenterOrientationMode
refCenterOrientationMode = options.refCenterOrientationMode
rawImages = []
if not mpi or (mpi and mpi.rank==0):
for imgfile in args[0:-1]:
imgnum = EMAN.fileCount(imgfile)[0]
for i in range(imgnum): rawImages.append((imgfile, i))
if mpi: rawImages = mpi.bcast(rawImages)
endNumOfRawImages = options.endNumOfRawImages
if endNumOfRawImages <=0 or endNumOfRawImages > len(rawImages):
endNumOfRawImages = len(rawImages)
numRawImages = endNumOfRawImages - startNumOfRawImages
if mpi:
ptclset = range(startNumOfRawImages + mpi.rank, endNumOfRawImages, mpi.size)
else:
ptclset = range(startNumOfRawImages, endNumOfRawImages)
solutions = []
rMask = options.rMask #mask size is given
if options.rMask <= 0 : rMask = refImageSizeY/2 #mask size = half image size
rMask1 = options.rMask1 #output tnf mask size is given
if options.rMask1 <= 0 : rMask1 = rMask #output tnf mask size = half image size
inputParm.rMask = rMask
inputParm.rMask1 = rMask1
rawImage = EMAN.EMData()
rawImage.getEuler().setSym(inputParm.sym) #set the symmetry of the raw partile
inputParm.rawImageFN = rawImages[0][0] #give the initial raw particle filename
print "start to prepare------"
rawImage.crossCommonLineSearchPrepare(inputParm) #prepare, create pseudo PFT of ref images
print "end to prepare------"
inputParm.rawImage = rawImage
#for rawImgSN in ptclset:
for index in range(len(ptclset)):
rawImgSN = ptclset[index]
inputParm.rawImageFN = rawImages[rawImgSN][0]
inputParm.thisRawImageSN = rawImages[rawImgSN][1]
if mpi: print "rank %d: %d in %d-%d (%d in %d-%d)" % (mpi.rank, rawImgSN, startNumOfRawImages, endNumOfRawImages, index, 0, len(ptclset))
#rawImage.readImage(rawImages[rawImgSN][0], rawImages[rawImgSN][1])
#rawImage.applyMask(rMask, 6) #apply mask type 6 [edge mean value] to raw image, center will be image center
#rawImage.getEuler().setSym("icos")
#if rawImage.hasCTF() == 1:
#ctfParm = rawImage.getCTF()
#inputParm.zScoreCriterion = options.zScoreCriterion + atan(abs(ctfParm[0])-1.5)/(pi/4) +0.59 #adjust zScore criterion -0.6 --> +1.2, 1.5, 2.0
#inputParm.numOfRefImages = int(min(numOfRefImages, max(numOfRefImages*exp(-(abs(ctfParm[0])/2.0-0.15))+0.5, 5.0))) # adjust maxNumOfRun, the min is 2
inputParm.thisRawImageSN = rawImgSN
solutionCenterDiffCriterion = inputParm.solutionCenterDiffCriterion
solutionOrientationDiffCriterion = inputParm.solutionOrientationDiffCriterion
#initialize Center And Orientation by ont of the following modes
if iniCenterOrientationMode == "iniparmfile" :
inputParm.initializeCenterAndOrientationFromIniParmFile() # need to set "refEulerConvention"
elif iniCenterOrientationMode == "headerfile" :
inputParm.initializeCenterAndOrientationFromParticle() # need to set "refEulerConvention"
else :
inputParm.initializeCenterAndOrientationFromRandom() # default is random orientation and physical center
#set the refence Center And Orientation by ont of the following modes
if refCenterOrientationMode == "iniparmfile" : inputParm.setRefCenterAndOrientationFromIniParmFile() # need to set "refEulerConvention"
elif refCenterOrientationMode == "headerfile" : inputParm.setRefCenterAndOrientationFromParticle() # need to set "refEulerConvention"
else : inputParm.setRefCenterAndOrientationFromInitializedParms() # default is copy the initial center and orientation
rawImage.crossCommonLineSearchReadRawParticle(inputParm) #create pseudo PFT of raw image
maxNumOfRun = inputParm.maxNumOfRun
outputParmList = []
numOfRun = 0
passAllConsistencyCriteria = 0
while (numOfRun < maxNumOfRun) or (len(outputParmList) < 2):
if (iniCenterOrientationMode != "iniparmfile") and (iniCenterOrientationMode != "headerfile") :
inputParm.initializeCenterAndOrientationFromRandom() # default is random orientation and physical center
if (refCenterOrientationMode != "iniparmfile") and (refCenterOrientationMode != "headerfile") :
inputParm.setRefCenterAndOrientationFromInitializedParms() # default is copy the initial center and orientation
numOfRun = numOfRun + 1
print "numOfRun = ", numOfRun
############################################################################
############ execute cross common line search for reference ################
############################################################################
outputParm = rawImage.crossCommonLineSearch(inputParm)
############################################################################
# pass criteria check
outputParmList.append(outputParm) #if passed criteria, e.g. zscore, residualThreshold, etc
############################################################################
outputParmList.sort(lambda x, y: cmp(x.residual, y.residual))
############################################################################
########################## consistency check ###############################
############################################################################
#passConsistencyCriteria = 0
finalOutputParmList = []
lowestResidualList = []
lengthOfList = len(outputParmList)
if lengthOfList < 2 : continue
for i in range(lengthOfList-1):
thisOutputParm = outputParmList[i]
numOfPairsPassConsistencyCheck = 0
for j in range(i+1,lengthOfList):
refOutputParm = outputParmList[j]
tmpOutputParm = EMAN.ccmlOutputParm() #create a new output parm object
tmpOutputParm.rawImageSN = thisOutputParm.rawImageSN #copy all paramenters
tmpOutputParm.residual = thisOutputParm.residual
tmpOutputParm.sigma = thisOutputParm.sigma
tmpOutputParm.verbose = thisOutputParm.verbose
tmpOutputParm.zScore = thisOutputParm.zScore
tmpOutputParm.zScoreCriterion = thisOutputParm.zScoreCriterion
tmpOutputParm.passAllCriteria = 0
tmpOutputParm.setCalculatedCenterAndOrientation(thisOutputParm.cx,thisOutputParm.cy,thisOutputParm.q)
tmpOutputParm.setRefCenterAndOrientation(refOutputParm.cx, refOutputParm.cy, refOutputParm.q)
tmpOutputParm.calculateDifferenceWithRefParm() #calculated the difference
centerDiff = tmpOutputParm.centerDiff
orientationDiff = tmpOutputParm.orientationDiff
##### FLIP CASE : if no consistency found, try flip this orientation
if ((centerDiff > solutionCenterDiffCriterion) or (orientationDiff > solutionOrientationDiffCriterion)) :
quatFlip = EMAN.Quaternion(refOutputParm.q.getEuler().alt(), refOutputParm.q.getEuler().az(), refOutputParm.q.getEuler().phi()+pi)
tmpOutputParm.setRefCenterAndOrientation(refOutputParm.cx, refOutputParm.cy, quatFlip)
tmpOutputParm.calculateDifferenceWithRefParm() #calculated the difference
centerDiff = tmpOutputParm.centerDiff
orientationDiff = tmpOutputParm.orientationDiff
tmpOutputParm.setRefCenterAndOrientation(refOutputParm.cx, refOutputParm.cy, refOutputParm.q) #set back the exact orientation of reference
#Save the configurations with lowest residuals
if (i<3) and (j==i+1) : lowestResidualList.append(tmpOutputParm)
#make the good/answers list
if ((centerDiff < solutionCenterDiffCriterion) and (orientationDiff < solutionOrientationDiffCriterion)) :
numOfPairsPassConsistencyCheck += 1
if numOfPairsPassConsistencyCheck == 1 : #save to the final list
tmpOutputParm.passAllCriteria = 1
finalOutputParmList.append(tmpOutputParm)
if i==0 and numOfPairsPassConsistencyCheck >= options.numConsistentRun: #if the first one, check whether it has 3 pair of consistencies
passAllConsistencyCriteria = 1
break
if i>0 : break #if not the first one, find one pair of consistency, then break
#no break here, just for saving all possible solutions
if passAllConsistencyCriteria and len(finalOutputParmList) >= options.numConsistentRun: break #if 3 consistent pair orientations were found, then stop
rawImage.crossCommonLineSearchReleaseParticle(inputParm) # release the memory related to this raw particle
# if no consistency found, keep the lowest ones as output
if len(finalOutputParmList) == 0 : finalOutputParmList = lowestResidualList
for i in range(len(finalOutputParmList)) :
if passAllConsistencyCriteria : finalOutputParmList[i].passAllCriteria = 1
else : finalOutputParmList[i].passAllCriteria = 0
if options.solutionFile:
for i in range(len(finalOutputParmList)) : finalOutputParmList[i].outputResult(solutionFile)
outputParm = finalOutputParmList[0] #just use the lowest residual as regular output
if outputParm.passAllCriteria: passfail = "pass"
else: passfail = "fail"
print "Final result: euler=%g\t%g\t%g\tcenter=%g\t%g\tresidue=%g\t%s" % (outputParm.alt*180/pi, outputParm.az*180/pi, outputParm.phi*180/pi, outputParm.cx, outputParm.cy, outputParm.residual, passfail)
if options.scoreFile:
rawImage.readImage(rawImages[rawImgSN][0], rawImages[rawImgSN][1], 1) # read header only
if rawImage.hasCTF():
defocus = rawImage.getCTF()[0]
else:
defocus = 0
solution = (rawImages[rawImgSN][0], rawImages[rawImgSN][1], outputParm.alt, outputParm.az, outputParm.phi, \
outputParm.cx, outputParm.cy, defocus, outputParm.residual, outputParm.passAllCriteria)
solutions.append( solution )
sys.stdout.flush()
rawImage.crossCommonLineSearchFinalize(inputParm) #finalize, i.e. delete memories
if mpi:
if options.verbose:
print "rank %d: done and ready to output" % (mpi.rank)
sys.stdout.flush()
mpi.barrier()
#print "rank %d: %s" % (mpi.rank, solutions)
if mpi.rank==0:
for r in range(1,mpi.size):
msg, status = mpi.recv(source = r, tag = r)
solutions += msg
def ptcl_cmp(x, y):
eq = cmp(x[0], y[0])
if not eq: return cmp(x[1],y[1])
else: return eq
solutions.sort(ptcl_cmp)
else:
mpi.send(solutions, 0, tag = mpi.rank)
if not mpi or (mpi and mpi.rank==0):
if options.scoreFile:
sFile = open(options.scoreFile, "w")
sFile.write("#LST\n")
for i in solutions:
if i[-1]:
sFile.write("%d\t%s\tdefocus=%g\tresidual=%g\n" % (i[1], i[0], i[7], i[8]))
sFile.close()
if options.listFile:
lFile = open(options.listFile, "w")
lFile.write("#LST\n")
for i in solutions:
if i[-1]:
lFile.write("%d\t%s\t%g\t%g\t%g\t%g\t%g\n" % (i[1], i[0], i[2]*180.0/pi, i[3]*180.0/pi, i[4]*180.0/pi, i[5], i[6]))
lFile.close()
if options.mrcSolutionFile:
outFile = open(options.mrcSolutionFile, "w")
for i in solutions:
if i[-1]:
#rawImage.readImage(i[0], i[1], 1)
rawImage.readImage(i[0], i[1])
thisEu = EMAN.Euler(i[2], i[3], i[4])
thisEu.convertToMRCAngle()
alt = thisEu.alt_MRC()*180.0/pi
az = thisEu.az_MRC()*180.0/pi
phi = thisEu.phi_MRC()*180.0/pi
cx = i[5]
cy = i[6]
dx = cx - rawImage.xSize()/2
dy = cy - rawImage.ySize()/2
rawImage.applyMask(rMask1,6,dx,dy,0) #apply mask type 4 [outside=0] to raw image, center will be the solved center
#tnfFileName = "%s-%d.tnf" % (os.path.basename(os.path.splitext(rawImages[rawImgSN][0])[0]), rawImages[rawImgSN][1])
prefix = os.path.dirname(options.mrcSolutionFile).replace(" ", "")
if prefix != "" : prefix = prefix + "/"
tnfFileName = "%s%s-%d.tnf" % (prefix,os.path.basename(os.path.splitext(i[0])[0]), i[1])
rawFFT = rawImage.doFFT()
rawFFT.writeImage(tnfFileName,0) #tnf file no header information, it is a pure FFT of raw image file
outFile.write("%s\n" % (os.path.abspath(tnfFileName)))
outFile.write(" %d, %.4f, %.4f, %.4f, %.4f, %.4f, 0.0\n" % (0, alt, az, phi, cy, cx))
outFile.close()
if updataHeader:
for i in solutions:
rawImage.readImage(i[0], i[1], 1)
if options.verbose:
cx = rawImage.get_center_x()
cy = rawImage.get_center_y()
alt = rawImage.alt()
az = rawImage.az()
phi = rawImage.phi()
print "Update header: %s %d\t%7.5f %7.5f %7.2f %7.2f %7.2f => %7.5f %7.5f %7.2f %7.2f %7.2f" % \
(i[0], i[1], alt*180.0/pi, az*180.0/pi, phi*180.0/pi, cx, cy, i[2]*180.0/pi, i[3]*180.0/pi, i[4]*180.0/pi, i[5], i[6])
rawImage.setRAlign(i[2], i[3], i[4])
rawImage.set_center_x(i[5])
rawImage.set_center_y(i[6])
imgtype = EMAN.EMData.ANY
rawImage.writeImage(i[0], i[1], imgtype, 1)
if not options.nolog and (not mpi or (mpi and mpi.rank==0)): EMAN.LOGend()
def main():
EMAN.appinit(sys.argv)
if sys.argv[-1].startswith("usefs="):
sys.argv = sys.argv[:-1] # remove the runpar fileserver info
(options, rawimage, refmap) = parse_command_line()
sffile = options.sffile
verbose = options.verbose
shrink = options.shrink
mask = options.mask
first = options.first
last = options.last
scorefunc = options.scorefunc
projfile = options.projection
output_ptcls = options.update_rawimage
cmplstfile = options.cmplstfile
ortlstfile = options.ortlstfile
startSym = options.startSym
endSym = options.endSym
if not options.nocmdlog:
pid = EMAN.LOGbegin(sys.argv)
EMAN.LOGInfile(pid, rawimage)
EMAN.LOGInfile(pid, refmap)
if projfile:
EMAN.LOGOutfile(pid, projfile)
if output_ptcls:
EMAN.LOGOutfile(pid, output_ptcls)
if cmplstfile:
EMAN.LOGOutfile(pid, cmplstfile)
if ortlstfile:
EMAN.LOGOutfile(pid, ortlstfile)
ptcls = []
if not (mpi or pypar) or ((mpi and mpi.rank == 0) or (pypar and pypar.rank == 0)):
ptcls = EMAN.image2list(rawimage)
ptcls = ptcls[first:last]
print "Read %d particle parameters" % (len(ptcls))
# ptcls = ptcls[0:10]
if mpi and mpi.size > 1:
ptcls = mpi.bcast(ptcls)
print "rank=%d\t%d particles" % (mpi.rank, len(ptcls))
elif pypar and pypar.size() > 1:
ptcls = pypar.broadcast(ptcls)
print "rank=%d\t%d particles" % (pypar.rank(), len(ptcls))
if sffile:
sf = EMAN.XYData()
sf.readFile(sffile)
sf.logy()
if not mpi or ((mpi and mpi.rank == 0) or (pypar and pypar.rank() == 0)):
if cmplstfile and projfile:
if output_ptcls:
raw_tmp = output_ptcls
else:
raw_tmp = rawimage
raw_tmp = rawimage
fp = open("tmp-" + cmplstfile, "w")
fp.write("#LST\n")
for i in range(len(ptcls)):
fp.write("%d\t%s\n" % (first + i, projfile))
fp.write("%d\t%s\n" % (first + i, raw_tmp))
fp.close()
if (mpi and mpi.size > 1 and mpi.rank == 0) or (pypar and pypar.size() > 1 and pypar.rank() == 0):
total_recv = 0
if output_ptcls:
total_recv += len(ptcls)
if projfile:
total_recv += len(ptcls)
for r in range(total_recv):
# print "before recv from %d" % (r)
if mpi:
msg, status = mpi.recv()
else:
msg = pypar.receive(r)
# print "after recv from %d" % (r)
# print msg, status
d = emdata_load(msg[0])
fname = msg[1]
index = msg[2]
d.writeImage(fname, index)
print "wrtie %s %d" % (fname, index)
if options.ortlstfile:
solutions = []
for r in range(1, mpi.size):
msg, status = mpi.recv(source=r, tag=r)
solutions += msg
def ptcl_cmp(x, y):
eq = cmp(x[0], y[0])
if not eq:
return cmp(x[1], y[1])
else:
return eq
solutions.sort(ptcl_cmp)
if (not mpi or (mpi and ((mpi.size > 1 and mpi.rank > 0) or mpi.size == 1))) or (
not pypar or (pypar and ((pypar.size() > 1 and pypar.rank() > 0) or pypar.size() == 1))
):
map3d = EMAN.EMData()
map3d.readImage(refmap, -1)
map3d.normalize()
if shrink > 1:
map3d.meanShrink(shrink)
map3d.realFilter(0, 0) # threshold, remove negative pixels
imgsize = map3d.ySize()
img = EMAN.EMData()
ctffilter = EMAN.EMData()
ctffilter.setSize(imgsize + 2, imgsize, 1)
ctffilter.setComplex(1)
ctffilter.setRI(1)
if (mpi and mpi.size > 1) or (pypar and pypar.size() > 1):
ptclset = range(mpi.rank - 1, len(ptcls), mpi.size - 1)
else:
ptclset = range(0, len(ptcls))
if mpi:
print "Process %d/%d: %d/%d particles" % (mpi.rank, mpi.size, len(ptclset), len(ptcls))
solutions = []
for i in ptclset:
ptcl = ptcls[i]
e = EMAN.Euler(ptcl[2], ptcl[3], ptcl[4])
dx = ptcl[5] - imgsize / 2
dy = ptcl[6] - imgsize / 2
print "%d\talt,az,phi=%8g,%8g,%8g\tx,y=%8g,%8g" % (
i + first,
e.alt() * 180 / pi,
e.az() * 180 / pi,
e.phi() * 180 / pi,
dx,
dy,
),
img.readImage(ptcl[0], ptcl[1])
img.setTAlign(-dx, -dy, 0)
img.setRAlign(0, 0, 0)
img.rotateAndTranslate() # now img is centered
img.applyMask(int(mask - max(abs(dx), abs(dy))), 6, 0, 0, 0)
if img.hasCTF():
fft = img.doFFT()
ctfparm = img.getCTF()
ctffilter.setCTF(ctfparm)
if options.phasecorrected:
if sffile:
ctffilter.ctfMap(64, sf) # Wiener filter with 1/CTF (no sign) correction
else:
if sffile:
ctffilter.ctfMap(32, sf) # Wiener filter with 1/CTF (including sign) correction
else:
ctffilter.ctfMap(2, EMAN.XYData()) # flip phase
fft.mult(ctffilter)
img2 = fft.doIFT() # now img2 is the CTF-corrected raw image
img.gimmeFFT()
del fft
else:
img2 = img
img2.normalize()
if shrink > 1:
img2.meanShrink(shrink)
# if sffile:
# snrcurve = img2.ctfCurve(9, sf) # absolute SNR
# else:
# snrcurve = img2.ctfCurve(3, EMAN.XYData()) # relative SNR
e.setSym(startSym)
maxscore = -1e30 # the larger the better
scores = []
for s in range(e.getMaxSymEl()):
ef = e.SymN(s)
# proj = map3d.project3d(ef.alt(), ef.az(), ef.phi(), -6) # Wen's direct 2D accumulation projection
proj = map3d.project3d(
ef.alt(), ef.az(), ef.phi(), -1
) # Pawel's fast projection, ~3 times faster than mode -6 with 216^3
# don't use mode -4, it modifies its own data
# proj2 = proj
proj2 = proj.matchFilter(img2)
proj2.applyMask(int(mask - max(abs(dx), abs(dy))), 6, 0, 0, 0)
if scorefunc == "ncccmp":
score = proj2.ncccmp(img2)
elif scorefunc == "lcmp":
score = -proj2.lcmp(img2)[0]
elif scorefunc == "pcmp":
score = -proj2.pcmp(img2)
elif scorefunc == "fsccmp":
score = proj2.fscmp(img2, [])
elif scorefunc == "wfsccmp":
score = proj2.fscmp(img2, snrcurve)
if score > maxscore:
maxscore = score
best_proj = proj2
best_ef = ef
best_s = s
scores.append(score)
# proj2.writeImage("proj-debug.img",s)
# print "\tsym %2d/%2d: euler=%8g,%8g,%8g\tscore=%12.7g\tbest=%2d euler=%8g,%8g,%8g score=%12.7g\n" % \
# (s,60,ef.alt()*180/pi,ef.az()*180/pi,ef.phi()*180/pi,score,best_s,best_ef.alt()*180/pi,best_ef.az()*180/pi,best_ef.phi()*180/pi,maxscore)
scores = Numeric.array(scores)
print "\tbest=%2d euler=%8g,%8g,%8g max score=%12.7g\tmean=%12.7g\tmedian=%12.7g\tmin=%12.7g\n" % (
best_s,
best_ef.alt() * 180 / pi,
best_ef.az() * 180 / pi,
best_ef.phi() * 180 / pi,
maxscore,
MLab.mean(scores),
MLab.median(scores),
MLab.min(scores),
)
if projfile:
best_proj.setTAlign(dx, dy, 0)
best_proj.setRAlign(0, 0, 0)
best_proj.rotateAndTranslate()
best_proj.set_center_x(ptcl[5])
best_proj.set_center_y(ptcl[6])
best_proj.setRAlign(best_ef)
# print "before proj send from %d" % (mpi.rank)
if mpi and mpi.size > 1:
mpi.send((emdata_dump(best_proj), projfile, i + first), 0)
elif pypar and pypar.size() > 1:
pypar.send((emdata_dump(best_proj), projfile, i + first), 0)
# print "after proj send from %d" % (mpi.rank)
else:
best_proj.writeImage(projfile, i + first)
img2.setTAlign(0, 0, 0)
img2.setRAlign(best_ef)
img2.setNImg(1)
# print "before raw send from %d" % (mpi.rank)
if output_ptcls:
if mpi and mpi.size > 1:
mpi.send((emdata_dump(img2), output_ptcls, i + first), 0)
elif pypar and pypar.size() > 1:
pypar.send((emdata_dump(img2), output_ptcls, i + first), 0)
# print "after raw send from %d" % (mpi.rank)
else:
img2.writeImage(output_ptcls, i + first)
solutions.append((ptcl[0], ptcl[1], best_ef.alt(), best_ef.az(), best_ef.phi(), ptcl[5], ptcl[6]))
if mpi and (mpi.size > 1 and mpi.rank > 0):
mpi.send(solutions, 0, tag=mpi.rank)
if mpi:
mpi.barrier()
elif pypar:
pypar.barrier()
if mpi:
mpi.finalize()
elif pypar:
pypar.finalize()
if options.cmplstfile:
os.rename("tmp-" + cmplstfile, cmplstfile)
if options.ortlstfile:
lFile = open(options.ortlstfile, "w")
lFile.write("#LST\n")
for i in solutions:
lFile.write(
"%d\t%s\t%g\t%g\t%g\t%g\t%g\n"
% (i[1], i[0], i[2] * 180.0 / pi, i[3] * 180.0 / pi, i[4] * 180.0 / pi, i[5], i[6])
)
lFile.close()
if not options.nocmdlog:
EMAN.LOGend()