def compute_max_block_size(self): """ Compute the required memory """ total_memory = psutil.virtual_memory().total max_memory_usage = self.params.integration.block.max_memory_usage assert max_memory_usage > 0.0, "maximum memory usage must be > 0" assert max_memory_usage <= 1.0, "maximum memory usage must be <= 1" limit_memory = int(floor(total_memory * max_memory_usage)) return MultiThreadedReferenceProfiler.compute_max_block_size( self.experiments[0].imageset, max_memory_usage=limit_memory)
def compute_reference_profiles(self, imageset): """ Integrate the reflections """ from dials.algorithms.integration.integrator import frame_hist # Compute the partiality self.reflections.compute_partiality(self.experiments) # Get some info EPS = 1e-7 full_value = 0.997300203937 - EPS fully_recorded = self.reflections["partiality"] > full_value npart = fully_recorded.count(False) nfull = fully_recorded.count(True) select_ice = self.reflections.get_flags( self.reflections.flags.in_powder_ring) select_int = ~self.reflections.get_flags( self.reflections.flags.dont_integrate) nice = select_ice.count(True) nint = select_int.count(True) ntot = len(self.reflections) frame0, frame1 = imageset.get_scan().get_array_range() # Write some output logger.info(" Beginning integration job %d" % self.index) logger.info("") logger.info(" Frames: %d -> %d" % (frame0, frame1)) logger.info("") logger.info(" Number of reflections") logger.info(" Partial: %d" % npart) logger.info(" Full: %d" % nfull) logger.info(" In ice ring: %d" % nice) logger.info(" Integrate: %d" % nint) logger.info(" Total: %d" % ntot) logger.info("") # Print a histogram of reflections on frames if frame1 - frame0 > 1: logger.info( " The following histogram shows the number of reflections predicted" ) logger.info( " to have all or part of their intensity on each frame.") logger.info("") logger.info( frame_hist(self.reflections["bbox"].select(select_int), prefix=" ", symbol="*")) logger.info("") # Construct the mask algorithm compute_mask = MaskCalculatorFactory.create(self.experiments, self.params) # Construct the background algorithm compute_background = BackgroundCalculatorFactory.create( self.experiments, self.params) # Construct the intensity algorithm compute_reference = ReferenceCalculatorFactory.create( self.experiments, self.params) # Call the multi threaded integrator reference_calculator = MultiThreadedReferenceProfiler( reflections=self.reflections, imageset=imageset, compute_mask=compute_mask, compute_background=compute_background, compute_reference=compute_reference, logger=Logger(logger), nthreads=self.params.integration.mp.nproc, buffer_size=self.params.integration.block.size, use_dynamic_mask=self.params.integration.use_dynamic_mask, debug=self.params.integration.debug.output, ) # Assign the reflections self.reflections = reference_calculator.reflections() # Assign the reference profiles self.reference = compute_reference # Write some log output fmt = "Used %d / %d reflections to create reference profiles" dont_integrate = self.reflections.get_flags( self.reflections.flags.dont_integrate) used_in_modelling = self.reflections.get_flags( self.reflections.flags.used_in_modelling) n_tot = dont_integrate.count(False) n_mod = (used_in_modelling & ~dont_integrate).count(True) logger.info("") logger.info(fmt % (n_mod, n_tot))