def start_helper(self, version_token): from spotfinder.applications.xfel import cxi_phil from iotbx.detectors.npy import NpyImage import os, copy is_file = isinstance(self._image_file, basestring) and os.path.isfile( self._image_file) if is_file: file_name = self._image_file else: file_name = "inmem" args = [ file_name, version_token, "viewer.powder_arcs.show=False", "viewer.powder_arcs.code=3n9c", ] params = cxi_phil.cxi_versioned_extract(args) horizons_phil = params.persist.commands if is_file: I = NpyImage(file_name) else: print "This is not a file; assume the data are in the defined dictionary format" I = NpyImage(file_name, source_data=self._image_file) I.readHeader(horizons_phil) I.translate_tiles(horizons_phil) # necessary to keep the phil parameters for subsequent calls to get_tile_manager() I.horizons_phil_cache = copy.deepcopy(horizons_phil) self.detectorbase = I
def start_helper(self, version_token): from spotfinder.applications.xfel import cxi_phil from iotbx.detectors.npy import NpyImage import os,copy is_file = isinstance(self._image_file, basestring) and os.path.isfile(self._image_file) if is_file: file_name = self._image_file else: file_name = "inmem" args = [file_name, version_token, "viewer.powder_arcs.show=False", "viewer.powder_arcs.code=3n9c", ] params = cxi_phil.cxi_versioned_extract(args) horizons_phil = params.persist.commands if is_file: I = NpyImage(file_name) else: print "This is not a file; assume the data are in the defined dictionary format" I = NpyImage(file_name, source_data=self._image_file) I.readHeader(horizons_phil) I.translate_tiles(horizons_phil) # necessary to keep the phil parameters for subsequent calls to get_tile_manager() I.horizons_phil_cache = copy.deepcopy(horizons_phil) self.detectorbase = I
def view_raw_image(path, *command_line, **kwargs): args = [path, "viewer.powder_arcs.show=False", "viewer.powder_arcs.code=3n9c", ] horizons_phil = cxi_phil.cxi_versioned_extract( copy.deepcopy(args),list(command_line)) global parameters parameters.horizons_phil = horizons_phil if horizons_phil.viewer.calibrate_pdb.code is not None: from rstbx.viewer.calibration import pdb_code_wrapper pdb_code_wrapper(horizons_phil).display(path) return elif horizons_phil.viewer.calibrate_unitcell.unitcell is not None: from rstbx.viewer.calibration import unit_cell_wrapper unit_cell_wrapper(horizons_phil).display(path) return elif horizons_phil.viewer.calibrate_silver==True: from rstbx.viewer.calibration import sb_wrapper sb_wrapper(horizons_phil).display(path) return wrapper_of_callback().display(path)
def view_raw_image(path, *command_line, **kwargs): args = [path, "viewer.powder_arcs.show=False", "viewer.powder_arcs.code=3n9c", ] horizons_phil = cxi_phil.cxi_versioned_extract( copy.deepcopy(args),list(command_line)) global parameters parameters.horizons_phil = horizons_phil if horizons_phil.viewer.calibrate_pdb.code is not None: from rstbx.viewer.calibration import pdb_code_wrapper pdb_code_wrapper(horizons_phil).display(path) return elif horizons_phil.viewer.calibrate_unitcell.unitcell is not None: from rstbx.viewer.calibration import unit_cell_wrapper unit_cell_wrapper(horizons_phil).display(path) return elif horizons_phil.viewer.calibrate_silver==True: from rstbx.viewer.calibration import sb_wrapper sb_wrapper(horizons_phil).display(path) return wrapper_of_callback().display(path)
def create_trial(self, d_min = 1.5, n_bins = 10, **kwargs): # d_min and n_bins only used if isoforms are in this trial trial = Trial(self, d_min = d_min, **kwargs) if trial.target_phil_str is not None: from iotbx.phil import parse backend = ['labelit', 'dials'][['cxi.xtc_process', 'cctbx.xfel.xtc_process'].index(self.params.dispatcher)] if backend == 'labelit': from spotfinder.applications.xfel import cxi_phil trial_params = cxi_phil.cxi_versioned_extract().persist.phil_scope.fetch(parse(trial.target_phil_str)).extract() isoforms = trial_params.isoforms elif backend == 'dials': from xfel.command_line.xtc_process import phil_scope trial_params = phil_scope.fetch(parse(trial.target_phil_str)).extract() isoforms = trial_params.indexing.stills.isoforms else: assert False if len(isoforms) > 0: for isoform in isoforms: print "Creating isoform", isoform.name db_isoform = Isoform(self, name = isoform.name, trial_id = trial.id) a, b, c, alpha, beta, gamma = isoform.cell.parameters() cell = self.create_cell(cell_a = a, cell_b = b, cell_c = c, cell_alpha = alpha, cell_beta = beta, cell_gamma = gamma, lookup_symbol = isoform.lookup_symbol, isoform_id = db_isoform.id) from cctbx.crystal import symmetry cs = symmetry(unit_cell = isoform.cell,space_group_symbol=str(isoform.lookup_symbol)) mset = cs.build_miller_set(anomalous_flag=False, d_min=d_min) binner = mset.setup_binner(n_bins=n_bins) for i in binner.range_used(): d_max, d_min = binner.bin_d_range(i) Bin(self, number = i, d_min = d_min, d_max = d_max, total_hkl = binner.counts_complete()[i], cell_id = cell.id) elif backend == 'labelit': pass # TODO: labelit target elif backend == 'dials': if trial_params.indexing.known_symmetry.unit_cell is not None and \ trial_params.indexing.known_symmetry.space_group is not None: print "Creating target cell" unit_cell = trial_params.indexing.known_symmetry.unit_cell symbol = str(trial_params.indexing.known_symmetry.space_group) a, b, c, alpha, beta, gamma = unit_cell.parameters() cell = self.create_cell(cell_a = a, cell_b = b, cell_c = c, cell_alpha = alpha, cell_beta = beta, cell_gamma = gamma, lookup_symbol = symbol, trial_id = trial.id) from cctbx.crystal import symmetry cs = symmetry(unit_cell = unit_cell, space_group_symbol = symbol) mset = cs.build_miller_set(anomalous_flag=False, d_min=d_min) binner = mset.setup_binner(n_bins=n_bins) for i in binner.range_used(): d_max, d_min = binner.bin_d_range(i) Bin(self, number = i, d_min = d_min, d_max = d_max, total_hkl = binner.counts_complete()[i], cell_id = cell.id) return trial
def start_helper(self, version_token): is_file = isinstance(self._image_file, six.string_types) and os.path.isfile( self._image_file) if is_file: file_name = self._image_file else: file_name = "inmem" args = [ file_name, version_token, "viewer.powder_arcs.show=False", "viewer.powder_arcs.code=3n9c", ] params = cxi_phil.cxi_versioned_extract(args) horizons_phil = params.persist.commands if is_file: image = NpyImage(file_name) else: print( "This is not a file; assume the data are in the defined dictionary format" ) image = NpyImage(file_name, source_data=self._image_file) image.readHeader(horizons_phil) image.translate_tiles(horizons_phil) # necessary to keep the phil parameters for subsequent calls to get_tile_manager() image.horizons_phil_cache = copy.deepcopy(horizons_phil) self.detectorbase = image
def print_unit_translations(data, params, optional): from scitbx.array_family import flex def pretty_format(data): out = """""" for quad in [0,1,2,3]: for blockof2 in [0,1,2,3]: format = "%3.0f,"*8 if quad==3 and blockof2==3: format = format[0:-1] format = " %s"%format out+=format+""" """ if quad<3: out += """ """ # reality check here in case the PAD is not 64-tiles Nparam = len(data) decoration = out.split("%3.0f,") if len(decoration)>Nparam+1: decoration = decoration[len(decoration)-Nparam:] return "%3.0f,".join(decoration) return out from spotfinder.applications.xfel.cxi_phil import cxi_versioned_extract if params.detector_format_version is not None: base_arguments = ["distl.detector_format_version=%s"%params.detector_format_version] if optional is not None: if optional.distl.quad_translations is not None: base_arguments.append("distl.quad_translations="+",".join([str(s) for s in optional.distl.quad_translations])) if optional.distl.tile_translations is not None: base_arguments.append("distl.tile_translations="+",".join([str(s) for s in optional.distl.tile_translations])) stuff = cxi_versioned_extract(base_arguments) old = flex.double(stuff.distl.tile_translations) print "cctbx already defines unit pixel translations for detector format version %s:"%params.detector_format_version print pretty_format(old)%tuple(old) print "new unit pixel increments will be SUBTRACTED off these to get final translations" print else: print "no pre-existing translations were input" print old = flex.double(128) print "Unit translations to be pasted into spotfinder/applications/xfel/cxi_phil.py:" new = old - flex.double(data) #overall_format = """ working_extract.distl.tile_translations = [ overall_format = '''distl {\n tile_translations = """ '''+pretty_format(new)+''' """}''' print overall_format%tuple(new)
def get_phil_scope(app, task_type): assert task_type in task_types if task_type == "indexing": dispatcher = app.params.dispatcher if dispatcher == 'cxi.xtc_process': #LABELIT from spotfinder.applications.xfel import cxi_phil return cxi_phil.cxi_versioned_extract().persist.phil_scope else: dispatcher = task_dispatchers[task_types.index(task_type)] return dispatcher, load_phil_scope_from_dispatcher(dispatcher)
def integrate_one_image(data): from .display_spots import run_one_index_core from labelit.dptbx.error import NoAutoIndex from libtbx.utils import Sorry path = "strong/" + data[ 'TIMESTAMP'] + "_" + "%05d" % data['SEQUENCE_NUMBER'] + ".pickle" args = [ "indexing.data=dummy", "distl.detector_format_version=CXI 3.2", "force_method2_resolution_limit=2.2", "distl_highres_limit=2.2", "distl.res.outer=2.0", "beam_search_scope=0.5", "target_cell=38,78,78,90,90,90", "lepage_max_delta = 3.0", "spots_pickle = None", "subgroups_pickle = None", "refinements_pickle = None", "rmsd_tolerance = 5.0", "mosflm_rmsd_tolerance = 5.0", "known_setting = 9", "mosaicity_limit=1.0", "indexing.completeness_pickle=%s" % path, "difflimit_sigma_cutoff=2.0", "indexing.verbose_cv=True", #"indexing.open_wx_viewer=True" ] from spotfinder.applications.xfel import cxi_phil horizons_phil = cxi_phil.cxi_versioned_extract(args) horizons_phil.indexing.data = data try: run_one_index_core(horizons_phil) except NoAutoIndex as e: print "NoAutoIndex" print e except Sorry as e: print e except ZeroDivisionError as e: print "ZeroDivisionError" print e except Exception as e: print "ANOTHER exception" print e
def create_trial(self, d_min = 1.5, n_bins = 10, **kwargs): # d_min and n_bins only used if isoforms are in this trial trial = Trial(self, **kwargs) if trial.target_phil_str is not None: from iotbx.phil import parse backend = ['labelit', 'dials'][['cxi.xtc_process', 'cctbx.xfel.xtc_process'].index(self.params.dispatcher)] if backend == 'labelit': from spotfinder.applications.xfel import cxi_phil trial_params = cxi_phil.cxi_versioned_extract().persist.phil_scope.fetch(parse(trial.target_phil_str)).extract() isoforms = trial_params.isoforms elif backend == 'dials': from xfel.command_line.xtc_process import phil_scope trial_params = phil_scope.fetch(parse(trial.target_phil_str)).extract() isoforms = trial_params.indexing.stills.isoforms else: assert False if len(isoforms) > 0: for isoform in isoforms: print "Creating isoform", isoform.name db_isoform = Isoform(self, name = isoform.name, trial_id = trial.id) a, b, c, alpha, beta, gamma = isoform.cell.parameters() cell = self.create_cell(cell_a = a, cell_b = b, cell_c = c, cell_alpha = alpha, cell_beta = beta, cell_gamma = gamma, lookup_symbol = isoform.lookup_symbol, isoform_id = db_isoform.id) from cctbx.crystal import symmetry cs = symmetry(unit_cell = isoform.cell,space_group_symbol=str(isoform.lookup_symbol)) mset = cs.build_miller_set(anomalous_flag=False, d_min=d_min) binner = mset.setup_binner(n_bins=n_bins) for i in binner.range_used(): d_max, d_min = binner.bin_d_range(i) Bin(self, number = i, d_min = d_min, d_max = d_max, total_hkl = binner.counts_complete()[i], cell_id = cell.id) return trial
def run_one(path, *command_line, **kwargs): args = ["distl.image=%s"%path, "distl.res.outer=2.1", "distl.detector_format_version=CXI 5.1", ] horizons_phil = cxi_phil.cxi_versioned_extract( copy.deepcopy(args),list(command_line)) global parameters parameters.horizons_phil = horizons_phil from spotfinder.applications import signal_strength info = signal_strength.run_signal_strength(horizons_phil) if kwargs.get("display",False): work = wrapper_of_callback(info) work.display_with_callback(path)
def run_one(path, *command_line, **kwargs): args = ["distl.image=%s"%path, "distl.res.outer=2.1", "distl.detector_format_version=CXI 5.1", ] horizons_phil = cxi_phil.cxi_versioned_extract( copy.deepcopy(args),list(command_line)) global parameters parameters.horizons_phil = horizons_phil from spotfinder.applications import signal_strength info = signal_strength.run_signal_strength(horizons_phil) if kwargs.get("display",False): work = wrapper_of_callback(info) work.display_with_callback(path)
def integrate_one_image(data): from display_spots import run_one_index_core from labelit.dptbx.error import NoAutoIndex from libtbx.utils import Sorry path = "strong/" + data['TIMESTAMP'] + "_" + "%05d" % data['SEQUENCE_NUMBER'] + ".pickle" args = ["indexing.data=dummy", "distl.detector_format_version=CXI 3.2", "force_method2_resolution_limit=2.2", "distl_highres_limit=2.2", "distl.res.outer=2.0", "beam_search_scope=0.5", "target_cell=38,78,78,90,90,90", "lepage_max_delta = 3.0", "spots_pickle = None", "subgroups_pickle = None", "refinements_pickle = None", "rmsd_tolerance = 5.0", "mosflm_rmsd_tolerance = 5.0", "known_setting = 9", "mosaicity_limit=1.0", "indexing.completeness_pickle=%s"%path, "difflimit_sigma_cutoff=2.0", "indexing.verbose_cv=True", #"indexing.open_wx_viewer=True" ] from spotfinder.applications.xfel import cxi_phil horizons_phil = cxi_phil.cxi_versioned_extract(args) horizons_phil.indexing.data = data try: run_one_index_core(horizons_phil) except NoAutoIndex,e: print "NoAutoIndex" print e
arg=arg ) horizons_phil = horizons_phil.fetch(sources=[command_line_params,]) consume.append(arg) except Sorry,e: pass for item in consume: args.remove(item) if len(args) > 0: raise Sorry("Not all arguments processed") params = horizons_phil.extract() if params.distl.tile_translations is not None and params.distl.quad_translations is not None: return params from spotfinder.applications.xfel.cxi_phil import cxi_versioned_extract args = ["distl.detector_format_version=%s"%params.distl.detector_format_version] versioned_extract = cxi_versioned_extract(args).persist.commands if params.distl.quad_translations is None: params.distl.quad_translations = versioned_extract.distl.quad_translations if params.distl.tile_translations is None: params.distl.tile_translations = versioned_extract.distl.tile_translations return params
if _detector_format_version_dict[version]['start_time'] is None: print "None" else: print evt_timestamp((_detector_format_version_dict[version]['end_time'], 0)) if __name__=='__main__': if len(sys.argv) <= 1: print "Listing of all known detector formats. Use cxi.detector_format_versions <version> to show the quadrant and unit pixel translations for a given format version" print print "Format version Det. address Start time End time" for key in sorted(_detector_format_version_dict): print_version(key) else: from spotfinder.applications.xfel.cxi_phil import cxi_versioned_extract for version in sys.argv[1:]: if version not in _detector_format_version_dict: print "Version %s not found. Did you use quotes?"%version continue print "Showing info for %s detector format version"%version print print "Format version Det. address Start time End time" print_version(version) print phil = cxi_versioned_extract(["distl.detector_format_version=%s"%version]) print "Quad translations:", phil.distl.quad_translations print "Tile translations:", phil.distl.tile_translations
# 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
# 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:
def load_cxi_phil(path, args=[]): import os from labelit.phil_preferences import iotbx_defs, libtbx_defs from iotbx import phil from libtbx.phil.command_line import argument_interpreter from libtbx.utils import Sorry exts = ["", ".params", ".phil"] foundIt = False for ext in exts: if os.path.exists(path + ext): foundIt = True path += ext break if not foundIt: raise Sorry("Target not found: " + path) master_phil = phil.parse(input_string=iotbx_defs + libtbx_defs, process_includes=True) horizons_phil = master_phil.fetch( sources=[phil.parse(file_name=path, process_includes=True)]) argument_interpreter = argument_interpreter(master_phil=master_phil) consume = [] for arg in args: try: command_line_params = argument_interpreter.process(arg=arg) horizons_phil = horizons_phil.fetch(sources=[ command_line_params, ]) consume.append(arg) except Sorry as e: pass for item in consume: args.remove(item) if len(args) > 0: raise Sorry("Not all arguments processed") params = horizons_phil.extract() if params.distl.tile_translations is not None and params.distl.quad_translations is not None: return params from spotfinder.applications.xfel.cxi_phil import cxi_versioned_extract args = [ "distl.detector_format_version=%s" % params.distl.detector_format_version ] versioned_extract = cxi_versioned_extract(args).persist.commands if params.distl.quad_translations is None: params.distl.quad_translations = versioned_extract.distl.quad_translations if params.distl.tile_translations is None: params.distl.tile_translations = versioned_extract.distl.tile_translations return params
consume.append(arg) except Sorry, e: pass for item in consume: args.remove(item) if len(args) > 0: raise Sorry("Not all arguments processed") params = horizons_phil.extract() if params.distl.tile_translations is not None and params.distl.quad_translations is not None: return params from spotfinder.applications.xfel.cxi_phil import cxi_versioned_extract args = [ "distl.detector_format_version=%s" % params.distl.detector_format_version ] versioned_extract = cxi_versioned_extract(args).persist.commands if params.distl.quad_translations is None: params.distl.quad_translations = versioned_extract.distl.quad_translations if params.distl.tile_translations is None: params.distl.tile_translations = versioned_extract.distl.tile_translations return params
img_dict = dpack(active_areas=active_areas, address=address, beam_center_x=beam_center[0] * pixel_size, beam_center_y=beam_center[1] * pixel_size, data=data, distance=params.distance, pixel_size=pixel_size, timestamp=timestamp, wavelength=params.wavelength) img = NpyImage("", source_data=img_dict) args = [ "distl.detector_format_version=%s" % params.detector_format_version ] horizons_phil = cxi_phil.cxi_versioned_extract(args) img.readHeader(horizons_phil) img.translate_tiles(horizons_phil) tm = img.get_tile_manager(horizons_phil) effective_active_areas = tm.effective_tiling_as_flex_int() if annulus: inner = params.distance * math.tan( 2 * math.sinh(params.wavelength / (2 * params.annulus_inner))) / pixel_size outer = params.distance * math.tan( 2 * math.sinh(params.wavelength / (2 * params.annulus_outer))) / pixel_size print "Pixel inner:", inner print "Pixel outer:", outer
if (residx == -1) and ((latxdim == -1) or (latydim == -1) or (latzdim == -1)): raise Exception,"Must provide either diffuse.lattice.resolution or latxdim, latydim, and latzdim." import os # read input file with list of diffraction images and scale factors f = open(ifname,"r") lines = [] for line in f: if ((line.strip()!="") and (line[0] != '.')): lines.append(line) f.close() from spotfinder.applications.xfel import cxi_phil horizons_phil = cxi_phil.cxi_versioned_extract(args) print "indexing..." t0 = clock() # indexing can be slow. would be good to save indexing info and read it back in results = run_one_index_core(horizons_phil) tel = clock()-t0 print "done indexing (",tel," sec)" latsize = latxdim*latydim*latzdim lat = np.zeros(latsize, dtype=np.float32) ct = np.zeros(latsize, dtype=np.float32) #name_of_interest = results.organizer.Files.filenames.FN[0] AI = results.indexing_ai i0=latxdim/2-1
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
if len(sys.argv) <= 1: print( "Listing of all known detector formats. Use cxi.detector_format_versions <version> to show the quadrant and unit pixel translations for a given format version" ) print() print( "Format version Det. address Start time End time" ) for key in sorted(_detector_format_version_dict): print_version(key) else: from spotfinder.applications.xfel.cxi_phil import cxi_versioned_extract for version in sys.argv[1:]: if version not in _detector_format_version_dict: print("Version %s not found. Did you use quotes?" % version) continue print("Showing info for %s detector format version" % version) print() print( "Format version Det. address Start time End time" ) print_version(version) print() phil = cxi_versioned_extract( ["distl.detector_format_version=%s" % version]) print("Quad translations:", phil.distl.quad_translations) print("Tile translations:", phil.distl.tile_translations)
def __init__(self, **kwargs): """The _Format constructor builds a dxtbx Format instance from the supplied keyworded arguments. It should be equivalent to the FormatPYunspecified constructor. """ from copy import deepcopy from dxtbx.model.beam import Beam, beam_factory from dxtbx.model.detector import Detector, detector_factory from dxtbx.model.goniometer import Goniometer, goniometer_factory from dxtbx.model.scan import Scan, scan_factory from spotfinder.applications.xfel import cxi_phil from iotbx.detectors.cspad_detector_formats import detector_format_version # From Format.__init__(). self._goniometer_factory = goniometer_factory self._detector_factory = detector_factory self._beam_factory = beam_factory self._scan_factory = scan_factory # From FormatPYunspecified._start(). Split the keyworded # arguments into a parameter dictionary suitable for # iotbx.detectors.npy.NpyImage and a separate image data object. parameters = dict( BEAM_CENTER_X=kwargs['PIXEL_SIZE'] * kwargs['BEAM_CENTER'][0], BEAM_CENTER_Y=kwargs['PIXEL_SIZE'] * kwargs['BEAM_CENTER'][1], CCD_IMAGE_SATURATION=kwargs['SATURATED_VALUE'], DISTANCE=kwargs['DISTANCE'], OSC_RANGE=0, OSC_START=0, PIXEL_SIZE=kwargs['PIXEL_SIZE'], SATURATED_VALUE=kwargs['SATURATED_VALUE'], SIZE1=kwargs['DATA'].focus()[0], SIZE2=kwargs['DATA'].focus()[1], WAVELENGTH=kwargs['WAVELENGTH']) self.detectorbase = _ImgDict(kwargs['DATA'], parameters) # Attempt to apply tile translations only for detectors that # support it. version_lookup = detector_format_version(kwargs['DETECTOR_ADDRESS'], kwargs['TIME_TUPLE'][0]) if version_lookup is not None: params = cxi_phil.cxi_versioned_extract( "distl.detector_format_version=" + version_lookup) # Necessary to keep the phil parameters for subsequent calls to # get_tile_manager(). horizons_phil = params.persist.commands self.detectorbase.translate_tiles(horizons_phil) self.detectorbase.horizons_phil_cache = deepcopy(horizons_phil) # From Format.setup(). goniometer_instance = self._goniometer() assert (isinstance(goniometer_instance, Goniometer)) self._goniometer_instance = goniometer_instance detector_instance = self._detector() assert (isinstance(detector_instance, Detector)) self._detector_instance = detector_instance beam_instance = self._beam() assert (isinstance(beam_instance, Beam)) self._beam_instance = beam_instance scan_instance = self._scan() assert (isinstance(scan_instance, Scan)) self._scan_instance = scan_instance
def __init__(self, **kwargs): """The _Format constructor builds a dxtbx Format instance from the supplied keyworded arguments. It should be equivalent to the FormatPYunspecified constructor. """ from copy import deepcopy from dxtbx.model.beam import Beam, beam_factory from dxtbx.model.detector import Detector, detector_factory from dxtbx.model.goniometer import Goniometer, goniometer_factory from dxtbx.model.scan import Scan, scan_factory from spotfinder.applications.xfel import cxi_phil from xfel.detector_formats import detector_format_version # From Format.__init__(). self._goniometer_factory = goniometer_factory self._detector_factory = detector_factory self._beam_factory = beam_factory self._scan_factory = scan_factory # From FormatPYunspecified._start(). Split the keyworded # arguments into a parameter dictionary suitable for # iotbx.detectors.npy.NpyImage and a separate image data object. parameters = dict( BEAM_CENTER_X=kwargs['PIXEL_SIZE'] * kwargs['BEAM_CENTER'][0], BEAM_CENTER_Y=kwargs['PIXEL_SIZE'] * kwargs['BEAM_CENTER'][1], CCD_IMAGE_SATURATION=kwargs['SATURATED_VALUE'], DISTANCE=kwargs['DISTANCE'], OSC_RANGE=0, OSC_START=0, PIXEL_SIZE=kwargs['PIXEL_SIZE'], SATURATED_VALUE=kwargs['SATURATED_VALUE'], SIZE1=kwargs['DATA'].focus()[0], SIZE2=kwargs['DATA'].focus()[1], WAVELENGTH=kwargs['WAVELENGTH']) self.detectorbase = _ImgDict(kwargs['DATA'], parameters) # Attempt to apply tile translations only for detectors that # support it. version_lookup = detector_format_version( kwargs['DETECTOR_ADDRESS'], kwargs['TIME_TUPLE'][0]) if version_lookup is not None: params = cxi_phil.cxi_versioned_extract( "distl.detector_format_version=" + version_lookup) # Necessary to keep the phil parameters for subsequent calls to # get_tile_manager(). horizons_phil = params.persist.commands self.detectorbase.translate_tiles(horizons_phil) self.detectorbase.horizons_phil_cache = deepcopy(horizons_phil) # From Format.setup(). goniometer_instance = self._goniometer() assert(isinstance(goniometer_instance, Goniometer)) self._goniometer_instance = goniometer_instance detector_instance = self._detector() assert(isinstance(detector_instance, Detector)) self._detector_instance = detector_instance beam_instance = self._beam() assert(isinstance(beam_instance, Beam)) self._beam_instance = beam_instance scan_instance = self._scan() assert(isinstance(scan_instance, Scan)) self._scan_instance = scan_instance