def compute_required_memory(imageset, block_size):
"""
Compute the required memory
"""
return MultiThreadedIntegrator.compute_required_memory(
imageset, block_size)
def compute_required_memory(self, imageset):
"""
Compute the required memory
"""
return MultiThreadedIntegrator.compute_required_memory(
imageset, self.params.integration.block.size
)
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 MultiThreadedIntegrator.compute_max_block_size(
self.experiments[0].imageset, max_memory_usage=limit_memory)
def integrate(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_intensity = IntensityCalculatorFactory.create(
self.experiments, self.reference, self.params)
# Call the multi threaded integrator
integrator = MultiThreadedIntegrator(
reflections=self.reflections,
imageset=imageset,
compute_mask=compute_mask,
compute_background=compute_background,
compute_intensity=compute_intensity,
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 = integrator.reflections()
