Example #1
0
class EMTomoAlignTaskDC(EMTask):
    '''
	A class the knows how to align two 3D volumes using parallel DC framework
	'''
    def __init__(self, command="e2tomoallvall", data=None, options=None):
        EMTask.__init__(self, command, data, options)
        # need this import for parallelism to work - somebody fixme?
        from e2tomoallvall import EMTomoAlignTask
        self.align_task = EMTomoAlignTask(data=data)


#		self.align_data = align_data
#		self.ralign_data = ralign_data
#		self.cmp_data = cmp_data

    def execute(self, progress_callback):
        '''
		Called to perform class averaging 
		May boot strap the original average, iteratively refines averages, aligns final average to ref 
		'''
        from EMAN2db import db_open_dict
        progress_callback(0)

        cache_name = self.data["probe"][1]
        cache = db_open_dict(cache_name)
        probe = cache[self.data["probe"][2]]

        cache_name = self.data["target"][1]
        cache = db_open_dict(cache_name)
        target = cache[self.data["target"][2]]

        return self.align_task.align(probe, target, progress_callback)
Example #2
0
class EMTomoAlignTaskDC(EMTask):
	'''
	A class the knows how to align two 3D volumes using parallel DC framework
	'''
	def __init__(self,command="e2tomoallvall",data=None,options=None):
		EMTask.__init__(self,command,data,options)
		# need this import for parallelism to work - somebody fixme?
		from e2tomoallvall import EMTomoAlignTask
		self.align_task = EMTomoAlignTask(data=data)
#		self.align_data = align_data
#		self.ralign_data = ralign_data
#		self.cmp_data = cmp_data
	
	def execute(self,progress_callback):
		'''
		Called to perform class averaging 
		May boot strap the original average, iteratively refines averages, aligns final average to ref 
		'''
		from EMAN2db import db_open_dict
		progress_callback(0)
		
		cache_name=self.data["probe"][1]
		cache=db_open_dict(cache_name)
		probe = cache[self.data["probe"][2]]
		
		cache_name=self.data["target"][1]
		cache=db_open_dict(cache_name)
		target = cache[self.data["target"][2]]
		
		return self.align_task.align(probe, target, progress_callback)
Example #3
0
 def __init__(self, command="e2tomoallvall", data=None, options=None):
     EMTask.__init__(self, command, data, options)
     # need this import for parallelism to work - somebody fixme?
     from e2tomoallvall import EMTomoAlignTask
     self.align_task = EMTomoAlignTask(data=data)
Example #4
0
    def execute(self, alignment_jobs, files, caller):
        '''
		The main function
		@param alignment_jobs a list of alignment pair indices like this [[0,1],[2,1],[2,3],[0,5],...] etc the indices pair represent images to be aligned and correspond to the order of the files argument
		@param files a list of filenames - used to read image based on the indices present in alignment_jobs
		@param caller - the calling object - it needs to have a function called process_output that takes a dictionary as the argument 
		'''
        options = self.options
        align_data = EMAN2.parsemodopt(options.align)
        align_cmp_data = EMAN2.parsemodopt(options.aligncmp)
        cmp_data = EMAN2.parsemodopt(options.cmp)
        ralign_data = None
        if options.ralign != None:
            ralign_data = EMAN2.parsemodopt(options.ralign)
            ralign_cmp_data = EMAN2.parsemodopt(options.raligncmp)

        data = {}
        data["align"] = align_data
        data["aligncmp"] = align_cmp_data
        data["cmp"] = cmp_data
        if ralign_data:
            data["ralign"] = ralign_data
            data["raligncmp"] = ralign_cmp_data

        data["using_cuda"] = self.using_cuda
        data["nsoln"] = self.nsoln

        if self.options.parallel:
            task_customers = []
            tids = []

            if options.shrink:
                scratch_name_1 = numbered_bdb(
                    "bdb:tomo_scratch#scratch_shrink")
                scratch_name_2 = numbered_bdb(
                    "bdb:tomo_scratch##scratch_shrink")
            else:
                print("no shrink")

            for i, j in alignment_jobs:
                if options.shrink or options.filter:

                    a = EMData(files[i], 0)
                    if options.filter:
                        filter_params = EMAN2.parsemodopt(options.filter)
                        a.process_inplace(filter_params[0], filter_params[1])
                    if options.shrink:
                        a.process_inplace("math.meanshrink",
                                          {"n": options.shrink})

                    a.set_attr("src_image", files[i])
                    a.write_image(scratch_name_1, 0)

                    a = EMData(files[j], 0)
                    if options.filter:
                        filter_params = EMAN2.parsemodopt(options.filter)
                        a.process_inplace(filter_params[0], filter_params[1])
                    if options.shrink:
                        a.process_inplace("math.meanshrink",
                                          {"n": options.shrink})
                    a.set_attr("src_image", files[j])
                    a.write_image(scratch_name_2, 0)

                    data["probe"] = ("cache", scratch_name_1, 0)
                    data["target"] = ("cache", scratch_name_2, 0)
                else:
                    data["probe"] = ("cache", files[i], 0)
                    data["target"] = ("cache", files[j], 0)

                data["target_idx"] = j
                data["probe_idx"] = i

                task = EMTomoAlignTaskDC(data=data)

                from EMAN2PAR import EMTaskCustomer
                etc = EMTaskCustomer(self.options.parallel)
                #print "Est %d CPUs"%etc.cpu_est()
                tid = etc.send_task(task)
                #print "Task submitted tid=",tid

                task_customers.append(etc)
                tids.append(tid)

            self.dc_monitor(task_customers, tids, caller)
        else:
            n = len(alignment_jobs)
            p = 0.0
            for i, j in alignment_jobs:

                probe = EMData(files[i], 0)
                target = EMData(files[j], 0)

                if options.filter:
                    print("filtered")
                    filter_params = EMAN2.parsemodopt(options.filter)
                    probe.process_inplace(filter_params[0], filter_params[1])
                    target.process_inplace(filter_params[0], filter_params[1])

                if options.shrink:
                    probe.process_inplace("math.meanshrink",
                                          {"n": options.shrink})
                    target.process_inplace("math.meanshrink",
                                           {"n": options.shrink})
                else:
                    print("no shrink")

                data["target"] = target
                data["probe"] = probe
                data["target_idx"] = j
                data["probe_idx"] = i

                task = EMTomoAlignTask(data=data)
                rslts = task.execute(self.progress_callback)

                if options.shrink:
                    self.correction_translation(rslts, options.shrink)
                caller.process_output(rslts)

                p += 1.0
Example #5
0
	def __init__(self,command="e2tomoallvall",data=None,options=None):
		EMTask.__init__(self,command,data,options)
		# need this import for parallelism to work - somebody fixme?
		from e2tomoallvall import EMTomoAlignTask
		self.align_task = EMTomoAlignTask(data=data)