def calcResolution(self, level):
		self.resdict = {}
		D=self.getClassificationAtLevel(level)
		for classref in D:
			stack=[]
			for partnum in D[classref]:
				stack.append(apImagicFile.readSingleParticleFromStack("alignedStack.hed",int(partnum)+1,msg=False))
			apImagicFile.writeImagic(stack,"tmp.hed")

			frcdata = apFourier.spectralSNRStack("tmp.hed", self.apix)
			self.resdict[classref] = apFourier.getResolution(frcdata, self.apix, self.boxsize)
		apFile.removeStack("tmp.hed")
	def calcResolution(self, level):
		self.resdict = {}
		D=self.getClassificationAtLevel(level)
		for classref in D:
			stack=[]
			for partnum in D[classref]:
				stack.append(apImagicFile.readSingleParticleFromStack("alignedStack.hed",int(partnum)+1,msg=False))
			apImagicFile.writeImagic(stack,"tmp.hed")

			frcdata = apFourier.spectralSNRStack("tmp.hed", self.apix)
			self.resdict[classref] = apFourier.getResolution(frcdata, self.apix, self.boxsize)
		apFile.removeStack("tmp.hed")
	def calcResolution(self, level):
		self.resdict = {}
		D=self.getClassificationAtLevel(level)
		for classref in D:
			stack=[]
			for partnum in D[classref]:
				### NOTE: RESOLUTION WILL NOT BE CALCULATED IF ALIGNED STACK IS NOT CREATED
				stack.append(apImagicFile.readSingleParticleFromStack(self.params['timestamp']+".hed",int(partnum),msg=False))
			apImagicFile.writeImagic(stack,"tmp.hed")

			frcdata = apFourier.spectralSNRStack("tmp.hed", self.apix)
			self.resdict[classref] = apFourier.getResolution(frcdata, self.apix, self.boxsize)
		apFile.removeStack("tmp.hed")
	def calcResolution(self, level):
		self.resdict = {}
		D=self.getClassificationAtLevel(level)
		for classref in D:
			stack=[]
			for partnum in D[classref]:
				### NOTE: RESOLUTION WILL NOT BE CALCULATED IF ALIGNED STACK IS NOT CREATED
				stack.append(apImagicFile.readSingleParticleFromStack(self.params['timestamp']+".hed",int(partnum),msg=False))
			apImagicFile.writeImagic(stack,"tmp.hed")

			frcdata = apFourier.spectralSNRStack("tmp.hed", self.apix)
			self.resdict[classref] = apFourier.getResolution(frcdata, self.apix, self.boxsize)
		apFile.removeStack("tmp.hed")
	def calcResolution(self, alignedStack):
		self.resdict = {}
		for classref, partlist in self.classD.iteritems():
			if len(partlist) == 0:
				continue
			stack=[]
			for partnum in partlist:
				### NOTE: RESOLUTION WILL NOT BE CALCULATED IF ALIGNED STACK IS NOT CREATED
				stack.append(apImagicFile.readSingleParticleFromStack(alignedStack,int(partnum),msg=False))
			apImagicFile.writeImagic(stack,"tmp.hed")

			frcdata = apFourier.spectralSNRStack("tmp.hed", self.apix)
			self.resdict[classref] = apFourier.getResolution(frcdata, self.apix, self.boxsize)
		apFile.removeStack("tmp.hed")
    def calcResolution(self, alignedStack):
        self.resdict = {}
        for classref, partlist in self.classD.iteritems():
            if len(partlist) == 0:
                continue
            stack = []
            for partnum in partlist:
                ### NOTE: RESOLUTION WILL NOT BE CALCULATED IF ALIGNED STACK IS NOT CREATED
                stack.append(
                    apImagicFile.readSingleParticleFromStack(alignedStack,
                                                             int(partnum),
                                                             msg=False))
            apImagicFile.writeImagic(stack, "tmp.hed")

            frcdata = apFourier.spectralSNRStack("tmp.hed", self.apix)
            self.resdict[classref] = apFourier.getResolution(
                frcdata, self.apix, self.boxsize)
        apFile.removeStack("tmp.hed")
        def makeNewStacks(self, parttree):
                ### untilted stack
                self.notstackdata = apStack.getOnlyStackData(self.params['notstackid'])
                notstackfile = os.path.join(self.notstackdata['path']['path'], self.notstackdata['name'])

                ### tilted stack
                if not self.tiltstackdata:
                        self.tiltstackdata = apStack.getOnlyStackData(self.params['tiltstackid'])
                tiltstackfile = os.path.join(self.tiltstackdata['path']['path'], self.tiltstackdata['name'])

                ### make doc file of Euler angles
                #eulerfile = self.makeEulerDoc(parttree)
                eulerfile = os.path.join(self.params['rundir'], "eulersdoc"+self.timestamp+".spi")
                if os.path.isfile(eulerfile):
                        apFile.removeFile(eulerfile)

                count = 0
                notstacklist = []
                tiltstacklist = []
                sizelimit = 2048
                notbox = apImagicFile.getBoxsize(notstackfile)
                tiltbox  = apImagicFile.getBoxsize(tiltstackfile)
                tiltstacks = []
                notstacks = []
                t0 = time.time()
                for partdict in parttree:
                        ### print friendly message
                        if count % 100 == 0:
                                backs = "\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b"
                                sys.stderr.write(backs+backs+backs+backs)
                                if count > sizelimit:
                                        esttime = (len(parttree)/float(count)-1.0)*(time.time()-t0)
                                        sys.stderr.write(str(count)+" particles of "+str(len(parttree))
                                                +", "+apDisplay.timeString(esttime)+" remaining")
                                else:
                                        sys.stderr.write(str(count)+" particles of "+str(len(parttree)))
                        ### save stacks to file to save memory
                        if count%sizelimit == 0:
                                if count > 1:
                                        apDisplay.printMsg("Writing stacks to file")
                                        t1 = time.time()
                                        tiltname = os.path.join(self.params['rundir'], "tiltstack%d.hed"%(count))
                                        apFile.removeStack(tiltname)
                                        apImagicFile.writeImagic(tiltstacklist, tiltname, msg=False)
                                        tiltstacks.append(tiltname)
                                        apDisplay.printMsg("finished tilted stack in "+apDisplay.timeString(time.time()-t1))
                                        t1 = time.time()
                                        notname = os.path.join(self.params['rundir'], "notstack%d.hed"%(count))
                                        apFile.removeStack(notname)
                                        apImagicFile.writeImagic(notstacklist, notname, msg=False)
                                        notstacks.append(notname)
                                        apDisplay.printMsg("finished untilted stack in "+apDisplay.timeString(time.time()-t1))
                                ### reset stacks
                                apDisplay.printMsg("Reset stacks in memory")
                                notstacklist = []
                                tiltstacklist = []
                        ### increment count
                        count += 1
                        ### write to Euler doc
                        self.appendEulerDoc(eulerfile, partdict['tilt'], count)
                        ### untilted stack
                        notpartarray = apImagicFile.readSingleParticleFromStack(notstackfile, partdict['not'], notbox, False)
                        notstacklist.append(notpartarray)
                        ### tilted stack
                        tiltpartarray = apImagicFile.readSingleParticleFromStack(tiltstackfile, partdict['tilt'], tiltbox, False)
                        tiltstacklist.append(tiltpartarray)
                ### write remaining particles to stack
                if len(notstacklist) > 0:
                        apDisplay.printMsg("Writing stacks to file")
                        t1 = time.time()
                        tiltname = os.path.join(self.params['rundir'], "tiltstack%d.hed"%(count))
                        apFile.removeStack(tiltname)
                        apImagicFile.writeImagic(tiltstacklist, tiltname, msg=False)
                        tiltstacks.append(tiltname)
                        apDisplay.printMsg("finished tilted stack in "+apDisplay.timeString(time.time()-t1))
                        t1 = time.time()
                        notname = os.path.join(self.params['rundir'], "notstack%d.hed"%(count))
                        apFile.removeStack(notname)
                        apImagicFile.writeImagic(notstacklist, notname, msg=False)
                        notstacks.append(notname)
                        apDisplay.printMsg("finished untilted stack in "+apDisplay.timeString(time.time()-t1))

                ### merge NOT stack
                notname = os.path.join(self.params['rundir'], "notstack.hed")
                apImagicFile.mergeStacks(notstacks, notname)
                for stackname in notstacks:
                        apFile.removeStack(stackname, warn=False)

                ### merge TILT stack
                tiltname = os.path.join(self.params['rundir'], "tiltstack.hed")
                apImagicFile.mergeStacks(tiltstacks, tiltname)
                for stackname in tiltstacks:
                        apFile.removeStack(stackname, warn=False)

                ### upload results
                if self.params['commit'] is True:
                        self.uploadResults()