def __call__(self, imageset):
'''
Override the parameters
'''
from dxtbx.imageset import ImageSet
from dxtbx.imageset import ImageSweep
from dxtbx.model import BeamFactory
from dxtbx.model import DetectorFactory
from dxtbx.model import GoniometerFactory
from dxtbx.model import ScanFactory
from copy import deepcopy
if self.params.geometry.convert_sweeps_to_stills:
imageset = ImageSet(reader=imageset.reader())
if not isinstance(imageset, ImageSweep):
if self.params.geometry.convert_stills_to_sweeps:
imageset = self.convert_stills_to_sweep(imageset)
if isinstance(imageset, ImageSweep):
beam = BeamFactory.from_phil(
self.params.geometry,
imageset.get_beam())
detector = DetectorFactory.from_phil(
self.params.geometry,
imageset.get_detector(),
beam)
goniometer = GoniometerFactory.from_phil(
self.params.geometry,
imageset.get_goniometer())
scan = ScanFactory.from_phil(
self.params.geometry,
deepcopy(imageset.get_scan()))
i0, i1 = scan.get_array_range()
j0, j1 = imageset.get_scan().get_array_range()
imageset.set_beam(beam)
imageset.set_detector(detector)
imageset.set_goniometer(goniometer)
imageset.set_scan(scan)
else:
for i in range(len(imageset)):
beam = BeamFactory.from_phil(
self.params.geometry,
imageset.get_beam(i))
detector = DetectorFactory.from_phil(
self.params.geometry,
imageset.get_detector(i),
beam)
goniometer = GoniometerFactory.from_phil(
self.params.geometry,
imageset.get_goniometer(i))
scan = ScanFactory.from_phil(
self.params.geometry,
imageset.get_scan(i))
imageset.set_beam(beam, i)
imageset.set_detector(detector, i)
imageset.set_goniometer(goniometer, i)
imageset.set_scan(scan, i)
return imageset
def tst_null_reader_imageset(self):
from dxtbx.imageset import NullReader, ImageSet
from dxtbx.model import Beam, Detector
paths = ['hello_world.cbf']
# Create the null reader
reader = NullReader(paths)
# Create the imageset
imageset = ImageSet(reader)
# Try to get an item
try:
imageset[0]
assert(False)
except Exception:
print 'OK'
# Try to slice the imageset
imageset2 = imageset[0:1]
print 'OK'
# Try some functions which should work
assert(len(imageset) == 1)
assert(imageset == imageset)
assert(imageset.indices() == [0])
assert(imageset.is_valid())
print 'OK'
# Try to get models (expect failure)
try:
imageset.get_image_models(0)
assert(False)
except Exception:
print 'OK'
# Get the image paths
assert(imageset.paths() == paths)
assert(imageset.get_path(0) == paths[0])
print 'OK'
imageset.set_beam(Beam(), 0)
imageset.set_detector(Detector(), 0)
assert(isinstance(imageset.get_beam(0), Beam))
assert(isinstance(imageset.get_detector(0), Detector))
print 'OK'
def pixel_list_to_shoeboxes(
imageset: ImageSet,
pixel_labeller: Iterable[PixelListLabeller],
min_spot_size: int,
max_spot_size: int,
write_hot_pixel_mask: bool,
) -> Tuple[flex.shoebox, Tuple[flex.size_t, ...]]:
"""Convert a pixel list to shoeboxes"""
# Extract the pixel lists into a list of reflections
shoeboxes = flex.shoebox()
spotsizes = flex.size_t()
hotpixels = tuple(flex.size_t()
for i in range(len(imageset.get_detector())))
if isinstance(imageset, ImageSequence):
twod = imageset.get_scan().is_still()
else:
twod = True
for i, (p, hp) in enumerate(zip(pixel_labeller, hotpixels)):
if p.num_pixels() > 0:
creator = flex.PixelListShoeboxCreator(
p,
i, # panel
0, # zrange
twod, # twod
min_spot_size, # min_pixels
max_spot_size, # max_pixels
write_hot_pixel_mask,
)
shoeboxes.extend(creator.result())
spotsizes.extend(creator.spot_size())
hp.extend(creator.hot_pixels())
logger.info("\nExtracted %d spots", len(shoeboxes))
# Get the unallocated spots and print some info
selection = shoeboxes.is_allocated()
shoeboxes = shoeboxes.select(selection)
ntoosmall = (spotsizes < min_spot_size).count(True)
ntoolarge = (spotsizes > max_spot_size).count(True)
assert ntoosmall + ntoolarge == selection.count(False)
logger.info("Removed %d spots with size < %d pixels", ntoosmall,
min_spot_size)
logger.info("Removed %d spots with size > %d pixels", ntoolarge,
max_spot_size)
# Return the shoeboxes
return shoeboxes, hotpixels
class CctbxPsanaEventProcessor(Processor):
""" Processor class for psana events """
def __init__(self, params_filename, output_tag, logfile=None):
"""
@param params_filename cctbx.xfel/DIALS parameter file for processing
@output_tag String that will prefix output files
@logfile File name for logging
"""
self.parsed_params = parse(file_name=params_filename)
dials_params = phil_scope.fetch(self.parsed_params).extract()
super(CctbxPsanaEventProcessor, self).__init__(dials_params,
output_tag)
self.update_geometry = ManualGeometryUpdater(dials_params)
simple_script = SimpleScript(dials_params)
simple_script.load_reference_geometry()
self.reference_detector = getattr(simple_script, 'reference_detector',
None)
self.output_tag = output_tag
self.detector_params = None
if logfile is not None:
log.config(logfile=logfile)
def setup_run(self, run, psana_detector):
""" Initialize processing for a given run
@param run psana Run object
@param psana_detector psana Detector object
"""
if psana_detector.is_cspad():
format_class = FormatXTCCspadSingleEvent
detector_scope = cspad_locator_scope
elif psana_detector.is_epix10ka2m():
format_class = FormatXTCEpixSingleEvent
detector_scope = epix_locator_scope
elif psana_detector.is_jungfrau():
format_class = FormatXTCJungfrauSingleEvent
detector_scope = jungfrau_locator_scope
elif 'rayonix' in psana_detector.name.dev.lower():
format_class = FormatXTCRayonixSingleEvent
detector_scope = rayonix_locator_scope
else:
raise RuntimeError('Unrecognized detector %s' %
psana_detector.name)
detector_params = detector_scope.fetch(self.parsed_params).extract()
self.dxtbx_img = format_class(detector_params, run, psana_detector)
self.imageset = ImageSet(
ImageSetData(MemReader([self.dxtbx_img]), None))
def process_event(self, event, event_tag):
""" Process a single psana event
@param event psana Event object
@param event_tag string identifying the event
"""
experiments = self.experiments_from_event(event)
self.process_experiments('%s_%s' % (self.output_tag, event_tag),
experiments)
def experiments_from_event(self, event):
""" Create an ExperimentList from a psana Event
@param event psana Event object
"""
self.dxtbx_img.event = event
self.imageset.set_beam(self.dxtbx_img.get_beam())
self.imageset.set_detector(self.dxtbx_img.get_detector())
self.update_geometry(self.imageset)
experiments = ExperimentListFactory.from_imageset_and_crystal(
self.imageset, None)
if self.reference_detector is not None:
experiment = experiments[0]
sync_geometry(self.reference_detector.hierarchy(),
self.imageset.get_detector().hierarchy())
experiment.detector = self.imageset.get_detector()
return experiments
