def _start(self): import os if isinstance(self._image_file, basestring) and os.path.isfile( self._image_file): stream = FormatPYunspecified.open_file(self._image_file, 'rb') import cPickle as pickle data = pickle.load(stream) else: data = self._image_file if not "DETECTOR_ADDRESS" in data: # legacy format; try to guess the address self.LCLS_detector_address = 'CxiDs1-0|Cspad-0' if "DISTANCE" in data and data["DISTANCE"] > 1000: # downstream CS-PAD detector station of CXI instrument self.LCLS_detector_address = 'CxiDsd-0|Cspad-0' else: self.LCLS_detector_address = data["DETECTOR_ADDRESS"] from iotbx.detectors.cspad_detector_formats import reverse_timestamp self._timesec = reverse_timestamp(data["TIMESTAMP"])[0] from iotbx.detectors.cspad_detector_formats import detector_format_version as detector_format_function version_lookup = detector_format_function(self.LCLS_detector_address, self._timesec) self.start_helper(version_token="distl.detector_format_version=%s" % version_lookup)
def distl_filter(self, address, cspad_img, distance, timestamp, wavelength): self.hitfinder_d["DATA"] = cspad_img self.hitfinder_d["DISTANCE"] = distance self.hitfinder_d["TIMESTAMP"] = timestamp self.hitfinder_d["WAVELENGTH"] = wavelength self.hitfinder_d["DETECTOR_ADDRESS"] = address args = ["indexing.data=dummy", "distl.bins.verbose=False", self.asic_filter, ] detector_format_version = detector_format_function( address, reverse_timestamp(timestamp)[0]) args += ["distl.detector_format_version=%s" % detector_format_version] from xfel.phil_preferences import load_cxi_phil horizons_phil = load_cxi_phil(self.m_xtal_target, args) horizons_phil.indexing.data = self.hitfinder_d from xfel.cxi import display_spots display_spots.parameters.horizons_phil = horizons_phil from rstbx.new_horizons.index import pre_indexing_validation,pack_names pre_indexing_validation(horizons_phil) imagefile_arguments = pack_names(horizons_phil) from spotfinder.applications import signal_strength info = signal_strength.run_signal_strength_core(horizons_phil,imagefile_arguments) imgdata = info.Files.images[0].linearintdata active_data = self.get_active_data(info.Files.images[0],horizons_phil) peak_heights = flex.int( [ imgdata[ spot.max_pxl_x(), spot.max_pxl_y() ] for spot in info.S.images[info.frames[0]]["spots_total"] ]) outscale = 256 corrected = peak_heights.as_double() * self.correction outvalue = outscale *(1.0-corrected) outvalue.set_selected(outvalue<0.0,0.) outvalue.set_selected(outvalue>=outscale,int(outscale)-1) outvalue = flex.int(outvalue.as_numpy_array().astype(numpy.int32)) # essentially, select a peak if the peak's ADU value is > 2.5 * the 90-percentile pixel value #work = display_spots.wrapper_of_callback(info) #work.display_with_callback(horizons_phil.indexing.data) return peak_heights,outvalue
def distl_filter(self, address, cspad_img, distance, timestamp, wavelength): self.hitfinder_d["DATA"] = cspad_img self.hitfinder_d["DISTANCE"] = distance self.hitfinder_d["TIMESTAMP"] = timestamp self.hitfinder_d["WAVELENGTH"] = wavelength self.hitfinder_d["DETECTOR_ADDRESS"] = address args = ["indexing.data=dummy", "distl.bins.verbose=False", self.asic_filter, ] detector_format_version = detector_format_function( address, reverse_timestamp(timestamp)[0]) args += ["distl.detector_format_version=%s" % detector_format_version] from xfel.phil_preferences import load_cxi_phil horizons_phil = load_cxi_phil(self.m_xtal_target, args) horizons_phil.indexing.data = self.hitfinder_d from xfel.cxi import display_spots display_spots.parameters.horizons_phil = horizons_phil from rstbx.new_horizons.index import pre_indexing_validation,pack_names pre_indexing_validation(horizons_phil) imagefile_arguments = pack_names(horizons_phil) from spotfinder.applications import signal_strength info = signal_strength.run_signal_strength_core(horizons_phil,imagefile_arguments) imgdata = info.Files.images[0].linearintdata active_data = self.get_active_data(info.Files.images[0],horizons_phil) peak_heights = flex.int( [ imgdata[ spot.max_pxl_x(), spot.max_pxl_y() ] for spot in info.S.images[info.frames[0]]["spots_total"] ]) outscale = 256 corrected = peak_heights.as_double() * self.correction outvalue = outscale *(1.0-corrected) outvalue.set_selected(outvalue<0.0,0.) outvalue.set_selected(outvalue>=outscale,int(outscale)-1) outvalue = flex.int(outvalue.as_numpy_array().astype(numpy.int32)) # essentially, select a peak if the peak's ADU value is > 2.5 * the 90-percentile pixel value #work = display_spots.wrapper_of_callback(info) #work.display_with_callback(horizons_phil.indexing.data) return peak_heights,outvalue
def integrate_one_image(data, **kwargs): from xfel.cxi.display_spots import run_one_index_core from labelit.dptbx.error import NoAutoIndex from libtbx.utils import Sorry from spotfinder.exception import SpotfinderError from labelit.exception import AutoIndexError from iotbx.detectors.cspad_detector_formats import detector_format_version as detector_format_function from iotbx.detectors.cspad_detector_formats import reverse_timestamp basename = kwargs.get("integration_basename") if (basename is None): basename = "" dirname = kwargs.get("integration_dirname") if (dirname is None): dirname = "integration" if (not os.path.isdir(dirname)): import errno try: os.makedirs(dirname) except OSError as exc: if exc.errno==errno.EEXIST: pass path = os.path.join(dirname, basename \ + data['TIMESTAMP'] \ + ("_%05d.pickle" % data['SEQUENCE_NUMBER'])) args = ["indexing.data=dummy", "beam_search_scope=0.5", "lepage_max_delta = 3.0", "spots_pickle = None", "subgroups_pickle = None", "refinements_pickle = None", "rmsd_tolerance = 5.0", "mosflm_rmsd_tolerance = 5.0", "indexing.completeness_pickle=%s"%path, "difflimit_sigma_cutoff=2.0", #"indexing.open_wx_viewer=True" ] detector_format_version = detector_format_function( data['DETECTOR_ADDRESS'], reverse_timestamp(data['TIMESTAMP'])[0]) args += ["distl.detector_format_version=%s" % detector_format_version] from xfel.phil_preferences import load_cxi_phil horizons_phil = load_cxi_phil(data["xtal_target"], args) horizons_phil.indexing.data = data print "XFEL processing: %s"%path try: return run_one_index_core(horizons_phil) except NoAutoIndex,e: print "NoAutoIndex", data['TIMESTAMP'], e info = e.info
def _start(self): import os if isinstance(self._image_file, basestring) and os.path.isfile(self._image_file): stream = FormatPYunspecified.open_file(self._image_file, 'rb') import cPickle as pickle data = pickle.load(stream) else: data = self._image_file if not "DETECTOR_ADDRESS" in data: # legacy format; try to guess the address self.LCLS_detector_address = 'CxiDs1-0|Cspad-0' if "DISTANCE" in data and data["DISTANCE"] > 1000: # downstream CS-PAD detector station of CXI instrument self.LCLS_detector_address = 'CxiDsd-0|Cspad-0' else: self.LCLS_detector_address = data["DETECTOR_ADDRESS"] from iotbx.detectors.cspad_detector_formats import reverse_timestamp self._timesec = reverse_timestamp( data["TIMESTAMP"] )[0] from iotbx.detectors.cspad_detector_formats import detector_format_version as detector_format_function version_lookup = detector_format_function(self.LCLS_detector_address,self._timesec) self.start_helper(version_token="distl.detector_format_version=%s"%version_lookup)
if params.output_file is None: logger = sys.stdout else: logger = open(params.output_file, 'w') logger.write("%s "%params.output_file) if not "DETECTOR_ADDRESS" in source_data: # legacy format; try to guess the address LCLS_detector_address = 'CxiDs1-0|Cspad-0' if "DISTANCE" in source_data and source_data["DISTANCE"] > 1000: # downstream CS-PAD detector station of CXI instrument LCLS_detector_address = 'CxiDsd-0|Cspad-0' else: LCLS_detector_address = source_data["DETECTOR_ADDRESS"] timesec = reverse_timestamp( source_data["TIMESTAMP"] )[0] version_lookup = detector_format_function(LCLS_detector_address,timesec) args = [ "distl.detector_format_version=%s"%version_lookup, "viewer.powder_arcs.show=False", "viewer.powder_arcs.code=3n9c", ] horizons_phil = cxi_phil.cxi_versioned_extract(args).persist.commands img = NpyImage(params.file_path, source_data) img.readHeader(horizons_phil) img.translate_tiles(horizons_phil) if params.verbose: img.show_header() the_tiles = img.get_tile_manager(horizons_phil).effective_tiling_as_flex_int(
else: doplots = False for data in generate_data_from_streams(args, verbose=True): if 'TIMESTAMP' in data: # this is how FormatPYunspecified guesses the address if not "DETECTOR_ADDRESS" in data: # legacy format; try to guess the address LCLS_detector_address = 'CxiDs1-0|Cspad-0' if "DISTANCE" in data and data["DISTANCE"] > 1000: # downstream CS-PAD detector station of CXI instrument LCLS_detector_address = 'CxiDsd-0|Cspad-0' else: LCLS_detector_address = data["DETECTOR_ADDRESS"] detector_format_version = detector_format_function( LCLS_detector_address, reverse_timestamp(data['TIMESTAMP'])[0]) print "Detector format version:", detector_format_version image_pickle = True else: print "Not an image pickle" image_pickle = False keywise_printout(data) if image_pickle: import dxtbx image = dxtbx.load(path) tile_manager = image.detectorbase.get_tile_manager(image.detectorbase.horizons_phil_cache) tiling = tile_manager.effective_tiling_as_flex_int(reapply_peripheral_margin = True) print int(len(tiling)/4), "translated active areas, first one: ", list(tiling[0:4])
def run(args, source_data=None): from xfel import radial_average from scitbx.array_family import flex from iotbx.detectors.cspad_detector_formats import reverse_timestamp from iotbx.detectors.cspad_detector_formats import detector_format_version as detector_format_function from spotfinder.applications.xfel import cxi_phil from iotbx.detectors.npy import NpyImage import os, sys from iotbx.detectors.npy import NpyImage user_phil = [] # TODO: replace this stuff with iotbx.phil.process_command_line_with_files # as soon as I can safely modify it for arg in args: if (not "=" in arg): try: user_phil.append(libtbx.phil.parse("""file_path=%s""" % arg)) except ValueError as e: raise Sorry("Unrecognized argument '%s'" % arg) else: try: user_phil.append(libtbx.phil.parse(arg)) except RuntimeError as e: raise Sorry("Unrecognized argument '%s' (error: %s)" % (arg, str(e))) params = master_phil.fetch(sources=user_phil).extract() if params.file_path is None or not os.path.isfile( params.file_path) and source_data is None: master_phil.show() raise Usage( "file_path must be defined (either file_path=XXX, or the path alone)." ) assert params.handedness is not None assert params.n_bins is not None assert params.verbose is not None assert params.output_bins is not None if source_data is None: from libtbx import easy_pickle source_data = easy_pickle.load(params.file_path) if params.output_file is None: logger = sys.stdout else: logger = open(params.output_file, 'w') logger.write("%s " % params.output_file) if not "DETECTOR_ADDRESS" in source_data: # legacy format; try to guess the address LCLS_detector_address = 'CxiDs1-0|Cspad-0' if "DISTANCE" in source_data and source_data["DISTANCE"] > 1000: # downstream CS-PAD detector station of CXI instrument LCLS_detector_address = 'CxiDsd-0|Cspad-0' else: LCLS_detector_address = source_data["DETECTOR_ADDRESS"] timesec = reverse_timestamp(source_data["TIMESTAMP"])[0] version_lookup = detector_format_function(LCLS_detector_address, timesec) args = [ "distl.detector_format_version=%s" % version_lookup, "viewer.powder_arcs.show=False", "viewer.powder_arcs.code=3n9c", ] horizons_phil = cxi_phil.cxi_versioned_extract(args).persist.commands img = NpyImage(params.file_path, source_data) img.readHeader(horizons_phil) img.translate_tiles(horizons_phil) if params.verbose: img.show_header() the_tiles = img.get_tile_manager( horizons_phil).effective_tiling_as_flex_int( reapply_peripheral_margin=False, encode_inactive_as_zeroes=True) if params.beam_x is None: params.beam_x = img.beamx / img.pixel_size if params.beam_y is None: params.beam_y = img.beamy / img.pixel_size if params.verbose: logger.write("I think the beam center is (%s,%s)\n" % (params.beam_x, params.beam_y)) bc = (int(params.beam_x), int(params.beam_y)) extent = int( math.ceil( max(distance((0, 0), bc), distance((img.size1, 0), bc), distance((0, img.size2), bc), distance((img.size1, img.size2), bc)))) if params.n_bins < extent: params.n_bins = extent extent_in_mm = extent * img.pixel_size extent_two_theta = math.atan(extent_in_mm / img.distance) * 180 / math.pi sums = flex.double(params.n_bins) * 0 sums_sq = flex.double(params.n_bins) * 0 counts = flex.int(params.n_bins) * 0 data = img.get_raw_data() if hasattr(data, "as_double"): data = data.as_double() logger.write("Average intensity: %9.3f\n" % flex.mean(data)) if params.verbose: logger.write("Generating average...tile:") logger.flush() for tile in xrange(len(the_tiles) // 4): if params.verbose: logger.write(" %d" % tile) logger.flush() x1, y1, x2, y2 = get_tile_coords(the_tiles, tile) radial_average(data, bc, sums, sums_sq, counts, img.pixel_size, img.distance, (x1, y1), (x2, y2)) if params.verbose: logger.write(" Finishing...\n") # average, avoiding division by zero results = sums.set_selected(counts <= 0, 0) results /= counts.set_selected(counts <= 0, 1).as_double() # calculte standard devations std_devs = [ math.sqrt((sums_sq[i] - sums[i] * results[i]) / counts[i]) if counts[i] > 0 else 0 for i in xrange(len(sums)) ] xvals = flex.double(len(results)) max_twotheta = float('-inf') max_result = float('-inf') for i in xrange(len(results)): twotheta = i * extent_two_theta / params.n_bins xvals[i] = twotheta if params.output_bins and "%.3f" % results[i] != "nan": #logger.write("%9.3f %9.3f\n"% (twotheta,results[i])) #.xy format for Rex.cell. logger.write( "%9.3f %9.3f %9.3f\n" % (twotheta, results[i], std_devs[i])) #.xye format for GSASII #logger.write("%.3f %.3f %.3f\n"%(twotheta,results[i],ds[i])) # include calculated d spacings if results[i] > max_result: max_twotheta = twotheta max_result = results[i] logger.write( "Maximum 2theta for %s, TS %s: %f, value: %f\n" % (params.file_path, source_data['TIMESTAMP'], max_twotheta, max_result)) if params.verbose: from pylab import scatter, show, xlabel, ylabel, ylim scatter(xvals, results) xlabel("2 theta") ylabel("Avg ADUs") if params.plot_y_max is not None: ylim(0, params.plot_y_max) show() return xvals, results
def event(self, evt, env): """The event() function is called for every L1Accept transition. XXX more? Previously, common-mode correction was applied only after initial threshold filtering. Since the common_mode class applies the (lengthy) common-mode correction immediately after reading the image from the stream, this optimisation is currently not (elegantly) doable. @param evt Event data object, a configure object @param env Environment object """ super(mod_hitfind, self).event(evt, env) if (evt.get("skip_event")): return # This module only applies to detectors for which a distance is # available. distance = cspad_tbx.env_distance(self.address, env, self._detz_offset) if distance is None: self.nfail += 1 self.logger.warning("event(): no distance, shot skipped") evt.put(skip_event_flag(), "skip_event") return device = cspad_tbx.address_split(self.address)[2] # ***** HITFINDING ***** XXX For hitfinding it may be interesting # to look at the fraction of subzero pixels in the dark-corrected # image. if (self.m_threshold is not None): # If a threshold value is given it can be applied in one of three ways: # 1. Apply it over the whole image if (self.m_roi is None and self.m_distl_min_peaks is None): vmax = flex.max(self.cspad_img) if (vmax < self.m_threshold): if not self.m_negate_hits: # Tell downstream modules to skip this event if the threshold was not met. evt.put(skip_event_flag(), "skip_event") return elif self.m_negate_hits: evt.put(skip_event_flag(), "skip_event") return # 2. Apply threshold over a rectangular region of interest. elif (self.m_roi is not None): vmax = flex.max(self.cspad_img[self.m_roi[2]:self.m_roi[3], self.m_roi[0]:self.m_roi[1]]) if (vmax < self.m_threshold): if not self.m_negate_hits: evt.put(skip_event_flag(), "skip_event") return elif self.m_negate_hits: evt.put(skip_event_flag(), "skip_event") return # 3. Determine the spotfinder spots within the central ASICS, and accept the # image as a hit if there are m_distl_min_peaks exceeding m_threshold. # As a further requirement, the peaks must exceed 2.5 * the 90-percentile # pixel value of the central ASICS. This filter was added to avoid high-background # false positives. elif (self.m_distl_min_peaks is not None): if device == 'marccd': self.hitfinder_d['BEAM_CENTER_X'] = self.beam_center[0] self.hitfinder_d['BEAM_CENTER_Y'] = self.beam_center[1] elif device == 'Rayonix': self.hitfinder_d['BEAM_CENTER_X'] = self.beam_center[0] self.hitfinder_d['BEAM_CENTER_Y'] = self.beam_center[1] peak_heights, outvalue = self.distl_filter( self.address, self.cspad_img.iround(), # XXX correct? distance, self.timestamp, self.wavelength) if ('permissive' in self.m_distl_flags): number_of_accepted_peaks = (peak_heights > self.m_threshold).count(True) else: number_of_accepted_peaks = (( peak_heights > self.m_threshold).__and__( outvalue == 0)).count(True) sec, ms = cspad_tbx.evt_time(evt) evt_time = sec + ms / 1000 self.stats_logger.info("BRAGG %.3f %d" % (evt_time, number_of_accepted_peaks)) skip_event = False if number_of_accepted_peaks < self.m_distl_min_peaks: self.logger.info( "Subprocess %02d: Spotfinder NO HIT image #%05d @ %s; %d spots > %d" % (env.subprocess(), self.nshots, self.timestamp, number_of_accepted_peaks, self.m_threshold)) if not self.m_negate_hits: skip_event = True else: self.logger.info( "Subprocess %02d: Spotfinder YES HIT image #%05d @ %s; %d spots > %d" % (env.subprocess(), self.nshots, self.timestamp, number_of_accepted_peaks, self.m_threshold)) if self.m_negate_hits: skip_event = True if skip_event: if self.m_db_logging: # log misses to the database self.queue_entry( (self.trial, evt.run(), "%.3f" % evt_time, number_of_accepted_peaks, distance, self.sifoil, self.wavelength, False, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, self.m_db_tags)) evt.put(skip_event_flag(), "skip_event") return # the indexer will log this hit when it is ran. Bug: if the spotfinder is ran by itself, this # hit will not be logged in the db. evt.put(number_of_accepted_peaks, 'sfspots') self.logger.info("Subprocess %02d: process image #%05d @ %s" % (env.subprocess(), self.nshots, self.timestamp)) # See r17537 of mod_average.py. if device == 'Cspad': pixel_size = cspad_tbx.pixel_size saturated_value = cspad_tbx.cspad_saturated_value elif device == 'marccd': pixel_size = evt.get("marccd_pixel_size") saturated_value = evt.get("marccd_saturated_value") elif device == 'Rayonix': pixel_size = rayonix_tbx.get_rayonix_pixel_size(self.bin_size) saturated_value = rayonix_tbx.rayonix_saturated_value d = cspad_tbx.dpack( active_areas=self.active_areas, address=self.address, beam_center_x=pixel_size * self.beam_center[0], beam_center_y=pixel_size * self.beam_center[1], data=self.cspad_img.iround(), # XXX ouch! distance=distance, pixel_size=pixel_size, saturated_value=saturated_value, timestamp=self.timestamp, wavelength=self.wavelength, xtal_target=self.m_xtal_target) if (self.m_dispatch == "index"): import sys from xfel.cxi.integrate_image_api import integrate_one_image info = integrate_one_image( d, integration_dirname=self.m_integration_dirname, integration_basename=self.m_integration_basename) sys.stdout = sys.__stdout__ sys.stderr = sys.__stderr__ indexed = info is not None and hasattr(info, 'spotfinder_results') if self.m_progress_logging: if self.m_db_version == 'v1': if indexed: # integration pickle dictionary is available here as info.last_saved_best if info.last_saved_best[ "identified_isoform"] is not None: #print info.last_saved_best.keys() from cxi_xdr_xes.cftbx.cspad_ana import db dbobj = db.dbconnect(self.m_db_host, self.m_db_name, self.m_db_user, self.m_db_password) cursor = dbobj.cursor() if info.last_saved_best[ "identified_isoform"] in self.isoforms: PM, indices, miller_id = self.isoforms[ info.last_saved_best["identified_isoform"]] else: from xfel.xpp.progress_support import progress_manager PM = progress_manager(info.last_saved_best, self.m_db_experiment_tag, self.m_trial_id, self.m_rungroup_id, evt.run()) indices, miller_id = PM.get_HKL(cursor) # cache these as they don't change for a given isoform self.isoforms[info.last_saved_best[ "identified_isoform"]] = PM, indices, miller_id if self.m_sql_buffer_size > 1: self.queue_progress_entry( PM.scale_frame_detail(self.timestamp, cursor, do_inserts=False)) else: PM.scale_frame_detail(self.timestamp, cursor, do_inserts=True) dbobj.commit() cursor.close() dbobj.close() elif self.m_db_version == 'v2': key_low = 'cctbx.xfel.radial_average.two_theta_low' key_high = 'cctbx.xfel.radial_average.two_theta_high' tt_low = evt.get(key_low) tt_high = evt.get(key_high) from xfel.ui.db.dxtbx_db import log_frame if indexed: n_spots = len(info.spotfinder_results.images[ info.frames[0]]['spots_total']) else: sfspots = evt.get('sfspots') if sfspots is None: if info is None or not isinstance(info, int): n_spots = 0 else: n_spots = info else: n_spots = sfspots if indexed: known_setting = info.horizons_phil.known_setting indexed_setting = info.organizer.info[ 'best_integration']['counter'] if known_setting is None or known_setting == indexed_setting: from xfel.command_line.frame_unpickler import construct_reflection_table_and_experiment_list c = construct_reflection_table_and_experiment_list( info.last_saved_best, None, pixel_size, proceed_without_image=True) c.assemble_experiments() c.assemble_reflections() log_frame(c.experiment_list, c.reflections, self.db_params, evt.run(), n_spots, self.timestamp, tt_low, tt_high) else: print( "Not logging %s, wrong bravais setting (expecting %d, got %d)" % (self.timestamp, known_setting, indexed_setting)) else: log_frame(None, None, self.db_params, evt.run(), n_spots, self.timestamp, tt_low, tt_high) if self.m_db_logging: sec, ms = cspad_tbx.evt_time(evt) evt_time = sec + ms / 1000 sfspots = evt.get('sfspots') if sfspots is None: if indexed: n_spots = len(info.spotfinder_results.images[ info.frames[0]]['spots_total']) else: n_spots = 0 else: n_spots = sfspots if indexed: mosaic_bloc_rotation = info.last_saved_best.get( 'ML_half_mosaicity_deg', [0])[0] mosaic_block_size = info.last_saved_best.get( 'ML_domain_size_ang', [0])[0] ewald_proximal_volume = info.last_saved_best.get( 'ewald_proximal_volume', [0])[0] obs = info.last_saved_best['observations'][0] cell_a, cell_b, cell_c, cell_alpha, cell_beta, cell_gamma = obs.unit_cell( ).parameters() pointgroup = info.last_saved_best['pointgroup'] resolution = obs.d_min() else: mosaic_bloc_rotation = mosaic_block_size = ewald_proximal_volume = cell_a = cell_b = cell_c = \ cell_alpha = cell_beta = cell_gamma = spacegroup = resolution = 0 self.queue_entry( (self.trial, evt.run(), "%.3f" % evt_time, n_spots, distance, self.sifoil, self.wavelength, indexed, mosaic_bloc_rotation, mosaic_block_size, ewald_proximal_volume, pointgroup, cell_a, cell_b, cell_c, cell_alpha, cell_beta, cell_gamma, resolution, self.m_db_tags)) if (not indexed): evt.put(skip_event_flag(), "skip_event") return elif (self.m_dispatch == "nop"): pass elif (self.m_dispatch == "view"): #interactive image viewer args = ["indexing.data=dummy"] detector_format_version = detector_format_function( self.address, evt.GetTime()) if detector_format_version is not None: args += [ "distl.detector_format_version=%" % detector_format_version ] from xfel.phil_preferences import load_cxi_phil horizons_phil = load_cxi_phil(self.m_xtal_target, args) horizons_phil.indexing.data = d from xfel.cxi import display_spots display_spots.parameters.horizons_phil = horizons_phil display_spots.wrapper_of_callback().display( horizons_phil.indexing.data) elif (self.m_dispatch == "spots"): #interactive spotfinder viewer args = ["indexing.data=dummy"] detector_format_version = detector_format_function( self.address, evt.GetTime()) if detector_format_version is not None: args += [ "distl.detector_format_version=%s" % detector_format_version ] from xfel.phil_preferences import load_cxi_phil horizons_phil = load_cxi_phil(self.m_xtal_target, args) horizons_phil.indexing.data = d from xfel.cxi import display_spots display_spots.parameters.horizons_phil = horizons_phil from rstbx.new_horizons.index import pre_indexing_validation, pack_names pre_indexing_validation(horizons_phil) imagefile_arguments = pack_names(horizons_phil) horizons_phil.persist.show() from spotfinder.applications import signal_strength info = signal_strength.run_signal_strength_core( horizons_phil, imagefile_arguments) work = display_spots.wrapper_of_callback(info) work.display_with_callback(horizons_phil.indexing.data) elif (self.m_dispatch == "write_dict"): self.logger.warning( "event(): deprecated dispatch 'write_dict', use mod_dump instead" ) if (self.m_out_dirname is not None or self.m_out_basename is not None): cspad_tbx.dwritef(d, self.m_out_dirname, self.m_out_basename) # Diagnostic message emitted only when all the processing is done. if (env.subprocess() >= 0): self.logger.info("Subprocess %02d: accepted #%05d @ %s" % (env.subprocess(), self.nshots, self.timestamp)) else: self.logger.info("Accepted #%05d @ %s" % (self.nshots, self.timestamp))
if params.output_file is None: logger = sys.stdout else: logger = open(params.output_file, 'w') logger.write("%s " % params.output_file) if not "DETECTOR_ADDRESS" in source_data: # legacy format; try to guess the address LCLS_detector_address = 'CxiDs1-0|Cspad-0' if "DISTANCE" in source_data and source_data["DISTANCE"] > 1000: # downstream CS-PAD detector station of CXI instrument LCLS_detector_address = 'CxiDsd-0|Cspad-0' else: LCLS_detector_address = source_data["DETECTOR_ADDRESS"] timesec = reverse_timestamp(source_data["TIMESTAMP"])[0] version_lookup = detector_format_function(LCLS_detector_address, timesec) args = [ "distl.detector_format_version=%s" % version_lookup, "viewer.powder_arcs.show=False", "viewer.powder_arcs.code=3n9c", ] horizons_phil = cxi_phil.cxi_versioned_extract(args).persist.commands img = NpyImage(params.file_path, source_data) img.readHeader(horizons_phil) img.translate_tiles(horizons_phil) if params.verbose: img.show_header() the_tiles = img.get_tile_manager(