def main(): from dials.util.options import OptionParser from dials.util.options import flatten_datablocks import libtbx.load_env usage = "%s [options] image_*.cbf" % ( libtbx.env.dispatcher_name) parser = OptionParser( usage=usage, phil=phil_scope, read_datablocks=True, read_datablocks_from_images=True, epilog=help_message) params, options = parser.parse_args(show_diff_phil=True) datablocks = flatten_datablocks(params.input.datablock) if len(datablocks) == 0: parser.print_help() exit() datablock = datablocks[0] imageset = datablock.extract_imagesets()[0] stability_fft(imageset, params)
def run(self): '''Execute the script.''' from dials.array_family import flex from dials.util.options import flatten_datablocks from dials.util.options import flatten_reflections from time import time from dials.util import log from logging import info, debug from libtbx.utils import Sorry start_time = time() # Parse the command line params, options = self.parser.parse_args(show_diff_phil=False) # Configure the logging log.config( params.verbosity, info=params.output.log, debug=params.output.debug_log) from dials.util.version import dials_version info(dials_version()) # Log the diff phil diff_phil = self.parser.diff_phil.as_str() if diff_phil is not '': info('The following parameters have been modified:\n') info(diff_phil) # Ensure we have a data block datablocks = flatten_datablocks(params.input.datablock) reflections = flatten_reflections(params.input.reflections) if len(datablocks) == 0 and len(reflections) == 0: self.parser.print_help() return elif len(datablocks) != len(reflections): raise Sorry("Must have same number of datablocks and reflection tables") # Combine the datablocks and reflections datablock, reflections = combine( datablocks, reflections, params) # Save the reflections to file info('\n' + '-' * 80) reflections.as_pickle(params.output.reflections) info('Saved {0} reflections to {1}'.format( len(reflections), params.output.reflections)) # Save the datablock from dxtbx.datablock import DataBlockDumper info('Saving datablocks to {0}'.format( params.output.datablock)) dump = DataBlockDumper(datablocks) dump.as_file(params.output.datablock) # Print the time info("Time Taken: %f" % (time() - start_time))
def run(args): from dials.util.options import OptionParser from dials.util.options import flatten_datablocks import libtbx.load_env usage = "%s [options] image_*.cbf" % ( libtbx.env.dispatcher_name) parser = OptionParser( usage=usage, phil=phil_scope, read_datablocks=True, read_datablocks_from_images=True, epilog=help_message) params, options = parser.parse_args(show_diff_phil=True) datablocks = flatten_datablocks(params.input.datablock) if len(datablocks) == 0 and len(experiments) == 0 and len(reflections) == 0: parser.print_help() exit() assert(len(datablocks) == 1) datablock = datablocks[0] imagesets = datablock.extract_imagesets() assert(len(imagesets) == 1) imageset = imagesets[0] images = imageset.indices() if params.frames: images = params.frames d_spacings = [] intensities = [] sigmas = [] for indx in images: print 'For frame %d:' % indx d, I, sig = background(imageset, indx, n_bins=params.n_bins) print '%8s %8s %8s' % ('d', 'I', 'sig') for j in range(len(I)): print '%8.3f %8.3f %8.3f' % (d[j], I[j], sig[j]) d_spacings.append(d) intensities.append(I) sigmas.append(sig) if params.plot: from matplotlib import pyplot fig = pyplot.figure() for d, I, sig in zip(d_spacings, intensities, sigmas): ds2 = 1/flex.pow2(d) pyplot.plot(ds2, I) pyplot.show()
def run(args): from dials.util.options import OptionParser from dials.util.options import flatten_datablocks parser = OptionParser( read_datablocks=True, read_datablocks_from_images=True, phil=phil_scope, check_format=True) params, options = parser.parse_args(show_diff_phil=True) datablocks = flatten_datablocks(params.input.datablock) assert len(datablocks) == 1 imagesets = datablocks[0].extract_imagesets() img_count = 0 import time t0 = time.time() for imgset in imagesets: for i in range(len(imgset)): if params.data == 'raw': imgset.get_raw_data(i) else: imgset.get_corrected_data(i) img_count += 1 print "Read %i images" %img_count t1 = time.time() t = t1 - t0 print "Read %i images in %.2fs (%.1f images/s)" %( img_count, t, img_count/t) return
def run(self): from dials.util.command_line import Command from dials.util.options import flatten_datablocks # Parse the command line params, options = self.parser.parse_args(show_diff_phil=True) # Ensure we have a data block datablocks = flatten_datablocks(params.input.datablock) if len(datablocks) == 0: self.parser.print_help() return elif len(datablocks) != 1: raise RuntimeError("only 1 datablock can be processed at a time") if not params.rs_mapper.map_file: raise RuntimeError("Please specify output map file (map_file=)") else: self.map_file = params.rs_mapper.map_file self.datablocks = flatten_datablocks(params.input.datablock) if len(self.datablocks) == 0: self.parser.print_help() return self.reverse_phi = params.rs_mapper.reverse_phi self.grid_size = params.rs_mapper.grid_size self.max_resolution = params.rs_mapper.max_resolution self.grid = flex.double(flex.grid(self.grid_size, self.grid_size, self.grid_size), 0) self.cnts = flex.int(flex.grid(self.grid_size, self.grid_size, self.grid_size), 0) for datablock in self.datablocks: for imageset in datablock.extract_imagesets(): self.process_imageset(imageset) recviewer.normalize_voxels(self.grid, self.cnts) uc = uctbx.unit_cell((self.grid_size, self.grid_size, self.grid_size, 90, 90, 90)) ccp4_map.write_ccp4_map( self.map_file, uc, sgtbx.space_group("P1"), (0, 0, 0), self.grid.all(), self.grid, flex.std_string(["cctbx.miller.fft_map"]), )
def run(args): import libtbx.load_env from libtbx.utils import Sorry from dials.util import log usage = "%s [options] datablock.json strong.pickle" %libtbx.env.dispatcher_name parser = OptionParser( usage=usage, phil=phil_scope, read_datablocks=True, read_reflections=True, check_format=False, epilog=help_message) params, options = parser.parse_args(show_diff_phil=False) datablocks = flatten_datablocks(params.input.datablock) reflections = flatten_reflections(params.input.reflections) if len(datablocks) == 0 or len(reflections) == 0: parser.print_help() exit(0) # Configure the logging log.config( info=params.output.log, debug=params.output.debug_log) # Log the diff phil diff_phil = parser.diff_phil.as_str() if diff_phil is not '': info('The following parameters have been modified:\n') info(diff_phil) imagesets = [] for datablock in datablocks: imagesets.extend(datablock.extract_imagesets()) assert len(imagesets) > 0 assert len(reflections) == len(imagesets) if params.scan_range is not None and len(params.scan_range) > 0: reflections = [ filter_reflections_by_scan_range(refl, params.scan_range) for refl in reflections] dps_params = dps_phil_scope.extract() # for development, we want an exhaustive plot of beam probability map: dps_params.indexing.plot_search_scope = params.plot_search_scope dps_params.indexing.mm_search_scope = params.mm_search_scope new_detector, new_beam = discover_better_experimental_model( imagesets, reflections, params, dps_params, nproc=params.nproc, wide_search_binning=params.wide_search_binning) for imageset in imagesets: imageset.set_detector(new_detector) imageset.set_beam(new_beam) from dxtbx.serialize import dump dump.datablock(datablock, params.output.datablock)
def run(args): from dials.util.options import OptionParser from dials.util.options import flatten_datablocks from dials.util.options import flatten_experiments import libtbx.load_env usage = "%s [options] datablock.json" %( libtbx.env.dispatcher_name) parser = OptionParser( usage=usage, phil=phil_scope, read_datablocks=True, read_experiments=True, check_format=True, epilog=help_message) params, options = parser.parse_args(show_diff_phil=True) datablocks = flatten_datablocks(params.input.datablock) experiments = flatten_experiments(params.input.experiments) if (len(datablocks) == 0 and len(experiments) == 0): parser.print_help() exit(0) if len(datablocks) == 0 and len(experiments) > 0: imagesets = experiments.imagesets() else: imagesets = [] for datablock in datablocks: imagesets.extend(datablock.extract_imagesets()) assert len(imagesets) == 1 imageset = imagesets[0] gonio = imageset.get_goniometer() if not params.detector_distance: detector = imageset.get_detector() if len(detector) > 1: params.detector_distance = detector.hierarchy().get_directed_distance() else: params.detector_distance = detector[0].get_directed_distance() if params.angle: assert len(params.angle) == len(gonio.get_angles()) else: for angle in gonio.get_angles(): params.angle.append(angle) import wxtbx.app a = wxtbx.app.CCTBXApp(0) a.settings = params f = ExperimentViewer( None, -1, "Experiment viewer", size=(1024,768)) f.load_imageset(imageset) f.Show() a.SetTopWindow(f) #a.Bind(wx.EVT_WINDOW_DESTROY, lambda evt: tb_icon.Destroy(), f) a.MainLoop()
def run(args): from dials.util.options import OptionParser from dials.util.options import flatten_datablocks from dials.util.options import flatten_experiments from dials.util.options import flatten_reflections parser = OptionParser( phil=master_phil, read_datablocks=True, read_experiments=True, read_reflections=True, check_format=False) params, options = parser.parse_args(show_diff_phil=True) datablocks = flatten_datablocks(params.input.datablock) experiments = flatten_experiments(params.input.experiments) reflections = flatten_reflections(params.input.reflections)[0] if len(params.input.reflections) == 2: reflections2 = flatten_reflections(params.input.reflections)[1] else: reflections2 = None # find the reflections in the second set that DO NOT match those in the # first set mask, _ = reflections2.match_with_reference(reflections) reflections2 = reflections2.select(~mask) print "{0} reflections from the second set do not match the first". \ format(len(reflections2)) #reflections2 = reflections2.select(reflections2["miller_index"] == (-7,2,-25)) if len(datablocks) == 0: if len(experiments) > 0: imagesets = experiments.imagesets() else: parser.print_help() return elif len(datablocks) > 1: raise Sorry("Only one DataBlock can be processed at a time") else: imagesets = datablocks[0].extract_imagesets() if len(imagesets) > 1: raise Sorry("Only one ImageSet can be processed at a time") imageset = imagesets[0] import wxtbx.app a = wxtbx.app.CCTBXApp(0) a.settings = params f = PredRelpViewer( None, -1, "Prediction reciprocal lattice viewer", size=(1024,768)) f.load_reflections2(reflections2) f.load_models(imageset, reflections) f.Show() a.SetTopWindow(f) #a.Bind(wx.EVT_WINDOW_DESTROY, lambda evt: tb_icon.Destroy(), f) a.MainLoop()
def run(args): import libtbx.load_env from libtbx.utils import Sorry from dials.util import log from logging import info import cPickle as pickle usage = "%s [options] datablock.json strong.pickle" % \ libtbx.env.dispatcher_name # Create the option parser parser = OptionParser( usage=usage, phil=phil_scope, read_reflections=True, read_datablocks=True, check_format=False, epilog=help_message) # Get the parameters params, options = parser.parse_args(show_diff_phil=False) # Configure the log log.config( params.verbosity, info='dials.find_hot_pixels.log', debug='dials.find_hot_pixels.debug.log') # Log the diff phil diff_phil = parser.diff_phil.as_str() if diff_phil is not '': info('The following parameters have been modified:\n') info(diff_phil) datablocks = flatten_datablocks(params.input.datablock) reflections = flatten_reflections(params.input.reflections) if len(datablocks) == 0 and len(reflections) == 0: parser.print_help() exit(0) if len(datablocks) > 1: raise Sorry("Only one DataBlock can be processed at a time") else: imagesets = datablocks[0].extract_imagesets() if len(reflections) == 0: raise Sorry("No reflection lists found in input") if len(reflections) > 1: raise Sorry("Multiple reflections lists provided in input") assert(len(reflections) == 1) reflections = reflections[0] mask = hot_pixel_mask(imagesets[0], reflections) pickle.dump(mask, open(params.output.mask, 'w'), pickle.HIGHEST_PROTOCOL) print 'Wrote hot pixel mask to %s' % params.output.mask return
def run(args): from dials.util.options import OptionParser from dials.util.options import flatten_datablocks from dials.util.options import flatten_experiments from dials.util.options import flatten_reflections import libtbx.load_env usage = "%s [options] datablock.json reflections.pickle" %( libtbx.env.dispatcher_name) parser = OptionParser( usage=usage, phil=phil_scope, read_datablocks=True, read_experiments=True, read_reflections=True, check_format=False, epilog=help_message) params, options = parser.parse_args(show_diff_phil=True) datablocks = flatten_datablocks(params.input.datablock) experiments = flatten_experiments(params.input.experiments) reflections = flatten_reflections(params.input.reflections) if (len(datablocks) == 0 and len(experiments) == 0) or len(reflections) == 0: parser.print_help() exit(0) if len(datablocks) == 0 and len(experiments) > 0: imagesets = experiments.imagesets() else: imagesets = [] for datablock in datablocks: imagesets.extend(datablock.extract_imagesets()) if len(reflections) > 1: assert len(reflections) == len(imagesets) from scitbx.array_family import flex for i in range(len(reflections)): reflections[i]['imageset_id'] = flex.int(len(reflections[i]), i) if i > 0: reflections[0].extend(reflections[i]) reflections = reflections[0] import wxtbx.app a = wxtbx.app.CCTBXApp(0) a.settings = params f = ReciprocalLatticeViewer( None, -1, "Reflection data viewer", size=(1024,768)) f.load_models(imagesets, reflections) f.Show() a.SetTopWindow(f) #a.Bind(wx.EVT_WINDOW_DESTROY, lambda evt: tb_icon.Destroy(), f) a.MainLoop()
def run(args): from dials.util.options import OptionParser from dials.util.options import flatten_datablocks from dials.util.options import flatten_experiments from dials.util.options import flatten_reflections from dials.util import log usage = "%s [options] datablock.json reflections.pickle" %( libtbx.env.dispatcher_name) parser = OptionParser( usage=usage, phil=phil_scope, read_datablocks=True, read_experiments=True, read_reflections=True, check_format=False, epilog=help_message) params, options = parser.parse_args() datablocks = flatten_datablocks(params.input.datablock) experiments = flatten_experiments(params.input.experiments) reflections = flatten_reflections(params.input.reflections) if (len(datablocks) == 0 and len(experiments) == 0) or len(reflections) == 0: parser.print_help() exit(0) ## Configure the logging #log.config(info='dials.rl_png.log') # Log the diff phil diff_phil = parser.diff_phil.as_str() if diff_phil is not '': logger.info('The following parameters have been modified:\n') logger.info(diff_phil) reflections = reflections[0] if len(datablocks) == 0 and len(experiments) > 0: imagesets = experiments.imagesets() else: imagesets = [] for datablock in datablocks: imagesets.extend(datablock.extract_imagesets()) f = ReciprocalLatticeJson(settings=params) f.load_models(imagesets, reflections) f.as_json(filename=params.output.json, compact=params.output.compact) print
def run(args): from dials.util.options import OptionParser from dials.util.options import flatten_datablocks from dials.util.options import flatten_experiments import libtbx.load_env usage = "%s [options] datablock.json | experiments.json" %( libtbx.env.dispatcher_name) parser = OptionParser( usage=usage, phil=phil_scope, read_datablocks=True, read_experiments=True, check_format=False, epilog=help_message) params, options = parser.parse_args(show_diff_phil=True) experiments = flatten_experiments(params.input.experiments) datablocks = flatten_datablocks(params.input.datablock) if len(experiments) == 0 and len(datablocks) == 0: parser.print_help() exit(0) from dials.command_line.dials_import import ManualGeometryUpdater update_geometry = ManualGeometryUpdater(params) if len(experiments): imagesets = experiments.imagesets() elif len(datablocks): assert len(datablocks) == 1 imagesets = datablocks[0].extract_imageset() for imageset in imagesets: imageset_new = update_geometry(imageset) imageset.set_detector(imageset_new.get_detector()) imageset.set_beam(imageset_new.get_beam()) imageset.set_goniometer(imageset_new.get_goniometer()) imageset.set_scan(imageset_new.get_scan()) from dxtbx.serialize import dump if len(experiments): print "Saving modified experiments to %s" %params.output.experiments dump.experiment_list(experiments, params.output.experiments) elif len(datablocks): raise NotImplemented
def run(self): params, options = self.parser.parse_args(show_diff_phil=True) datablocks = flatten_datablocks(params.input.datablock) experiments = flatten_experiments(params.input.experiments) reflections = flatten_reflections(params.input.reflections) if len(reflections) > 0: reflections = reflections[0] else: reflections = None all_detectors = [] for db in datablocks: all_detectors.extend(db.unique_detectors()) all_detectors.extend(experiments.detectors()) display_detectors(all_detectors[: min(len(all_detectors), 10)], reflections=reflections)
def run(self): ''' Parse the options. ''' from dxtbx.datablock import DataBlockFactory from dxtbx.datablock import DataBlockTemplateImporter from dials.util.options import flatten_datablocks from dials.util import log from logging import info, debug import cPickle as pickle from libtbx.utils import Sorry # Parse the command line arguments params, options = self.parser.parse_args(show_diff_phil=False) datablocks = flatten_datablocks(params.input.datablock) # Configure logging log.config( params.verbosity, info=params.output.log, debug=params.output.debug_log) from dials.util.version import dials_version info(dials_version()) # Log the diff phil diff_phil = self.parser.diff_phil.as_str() if diff_phil is not '': info('The following parameters have been modified:\n') info(diff_phil) # Load reference geometry reference_detector = None reference_beam = None if params.input.reference_geometry is not None: from dxtbx.serialize import load try: experiments = load.experiment_list( params.input.reference_geometry, check_format=False) assert len(experiments.detectors()) == 1 assert len(experiments.beams()) == 1 reference_detector = experiments.detectors()[0] reference_beam = experiments.beams()[0] except Exception, e: datablock = load.datablock(params.input.reference_geometry) assert len(datablock) == 1 imageset = datablock[0].extract_imagesets()[0] reference_detector = imageset.get_detector() reference_beam = imageset.get_beam()
def run(args): import libtbx.load_env usage = """\ %s datablock.json reflections.pickle [options]""" %libtbx.env.dispatcher_name from dials.util.options import OptionParser from dials.util.options import flatten_datablocks from dials.util.options import flatten_experiments from dials.util.options import flatten_reflections from scitbx.array_family import flex from scitbx import matrix from libtbx.phil import command_line from libtbx.utils import Sorry parser = OptionParser( usage=usage, phil=master_phil_scope, read_datablocks=True, read_experiments=True, read_reflections=True, check_format=False) params, options = parser.parse_args(show_diff_phil=True) datablocks = flatten_datablocks(params.input.datablock) reflections = flatten_reflections(params.input.reflections) experiments = flatten_experiments(params.input.experiments) if len(datablocks) == 1: imageset = datablocks[0].extract_imagesets()[0] elif len(datablocks) > 1: raise Sorry("Only one DataBlock can be processed at a time") elif len(experiments.imagesets()) > 0: imageset = experiments.imagesets()[0] imageset.set_detector(experiments[0].detector) imageset.set_beam(experiments[0].beam) imageset.set_goniometer(experiments[0].goniometer) else: parser.print_help() return detector = imageset.get_detector() scan = imageset.get_scan() panel_origin_shifts = {0: (0,0,0)} try: hierarchy = detector.hierarchy() except AttributeError, e: hierarchy = None
def __call__(self): ''' Import the datablocks ''' from dxtbx.datablock import DataBlockTemplateImporter from dxtbx.datablock import DataBlockFactory from dials.util.options import flatten_datablocks from libtbx.utils import Sorry # Get the datablocks datablocks = flatten_datablocks(self.params.input.datablock) # Check we have some filenames if len(datablocks) == 0: format_kwargs = { 'dynamic_shadowing' : self.params.format.dynamic_shadowing } # Check if a template has been set and print help if not, otherwise try to # import the images based on the template input if len(self.params.input.template) > 0: importer = DataBlockTemplateImporter( self.params.input.template, max(self.params.verbosity-1, 0), format_kwargs=format_kwargs) datablocks = importer.datablocks if len(datablocks) == 0: raise Sorry('No datablocks found matching template %s' % self.params.input.template) elif len(self.params.input.directory) > 0: datablocks = DataBlockFactory.from_filenames( self.params.input.directory, max(self.params.verbosity-1, 0), format_kwargs=format_kwargs) if len(datablocks) == 0: raise Sorry('No datablocks found in directories %s' % self.params.input.directory) else: raise Sorry('No datablocks found') if len(datablocks) > 1: raise Sorry("More than 1 datablock found") # Return the datablocks return datablocks[0]
def run(args): import libtbx.load_env from libtbx.utils import Sorry usage = "%s [options] datablock.json" %libtbx.env.dispatcher_name parser = OptionParser( usage=usage, phil=phil_scope, read_datablocks=True, check_format=True, read_datablocks_from_images=True, epilog=help_message) params, options = parser.parse_args(show_diff_phil=False) ## Configure the logging #log.config( #params.verbosity, info='dials.estimate_gain.log', debug='dials.estimate_gain.debug.log') # Log the diff phil diff_phil = parser.diff_phil.as_str() if diff_phil is not '': print 'The following parameters have been modified:\n' print diff_phil datablocks = flatten_datablocks(params.input.datablock) if len(datablocks) == 0: parser.print_help() return elif len(datablocks) > 1: raise Sorry("Only one DataBlock can be processed at a time") else: imagesets = [] for datablock in datablocks: imagesets.extend(datablock.extract_imagesets()) assert len(imagesets) == 1 imageset = imagesets[0] estimate_gain(imageset, params.kernel_size, params.output.gain_map) return
def run(args): from dials.util.options import OptionParser from dials.util.options import flatten_datablocks import libtbx.load_env usage = "%s [options] datablock.json" % ( libtbx.env.dispatcher_name) parser = OptionParser( usage=usage, phil=phil_scope, read_datablocks=True, read_datablocks_from_images=True, epilog=help_message) params, options = parser.parse_args(show_diff_phil=True) datablocks = flatten_datablocks(params.input.datablock) if len(datablocks) == 0: parser.print_help() exit() assert(len(datablocks) == 1) datablock = datablocks[0] imagesets = datablock.extract_imagesets() assert(len(imagesets) == 1) imageset = imagesets[0] images = params.image for j, img_a in enumerate(images[:-1]): for img_b in images[j+1:]: a = imageset.get_raw_data(img_a)[0] b = imageset.get_raw_data(img_b)[0] n, cc = image_correlation(a, b) print '%5d %5d %7d %.4f' % (img_a, img_b, n, cc)
def run(args): from dials.util.options import OptionParser from dials.util.options import flatten_datablocks from dials.util.options import flatten_experiments from dials.util.options import flatten_reflections import libtbx.load_env usage = "%s [options] datablock.json reflections.pickle" %( libtbx.env.dispatcher_name) parser = OptionParser( usage=usage, phil=phil_scope, read_datablocks=True, read_experiments=True, read_reflections=True, check_format=False, epilog=help_message) params, options = parser.parse_args(show_diff_phil=True) datablocks = flatten_datablocks(params.input.datablock) experiments = flatten_experiments(params.input.experiments) reflections = flatten_reflections(params.input.reflections) if (len(datablocks) == 0 and len(experiments) == 0) or len(reflections) == 0: parser.print_help() exit(0) reflections = reflections[0] if len(datablocks) == 0 and len(experiments) > 0: imagesets = experiments.imagesets() else: imagesets = [] for datablock in datablocks: imagesets.extend(datablock.extract_imagesets()) spot_resolution_shells(imagesets, reflections, params)
def run(self): ''' Run the script. ''' from dials.util.options import flatten_datablocks from dxtbx.datablock import DataBlockDumper from libtbx.utils import Sorry import cPickle as pickle # Parse the command line arguments params, options = self.parser.parse_args(show_diff_phil=True) datablocks = flatten_datablocks(params.input.datablock) # Check number of args if len(datablocks) == 0: self.parser.print_help() return # Check the mask file is given if params.input.mask is None: self.parser.print_help() return # Check nbumber of datablocks if len(datablocks) != 1: raise Sorry('exactly 1 datablock must be specified') # Get the imageset datablock = datablocks[0] imagesets = datablock.extract_imagesets() if len(imagesets) != 1: raise Sorry('datablock must contain exactly 1 imageset') imageset = imagesets[0] # Set the lookup imageset.external_lookup.mask.filename = params.input.mask # Dump the datablock print "Writing datablock to %s" % params.output.datablock dump = DataBlockDumper(datablock) dump.as_json(filename=params.output.datablock)
def run(self): # load at least two detectors from the command line params, options = self.parser.parse_args(show_diff_phil=True) datablocks = flatten_datablocks(params.input.datablock) experiments = flatten_experiments(params.input.experiments) # collect all detectors found all_detectors = [] for db in datablocks: all_detectors.extend(db.unique_detectors()) all_detectors.extend(experiments.detectors()) assert len(all_detectors) >= 2 a = all_detectors[0] b = all_detectors[1] level = 0 pga = a.hierarchy() pgb = b.hierarchy() while True: # starting at the top of the hierarchy, show diffs in local origins at each level print "Level", level oa = col(pga.get_local_origin()) ob = col(pgb.get_local_origin()) print " Detector a", oa.elems print " Detector b", ob.elems print " Diffs", (ob-oa).elems if hasattr(pga, 'children'): pga = pga[0] pgb = pgb[0] level += 1 else: break
def open_viewer(self, filename): import wx from dials.util.options import OptionParser from dials.util.options import flatten_datablocks import libtbx.load_env parser = OptionParser( phil=phil_scope, read_datablocks=True, read_experiments=True, read_reflections=True, read_datablocks_from_images=True) params, options = parser.parse_args(args=[filename]) datablocks = flatten_datablocks(params.input.datablock) imagesets = datablocks[0].extract_imagesets() self.runner = iv.Script( params=params.image_viewer, reflections=[], imagesets=imagesets, crystals=None) # Run the script self.thread = threading.Thread(target=self.runner) self.thread.start()
def run(args): from dials.util.options import OptionParser from dials.util.options import flatten_datablocks import libtbx.load_env usage = "%s [options] datablock.json reference=reference_datablock.json" %( libtbx.env.dispatcher_name) parser = OptionParser( usage=usage, phil=phil_scope, read_datablocks=True, check_format=False, epilog=help_message) params, options = parser.parse_args(show_diff_phil=True) datablocks = flatten_datablocks(params.input.datablock) if len(datablocks) == 0: parser.print_help() exit() # Load reference geometry reference_detector = None if params.input.reference is not None: from dxtbx.serialize import load try: reference_experiments = load.experiment_list( params.input.reference, check_format=False) assert len(reference_experiments.detectors()) == 1 reference_detector = reference_experiments.detectors()[0] except Exception, e: reference_datablocks = load.datablock(params.input.reference) assert len(reference_datablocks) == 1 imageset = reference_datablocks[0].extract_imagesets()[0] reference_detector = imageset.get_detector()
def run(): import sys import libtbx.load_env from dials.util.options import OptionParser from dials.util.options import flatten_datablocks usage = "%s [options] image_*.cbf" %libtbx.env.dispatcher_name parser = OptionParser( usage=usage, phil=phil_scope, read_datablocks=True, read_datablocks_from_images=True, epilog=help_message ) params, options, args = parser.parse_args( show_diff_phil=True, return_unhandled=True) n_images = params.merge_n_images out_prefix = params.output.image_prefix datablocks = flatten_datablocks(params.input.datablock) if len(datablocks) == 0: parser.print_help() return if len(datablocks) > 1: raise Sorry("Only one DataBlock can be processed at a time") else: imagesets = datablocks[0].extract_imagesets() assert len(imagesets) == 1 imageset = imagesets[0] merge_cbf(imageset, n_images, out_prefix=out_prefix)
def run(self): """Parse the options.""" from dials.util.options import flatten_experiments, flatten_datablocks # Parse the command line arguments params, options = self.parser.parse_args(show_diff_phil=True) experiments = flatten_experiments(params.input.experiments) datablocks = flatten_datablocks(params.input.datablock) # Verify inputs if len(experiments) == 0 and len(datablocks) == 0: print("No experiments found") return if len(experiments) > 0 and len(datablocks) > 0: print("Please analyze only one datablock or experiment list") return # Find the detector of interest if len(experiments) > 0: print( "Found %d experiments, doing analysis on experiment 0" % len(experiments) ) detector = experiments[0].detector else: print( "Found %d datablocks, doing analysis on datablock 0" % len(datablocks) ) detector = datablocks[0].unique_detectors()[0] # Build a list of all 2x1 sensors in the detector sensors = [] def recursive_find_sensors(group): if len(group) == 2: # Verify the children of this group are Panels, not PanelGroups assert [not hasattr(child, "children") for child in group].count( False ) == 0 sensors.append(group) else: for child in group: recursive_find_sensors(child) recursive_find_sensors(detector.hierarchy()) print("Found %d 2x1 sensors" % len(sensors)) pixel_gaps = flex.double() bottom_gaps = flex.double() angles = flex.double() sensor_angles = flex.double() for sensor in sensors: a = sensor[0] b = sensor[1] # Get initial vectors center_a = col(a.get_local_origin()) center_b = col(b.get_local_origin()) pixel_size_a = a.get_pixel_size()[0] pixel_size_b = b.get_pixel_size()[0] assert pixel_size_a == pixel_size_b pixel_size = pixel_size_a width_a = a.get_image_size()[0] width_b = b.get_image_size()[0] assert width_a == width_b width = width_a * pixel_size # Calculate statistics pixel_gaps.append( (abs((center_a - center_b).dot(col((1, 0, 0)))) - width) / pixel_size ) bottom_gaps.append( ((center_a - center_b).dot(col((0, 1, 0))) - 0) / pixel_size ) slow_a = col(a.get_slow_axis()) slow_b = col(b.get_slow_axis()) angle = slow_a.angle(slow_b, deg=True) if slow_a.cross(slow_b)[1] < 0: angle = -angle angles.append(angle) a_to_b = center_b - center_a angle = a_to_b.angle(col((1, 0, 0)), deg=True) if a_to_b.cross(col((1, 0, 0)))[1] < 0: angle = -angle sensor_angles.append(angle) pg_stats = flex.mean_and_variance(pixel_gaps) bg_stats = flex.mean_and_variance(bottom_gaps) an_stats = flex.mean_and_variance(angles) sa_stats = flex.mean_and_variance(sensor_angles) for x in xrange(len(pixel_gaps)): print( "%2d. Px gap: %5.3f vertical: %6.3f asic_angle: %6.3f sensor_angle: %6.3f" % (x, pixel_gaps[x], bottom_gaps[x], angles[x], sensor_angles[x]) ) print("Sensor stats (means and standard deviations)") print( "3 pixel gap : %f, %f" % (pg_stats.mean(), pg_stats.unweighted_sample_standard_deviation()) ) print( "Vertical offset : %f, %f" % (bg_stats.mean(), bg_stats.unweighted_sample_standard_deviation()) ) print( "Angular deviations (between asics) : %f, %f" % (an_stats.mean(), an_stats.unweighted_sample_standard_deviation()) ) print( "Angular deviations (sensor) : %f, %f" % (sa_stats.mean(), sa_stats.unweighted_sample_standard_deviation()) )
def run(args): from dials.util.options import OptionParser from dials.util.options import flatten_datablocks from dials.util.options import flatten_experiments import libtbx.load_env usage = "%s [options] datablock.json" %( libtbx.env.dispatcher_name) import os if 'DIALS_EXPORT_DO_NOT_CHECK_FORMAT' in os.environ: parser = OptionParser( usage=usage, phil=phil_scope, read_datablocks=True, read_experiments=True, check_format=False, epilog=help_message) else: parser = OptionParser( usage=usage, phil=phil_scope, read_datablocks=True, read_experiments=True, check_format=True, epilog=help_message) params, options = parser.parse_args(show_diff_phil=True) datablocks = flatten_datablocks(params.input.datablock) experiments = flatten_experiments(params.input.experiments) if (len(datablocks) == 0 and len(experiments) == 0): parser.print_help() exit(0) if len(datablocks) == 0 and len(experiments) > 0: imagesets = experiments.imagesets() crystal = experiments[0].crystal else: imagesets = [] crystal = None for datablock in datablocks: imagesets.extend(datablock.extract_imagesets()) assert len(imagesets) == 1, len(imagesets) imageset = imagesets[0] gonio = imageset.get_goniometer() if not params.detector_distance: detector = imageset.get_detector() if len(detector) > 1: params.detector_distance = detector.hierarchy().get_directed_distance() else: params.detector_distance = detector[0].get_directed_distance() if gonio is not None and not isinstance(gonio, MultiAxisGoniometer): from dxtbx.model.goniometer import GoniometerFactory gonio = GoniometerFactory.multi_axis( axes=flex.vec3_double((gonio.get_rotation_axis(),)), angles=flex.double((0,)), names=flex.std_string(('GON_OMEGA',)), scan_axis=0) imageset.set_goniometer(gonio) if isinstance(gonio, MultiAxisGoniometer): if params.angle: assert len(params.angle) == len(gonio.get_angles()) else: for angle in gonio.get_angles(): params.angle.append(angle) import wxtbx.app a = wxtbx.app.CCTBXApp(0) a.settings = params f = ExperimentViewer( None, -1, "Experiment viewer", size=(1024,768)) f.load_imageset(imageset, crystal=crystal) f.Show() a.SetTopWindow(f) a.MainLoop()
from dials.util.options import flatten_datablocks from dials.util.options import flatten_experiments from dials.util.options import flatten_reflections import libtbx.load_env usage_message = """ %s datablock.json [reflections.pickle] """ % libtbx.env.dispatcher_name parser = OptionParser(usage=usage_message, phil=phil_scope, read_datablocks=True, read_experiments=True, read_reflections=True, read_datablocks_from_images=True, epilog=help_message) params, options = parser.parse_args(show_diff_phil=True) datablocks = flatten_datablocks(params.input.datablock) experiments = flatten_experiments(params.input.experiments) reflections = flatten_reflections(params.input.reflections) if len(datablocks) == 0 and len(experiments) == 0: parser.print_help() exit(0) if len(datablocks) > 0: assert len(datablocks) == 1 datablock = datablocks[0] else: datablock = None if params.mask is not None: from libtbx import easy_pickle
def run(self): '''Execute the script.''' from dials.util.options import flatten_datablocks from time import time from dials.util import log from libtbx.utils import Sorry import datetime start_time = time() # Parse the command line params, options = self.parser.parse_args(show_diff_phil=False) # Configure the logging log.config( params.verbosity, info=params.output.log, debug=params.output.debug_log) from dials.util.version import dials_version logger.info(dials_version()) # Log the diff phil diff_phil = self.parser.diff_phil.as_str() if diff_phil is not '': logger.info('The following parameters have been modified:\n') logger.info(diff_phil) # Ensure we have a data block datablocks = flatten_datablocks(params.input.datablock) if len(datablocks) == 0: self.parser.print_help() return # Extend the first datablock datablock = datablocks[0] for db in datablocks[1:]: if datablock.format_class() != db.format_class(): raise Sorry("Datablocks must have the same format") datablock.extend(db) # Get the imagesets and sweeps stills = datablock.extract_stills() sweeps = datablock.extract_sweeps() if len(stills) > 0: raise Sorry("Sets of still images are currently unsupported") logger.info("Number of sweeps = %d" % len(sweeps)) # Sort the sweeps by timestamps logger.info("Sorting sweeps based on timestamp") sweeps = sorted(sweeps, key=lambda x: x.get_scan().get_epochs()[0]) # Count the number of datasets from each day from collections import Counter counter = Counter() for s in sweeps: timestamp = s.get_scan().get_epochs()[0] timestamp = datetime.datetime.fromtimestamp(timestamp) timestamp = timestamp.strftime('%Y-%m-%d') counter[timestamp] += 1 # Print the number of datasets on each day for timestamp in sorted(counter.keys()): logger.info("%d datasets collected on %s" % (counter[timestamp], timestamp)) # Loop though and see if any models might be shared b_list = [ s.get_beam() for s in sweeps ] d_list = [ s.get_detector() for s in sweeps ] g_list = [ s.get_goniometer() for s in sweeps ] b_index = [] d_index = [] g_index = [] for i in range(len(sweeps)): b = b_list[i] d = d_list[i] g = g_list[i] bn = i dn = i gn = i if i > 0: bj = b_index[-1] dj = d_index[-1] gj = g_index[-1] if b.is_similar_to(b_list[bj]): bn = bj if d.is_similar_to(d_list[dj]): dn = dj if g.is_similar_to(g_list[gj]): gn = gj b_index.append(bn) d_index.append(dn) g_index.append(gn) # Print a table of possibly shared models from libtbx.table_utils import format as table rows = [["Sweep", "ID", "Beam", "Detector", "Goniometer", "Date", "Time"]] for i in range(len(sweeps)): timestamp = sweeps[i].get_scan().get_epochs()[0] timestamp = datetime.datetime.fromtimestamp(timestamp) date_str = timestamp.strftime('%Y-%m-%d') time_str = timestamp.strftime('%H:%M:%S') row = [ '%s' % sweeps[i].get_template(), '%s' % i, '%s' % b_index[i], '%s' % d_index[i], '%s' % g_index[i], '%s' % date_str, '%s' % time_str] rows.append(row) logger.info(table(rows, has_header=True, justify='left', prefix=' ')) # Print the time logger.info("Time Taken: %f" % (time() - start_time))
def run(self): '''Execute the script.''' from dials.util.options import flatten_reflections, flatten_experiments, \ flatten_datablocks import cPickle as pickle # Parse the command line params, options = self.parser.parse_args(show_diff_phil=True) reflections = flatten_reflections(params.input.reflections) experiments = flatten_experiments(params.input.experiments) datablocks = flatten_datablocks(params.input.datablock) # Try to load the models and data slice_exps = len(experiments) > 0 slice_refs = len(reflections) > 0 slice_dbs = len(datablocks) > 0 # Catch case of nothing to do if not any([slice_exps, slice_refs, slice_dbs]): print "No suitable input provided" self.parser.print_help() return if reflections: if len(reflections) > 1: raise Sorry( "Only one reflections list can be imported at present") reflections = reflections[0] # calculate frame numbers if needed if experiments: reflections = calculate_frame_numbers(reflections, experiments) # if we still don't have the right column give up if 'xyzobs.px.value' not in reflections: raise Sorry( "These reflections do not have frame numbers set, and " "there are no experiments provided to calculate these.") # set trivial case where no scan range is provided at all if not params.scan_range: params.scan_range = [None] # check if slicing into blocks if params.block_size is not None: # in this case for simplicity, ensure that there is either an # an experiment list or datablocks, but not both. Ensure there is only # a single scan contained within. if [slice_exps, slice_dbs].count(True) != 1: raise Sorry( "For slicing into blocks please provide either datablocks" " or experiments, but not both.") if slice_exps: if len(experiments) > 1: raise Sorry( "For slicing into blocks please provide a single " "scan only") scan = experiments[0].scan if slice_dbs: scans = datablocks[0].unique_scans() if len(scans) > 1 or len(datablocks) > 1: raise Sorry( "For slicing into blocks please provide a single " "scan only") scan = scans[0] # Having extracted the scan, calculate the blocks params.scan_range = calculate_block_ranges(scan, params.block_size) # Do the slicing then recombine if slice_exps: sliced = [slice_experiments(experiments, [sr])[0] \ for sr in params.scan_range] sliced_experiments = ExperimentList() for exp in sliced: sliced_experiments.append(exp) if slice_dbs: sliced = [slice_datablocks(datablocks, [sr])[0] \ for sr in params.scan_range] imagesets = [db.extract_imagesets()[0] for db in sliced] sliced_datablocks = DataBlock(imagesets) # slice reflections if present if slice_refs: sliced = [slice_reflections(reflections, [sr]) \ for sr in params.scan_range] sliced_reflections = sliced[0] for i, rt in enumerate(sliced[1:]): rt['id'] += (i + 1) # set id sliced_reflections.extend(rt) else: # slice each dataset into the requested subset if slice_exps: sliced_experiments = slice_experiments(experiments, params.scan_range) if slice_refs: sliced_reflections = slice_reflections(reflections, params.scan_range) if slice_dbs: sliced_datablocks = slice_datablocks(datablocks, params.scan_range) # Save sliced experiments if slice_exps: output_experiments_filename = params.output.experiments_filename if output_experiments_filename is None: # take first filename as template bname = basename(params.input.experiments[0].filename) bname = splitext(bname)[0] if not bname: bname = "experiments" if len(params.scan_range ) == 1 and params.scan_range[0] is not None: ext = "_{0}_{1}.json".format(*params.scan_range[0]) else: ext = "_sliced.json" output_experiments_filename = bname + ext print 'Saving sliced experiments to {0}'.format( output_experiments_filename) from dxtbx.model.experiment.experiment_list import ExperimentListDumper dump = ExperimentListDumper(sliced_experiments) dump.as_json(output_experiments_filename) # Save sliced reflections if slice_refs: output_reflections_filename = params.output.reflections_filename if output_reflections_filename is None: # take first filename as template bname = basename(params.input.reflections[0].filename) bname = splitext(bname)[0] if not bname: bname = "reflections" if len(params.scan_range ) == 1 and params.scan_range[0] is not None: ext = "_{0}_{1}.pickle".format(*params.scan_range[0]) else: ext = "_sliced.pickle" output_reflections_filename = bname + ext print 'Saving sliced reflections to {0}'.format( output_reflections_filename) sliced_reflections.as_pickle(output_reflections_filename) # Save sliced datablocks if slice_dbs: output_datablocks_filename = params.output.datablocks_filename if output_datablocks_filename is None: # take first filename as template bname = basename(params.input.datablock[0].filename) bname = splitext(bname)[0] if not bname: bname = "datablock" if len(params.scan_range ) == 1 and params.scan_range[0] is not None: ext = "_{0}_{1}.json".format(*params.scan_range[0]) else: ext = "_sliced.json" output_datablocks_filename = bname + ext print 'Saving sliced datablocks to {0}'.format( output_datablocks_filename) from dxtbx.datablock import DataBlockDumper dump = DataBlockDumper(sliced_datablocks) dump.as_file(output_datablocks_filename) return
def run(self): '''Execute the script.''' from dxtbx.datablock import DataBlockTemplateImporter from dials.util.options import flatten_datablocks from dials.util import log from logging import info from time import time from libtbx.utils import Abort # Parse the command line params, options = self.parser.parse_args(show_diff_phil=False) datablocks = flatten_datablocks(params.input.datablock) # Check we have some filenames if len(datablocks) == 0: # Check if a template has been set and print help if not, otherwise try to # import the images based on the template input if len(params.input.template) == 0: self.parser.print_help() exit(0) else: importer = DataBlockTemplateImporter( params.input.template, options.verbose) datablocks = importer.datablocks # Save the options self.options = options self.params = params self.load_reference_geometry() st = time() # Import stuff if len(datablocks) == 0: raise Abort('No datablocks specified') elif len(datablocks) > 1: raise Abort('Only 1 datablock can be processed at a time.') datablock = datablocks[0] if self.reference_detector is not None: for imageset in datablock.extract_imagesets(): imageset.set_detector(self.reference_detector) # Configure logging log.config( params.verbosity, info='dials.process.log', debug='dials.process.debug.log') # Log the diff phil diff_phil = self.parser.diff_phil.as_str() if diff_phil is not '': info('The following parameters have been modified:\n') info(diff_phil) if self.params.output.datablock_filename: from dxtbx.datablock import DataBlockDumper dump = DataBlockDumper(datablock) dump.as_json(self.params.output.datablock_filename) # Do the processing observed = self.find_spots(datablock) experiments, indexed = self.index(datablock, observed) experiments = self.refine(experiments, indexed) integrated = self.integrate(experiments, indexed) # Total Time info("") info("Total Time Taken = %f seconds" % (time() - st))
def run(args): import libtbx.load_env from dials.util import log usage = "%s [options] datablock.json strong.pickle" % libtbx.env.dispatcher_name parser = OptionParser(usage=usage, phil=phil_scope, read_datablocks=True, read_reflections=True, check_format=False, epilog=help_message) params, options = parser.parse_args(show_diff_phil=False) datablocks = flatten_datablocks(params.input.datablock) reflections = flatten_reflections(params.input.reflections) if len(datablocks) == 0 or len(reflections) == 0: parser.print_help() exit(0) imagesets = [] for db in datablocks: imagesets.extend(db.extract_imagesets()) spots = [] for reflection in reflections: unique_ids = set(reflection['id']) for unique_id in sorted(unique_ids): spots.append(reflection.select(reflection['id'] == unique_id)) assert len(imagesets) == len(spots) if params.output.compress: import gzip fout = gzip.GzipFile(params.output.csv, 'w') else: fout = open(params.output.csv, 'w') fout.write('# x,y,z,experiment_id,imageset_id\n') dp = params.output.dp if dp <= 0: fmt = '%f,%f,%f,%d,%d\n' else: fmt = '%%.%df,%%.%df,%%.%df,%%d,%%d\n' % (dp, dp, dp) print 'Using format:', fmt.strip() for k, (imageset, refl) in enumerate(zip(imagesets, spots)): if 'imageset_id' not in refl: refl['imageset_id'] = refl['id'] reflmm = indexer_base.map_spots_pixel_to_mm_rad( spots=refl, detector=imageset.get_detector(), scan=imageset.get_scan()) indexer_base.map_centroids_to_reciprocal_space( reflmm, detector=imageset.get_detector(), beam=imageset.get_beam(), goniometer=imageset.get_goniometer()) rlp = reflmm['rlp'] for _rlp in rlp: fout.write(fmt % (_rlp[0], _rlp[1], _rlp[2], k, k)) print 'Appended %d spots to %s' % (len(rlp), params.output.csv) fout.close()
def run(args): import libtbx.load_env from libtbx.utils import Sorry from dials.util import log usage = "%s [options] datablock.json strong.pickle" % libtbx.env.dispatcher_name parser = OptionParser( usage=usage, phil=phil_scope, read_reflections=True, read_datablocks=True, read_datablocks_from_images=True, check_format=False, epilog=help_message, ) params, options = parser.parse_args(show_diff_phil=False) from dials.util.version import dials_version logger.info(dials_version()) # Log the diff phil diff_phil = parser.diff_phil.as_str() if diff_phil is not "": logger.info("The following parameters have been modified:\n") logger.info(diff_phil) datablocks = flatten_datablocks(params.input.datablock) reflections = flatten_reflections(params.input.reflections) if len(datablocks) == 0: parser.print_help() return imagesets = [] for datablock in datablocks: imagesets.extend(datablock.extract_imagesets()) if len(reflections) == 0: raise Sorry("No reflection lists found in input") if len(reflections) > 1: assert len(reflections) == len(imagesets) for i in range(len(reflections)): reflections[i]["imageset_id"] = flex.int(len(reflections[i]), i) if i > 0: reflections[0].extend(reflections[i]) reflections_input = reflections[0] for imageset in imagesets: if (imageset.get_goniometer() is not None and imageset.get_scan() is not None and imageset.get_scan().get_oscillation()[1] == 0): imageset.set_goniometer(None) imageset.set_scan(None) from dials.algorithms.indexing.indexer import Indexer reflections = flex.reflection_table() for i, imageset in enumerate(imagesets): if "imageset_id" not in reflections_input: reflections_input["imageset_id"] = reflections_input["id"] sel = reflections_input["imageset_id"] == i refl = Indexer.map_spots_pixel_to_mm_rad(reflections_input.select(sel), imageset.get_detector(), imageset.get_scan()) Indexer.map_centroids_to_reciprocal_space( refl, imageset.get_detector(), imageset.get_beam(), imageset.get_goniometer(), ) refl["entering"] = Indexer.calculate_entering_flags( refl, beam=imageset.get_beam(), goniometer=imageset.get_goniometer()) reflections.extend(refl) filter_ice(reflections, steps=params.steps) return
def run(args): import os import libtbx.load_env from libtbx.utils import Sorry from dials.util.options import OptionParser usage = "%s [options] datablock.json | image.cbf" % libtbx.env.dispatcher_name parser = OptionParser(usage=usage, phil=phil_scope, read_datablocks=True, read_datablocks_from_images=True, check_format=True, epilog=help_message) params, options = parser.parse_args(show_diff_phil=True) datablocks = flatten_datablocks(params.input.datablock) if len(datablocks) == 0: parser.print_help() exit(0) imagesets = datablocks[0].extract_imagesets() brightness = params.brightness / 100 vendortype = "made up" # check that binning is a power of 2 binning = params.binning if not (binning > 0 and ((binning & (binning - 1)) == 0)): raise Sorry("binning must be a power of 2") output_dir = params.output_dir if output_dir is None: output_dir = "." elif not os.path.exists(output_dir): os.makedirs(output_dir) from rstbx.slip_viewer.tile_generation \ import _get_flex_image, _get_flex_image_multipanel for imageset in imagesets: detector = imageset.get_detector() if len(detector) > 1: raise Sorry( 'Currently only single panel detectors are supported by %s' % libtbx.env.dispatcher_name) panel = detector[0] scan = imageset.get_scan() # XXX is this inclusive or exclusive? saturation = panel.get_trusted_range()[1] if params.saturation: saturation = params.saturation if scan is not None and scan.get_oscillation()[1] > 0: start, end = scan.get_image_range() else: start, end = 0, len(imageset) for i_image in range(start, end + 1): image = imageset.get_raw_data(i_image - start) #if len(detector) == 1: #image = [image] trange = [p.get_trusted_range() for p in detector] mask = imageset.get_mask(i_image - start) if mask is None: mask = [ p.get_trusted_range_mask(im) for im, p in zip(image, detector) ] if params.show_mask: for rd, m in zip(image, mask): rd.set_selected(~m, -2) image = image_filter(image, mask, display=params.display, gain_value=params.gain, nsigma_b=params.nsigma_b, nsigma_s=params.nsigma_s, global_threshold=params.global_threshold, min_local=params.min_local, kernel_size=params.kernel_size) show_untrusted = params.show_mask if len(detector) > 1: # FIXME This doesn't work properly, as flex_image.size2() is incorrect # also binning doesn't work assert binning == 1 flex_image = _get_flex_image_multipanel( brightness=brightness, panels=detector, raw_data=image, beam=imageset.get_beam(), show_untrusted=show_untrusted) else: flex_image = _get_flex_image(brightness=brightness, data=image[0], binning=binning, saturation=saturation, vendortype=vendortype, show_untrusted=show_untrusted) flex_image.setWindow(0, 0, 1) flex_image.adjust( color_scheme=colour_schemes.get(params.colour_scheme)) # now export as a bitmap flex_image.prep_string() try: from PIL import Image except ImportError: import Image # XXX is size//binning safe here? try: # fromstring raises Exception in Pillow >= 3.0.0 pil_img = Image.fromstring('RGB', (flex_image.size2() // binning, flex_image.size1() // binning), flex_image.export_string) except Exception: pil_img = Image.frombytes('RGB', (flex_image.size2() // binning, flex_image.size1() // binning), flex_image.export_string) path = os.path.join( output_dir, params.prefix + ("%04d" % i_image) + '.' + params.format) print "Exporting %s" % path with open(path, 'wb') as tmp_stream: pil_img.save(tmp_stream, format=params.format, compress_level=params.png.compress_level, quality=params.jpeg.quality)
def run(args): from dials.util.options import OptionParser from dials.util.options import flatten_datablocks from dials.util.options import flatten_experiments from dials.util.options import flatten_reflections from dials.util import log import libtbx.load_env usage = "%s [options] datablock.json reflections.pickle" % ( libtbx.env.dispatcher_name) parser = OptionParser(usage=usage, phil=phil_scope, read_datablocks=True, read_experiments=True, read_reflections=True, check_format=False, epilog=help_message) params, options = parser.parse_args() datablocks = flatten_datablocks(params.input.datablock) experiments = flatten_experiments(params.input.experiments) reflections = flatten_reflections(params.input.reflections) if (len(datablocks) == 0 and len(experiments) == 0) or len(reflections) == 0: parser.print_help() exit(0) # Configure the logging log.config(info='dials.detect_blanks.log') # Log the diff phil diff_phil = parser.diff_phil.as_str() if diff_phil is not '': logger.info('The following parameters have been modified:\n') logger.info(diff_phil) reflections = reflections[0] if len(datablocks) == 0 and len(experiments) > 0: imagesets = experiments.imagesets() else: imagesets = [] for datablock in datablocks: imagesets.extend(datablock.extract_imagesets()) assert len(imagesets) == 1 imageset = imagesets[0] scan = imageset.get_scan() integrated_sel = reflections.get_flags(reflections.flags.integrated) indexed_sel = reflections.get_flags(reflections.flags.indexed) centroid_outlier_sel = reflections.get_flags( reflections.flags.centroid_outlier) strong_sel = reflections.get_flags(reflections.flags.strong) indexed_sel &= (~centroid_outlier_sel) logger.info('Analysis of %i strong reflections:' % strong_sel.count(True)) strong_results = blank_counts_analysis( reflections.select(strong_sel), scan, phi_step=params.phi_step, fractional_loss=params.counts_fractional_loss) for blank_start, blank_end in strong_results['blank_regions']: logger.info('Potential blank images: %i -> %i' % (blank_start + 1, blank_end)) indexed_results = None if indexed_sel.count(True) > 0: logger.info('Analysis of %i indexed reflections:' % indexed_sel.count(True)) indexed_results = blank_counts_analysis( reflections.select(indexed_sel), scan, phi_step=params.phi_step, fractional_loss=params.counts_fractional_loss) for blank_start, blank_end in indexed_results['blank_regions']: logger.info('Potential blank images: %i -> %i' % (blank_start + 1, blank_end)) integrated_results = None if integrated_sel.count(True) > 0: logger.info('Analysis of %i integrated reflections:' % integrated_sel.count(True)) integrated_results = blank_integrated_analysis( reflections.select(integrated_sel), scan, phi_step=params.phi_step, fractional_loss=params.misigma_fractional_loss) for blank_start, blank_end in integrated_results['blank_regions']: logger.info('Potential blank images: %i -> %i' % (blank_start + 1, blank_end)) d = { 'strong': strong_results, 'indexed': indexed_results, 'integrated': integrated_results } if params.output.json is not None: import json with open(params.output.json, 'wb') as f: json.dump(d, f) if params.output.plot: from matplotlib import pyplot plots = [(strong_results, '-')] if indexed_results: plots.append((indexed_results, '--')) if integrated_results: plots.append((integrated_results, ':')) for results, linestyle in plots: xs = results['data'][0]['x'] ys = results['data'][0]['y'] xmax = max(xs) ymax = max(ys) xs = [x / xmax for x in xs] ys = [y / ymax for y in ys] blanks = results['data'][0]['blank'] pyplot.plot(xs, ys, color='blue', linestyle=linestyle) pyplot.plot(*zip(*[(x, y) for x, y, blank in zip(xs, ys, blanks) if blank]), color='red', linestyle=linestyle) pyplot.ylim(0) pyplot.show() pyplot.clf()
def read_expt(filename): from dials.util.options import flatten_datablocks from dials.util.phil import DataBlockConverters converter = DataBlockConverters(check_format=False) return flatten_datablocks([converter.from_string(filename)])
def run(self): '''Execute the script.''' from dials.array_family import flex from dials.util.options import flatten_reflections from dials.util.options import flatten_datablocks from dials.util.options import flatten_experiments from libtbx.utils import Sorry # Parse the command line params, options = self.parser.parse_args(show_diff_phil=True) reflections = flatten_reflections(params.input.reflections) if params.input.datablock is not None and len(params.input.datablock): datablocks = flatten_datablocks(params.input.datablock) assert len(datablocks) == 1 imagesets = datablocks[0].extract_imagesets() assert len(imagesets) == 1 imageset = imagesets[0] elif params.input.experiments is not None and len( params.input.experiments): experiments = flatten_experiments(params.input.experiments) assert len(datablocks) == 1 imageset = experiments[0].imageset else: imageset = None if len(reflections) == 0: self.parser.print_help() raise Sorry('No valid reflection file given') if len(reflections) != 1: self.parser.print_help() raise Sorry('Exactly 1 reflection file must be specified') reflections = reflections[0] # Check params if params.d_min is not None and params.d_max is not None: if params.d_min > params.d_max: raise Sorry("d_min must be less than d_max") if params.d_min is not None or params.d_max is not None: if 'd' not in reflections: raise Sorry("Reflection table has no resolution information") # Check params if params.partiality.min is not None and params.partiality.max is not None: if params.min > params.max: raise Sorry( "partiality.min must be less than partiality.d_max") if params.partiality.min is not None or params.partiality.max is not None: if 'partiality' not in reflections: raise Sorry("Reflection table has no partiality information") print "{0} reflections loaded".format(len(reflections)) if (len(params.inclusions.flag) == 0 and len(params.exclusions.flag) == 0 and params.d_min is None and params.d_max is None and params.partiality.min is None and params.partiality.max is None and not params.ice_rings.filter): print "No filter specified. Performing analysis instead." return self.analysis(reflections) # Build up the initial inclusion selection inc = flex.bool(len(reflections), True) # 2016/07/06 GW logic here not right should be && for each flag not or? for flag in params.inclusions.flag: sel = reflections.get_flags(getattr(reflections.flags, flag)) inc = inc & sel reflections = reflections.select(inc) print "{0} reflections selected to form the working set".format( len(reflections)) # Make requested exclusions from the current selection exc = flex.bool(len(reflections)) for flag in params.exclusions.flag: print flag sel = reflections.get_flags(getattr(reflections.flags, flag)) exc = exc | sel reflections = reflections.select(~exc) print "{0} reflections excluded from the working set".format( exc.count(True)) # Filter based on resolution if params.d_min is not None: selection = reflections['d'] >= params.d_min reflections = reflections.select(selection) print "Selected %d reflections with d >= %f" % (len(reflections), params.d_min) # Filter based on resolution if params.d_max is not None: selection = reflections['d'] <= params.d_max reflections = reflections.select(selection) print "Selected %d reflections with d <= %f" % (len(reflections), params.d_max) # Filter based on partiality if params.partiality.min is not None: selection = reflections['partiality'] >= params.partiality.min reflections = reflections.select(selection) print "Selected %d reflections with partiality >= %f" % ( len(reflections), params.partiality.min) # Filter based on partiality if params.partiality.max is not None: selection = reflections['partiality'] <= params.partiality.max reflections = reflections.select(selection) print "Selected %d reflections with partiality <= %f" % ( len(reflections), params.partiality.max) # Filter powder rings if params.ice_rings.filter: from dials.algorithms.integration import filtering if 'd' in reflections: d_spacings = reflections['d'] else: from cctbx import uctbx if 'rlp' not in reflections: assert imageset is not None from dials.algorithms.spot_finding.per_image_analysis import map_to_reciprocal_space reflections = map_to_reciprocal_space( reflections, imageset) d_star_sq = flex.pow2(reflections['rlp'].norms()) d_spacings = uctbx.d_star_sq_as_d(d_star_sq) d_min = params.ice_rings.d_min width = params.ice_rings.width if d_min is None: d_min = flex.min(d_spacings) ice_filter = filtering.PowderRingFilter( params.ice_rings.unit_cell, params.ice_rings.space_group.group(), d_min, width) ice_sel = ice_filter(d_spacings) print "Rejecting %i reflections at ice ring resolution" % ice_sel.count( True) reflections = reflections.select(~ice_sel) #reflections = reflections.select(ice_sel) # Save filtered reflections to file if params.output.reflections: print "Saving {0} reflections to {1}".format( len(reflections), params.output.reflections) reflections.as_pickle(params.output.reflections) return
def run(args): from dials.util.options import OptionParser from dials.util.options import flatten_datablocks import libtbx.load_env usage = "%s [options] datablock.json" %( libtbx.env.dispatcher_name) parser = OptionParser( usage=usage, phil=phil_scope, read_datablocks=True, check_format=True, epilog=help_message) params, options = parser.parse_args(show_diff_phil=True) datablocks = flatten_datablocks(params.input.datablock) if len(datablocks) == 0: parser.print_help() exit(0) assert len(datablocks) == 1 imagesets = datablocks[0].extract_imagesets() imageset = imagesets[0] goniometer = imageset.get_goniometer() detector = imageset.get_detector() scan = imageset.get_scan() masker = imageset.masker().format_class(imageset.paths()[0]).get_goniometer_shadow_masker() if masker is None: raise Sorry('Goniometer model does not support shadowing.') angles = goniometer.get_angles() names = goniometer.get_names() scan_axis = goniometer.get_scan_axis() phi = angles[0] if params.step_size is libtbx.Auto: if params.mode == '1d': step = scan.get_oscillation()[1] else: step = 10 else: step = params.step_size if params.mode == '1d': if params.oscillation_range is not None: start, end = params.oscillation_range else: start, end = scan.get_oscillation_range() scan_points = flex.double(libtbx.utils.frange(start, end, step=step)) n_px_shadowed = flex.double(scan_points.size(), 0) n_px_tot = flex.double(scan_points.size(), 0) assert len(angles) == 3 for i, scan_angle in enumerate(scan_points): shadow = masker.project_extrema(detector, scan_angle=scan_angle) for p_id in range(len(detector)): px_x, px_y = detector[p_id].get_image_size() n_px_tot[i] += px_x * px_y if shadow[p_id].size() < 4: continue n_px_shadowed[i] += polygon_area(shadow[p_id]) else: kappa_values = flex.double(libtbx.utils.frange(0, 360, step=step)) omega_values = flex.double(libtbx.utils.frange(0, 360, step=step)) grid = flex.grid(kappa_values.size(), omega_values.size()) n_px_shadowed = flex.double(grid, 0) n_px_tot = flex.double(grid, 0) assert len(angles) == 3 for i, kappa in enumerate(kappa_values): for j, omega in enumerate(omega_values): masker.goniometer.set_angles((phi, kappa, omega)) shadow = masker.project_extrema(detector, scan_angle=omega) for p_id in range(len(detector)): px_x, px_y = detector[p_id].get_image_size() n_px_tot[i, j] += px_x * px_y if shadow[p_id].size() < 4: continue n_px_shadowed[i, j] += polygon_area(shadow[p_id]) fraction_shadowed = n_px_shadowed/n_px_tot if params.output.json is not None: if params.mode == '2d': raise Sorry('json output not supported for mode=2d') print 'Writing json output to %s' %params.output.json d = { 'scan_points': list(scan_points), 'fraction_shadowed': list(fraction_shadowed), } import json with open(params.output.json, 'wb') as f: json.dump(d, f) if params.output.plot is not None: import matplotlib matplotlib.use('Agg') from matplotlib import pyplot as plt plt.style.use('ggplot') if params.mode == '1d': plt.plot(scan_points.as_numpy_array(), fraction_shadowed.as_numpy_array() * 100) plt.xlabel('%s angle (degrees)' %names[scan_axis]) plt.ylabel('Shadowed area (%)') if params.y_max is not None: plt.ylim(0, params.y_max) else: plt.ylim(0, plt.ylim()[1]) else: plt.imshow(fraction_shadowed.as_numpy_array() * 100, interpolation='bicubic') plt.xlabel('%s angle (degrees)' %names[2]) plt.ylabel('%s angle (degrees)' %names[1]) plt.xlim(0, 360/step) plt.ylim(0, 360/step) plt.axes().set_xticklabels(["%.0f" %(step * t) for t in plt.xticks()[0]]) plt.axes().set_yticklabels(["%.0f" %(step * t) for t in plt.yticks()[0]]) cbar = plt.colorbar() cbar.set_label('Shadowed area (%)') if params.output.size_inches is not None: fig = plt.gcf() fig.set_size_inches(params.output.size_inches) plt.tight_layout() print 'Saving plot to %s' %params.output.plot plt.savefig(params.output.plot)
def run(self): ''' Perform the integration. ''' from dials.util.options import flatten_datablocks, flatten_experiments from dials.util import log # Parse the command line params, options = self.parser.parse_args(show_diff_phil=False) experiments = flatten_experiments(params.input.experiments) datablocks = flatten_datablocks(params.input.datablock) if len(experiments) == 0 and len(datablocks) == 0: self.parser.print_help() return if len(datablocks) > 0: assert len(datablocks) == 1 imagesets = datablocks[0].extract_imagesets() assert len(imagesets) == 1 imageset = imagesets[0] beam = imageset.get_beam() detector = imageset.get_detector() else: assert len(experiments) == 1 imageset = experiments[0].imageset beam = experiments[0].beam detector = experiments[0].detector # Configure logging log.config() # Set the scan range if params.scan_range is None: scan_range = (0, len(imageset)) else: scan_range = params.scan_range i0, i1 = scan_range if i0 < 0 or i1 > len(imageset): raise RuntimeError('Scan range outside image range') if i0 >= i1: raise RuntimeError('Invalid scan range') summed_data = None summed_mask = None # Loop through images for i in range(*scan_range): logger.info("Reading image %d" % i) # Read image data = imageset.get_raw_data(i) mask = imageset.get_mask(i) assert isinstance(data, tuple) assert isinstance(mask, tuple) if summed_data is None: summed_mask = mask summed_data = data else: summed_data = [sd + d for sd, d in zip(summed_data, data)] summed_mask = [sm & m for sm, m in zip(summed_mask, mask)] # Compute min and max and num if params.num_bins is None: num_bins = sum(sum(p.get_image_size()) for p in detector) if params.d_max is None: vmin = 0 else: vmin = (1.0 / d_max)**2 if params.d_min is None: params.d_min = detector.get_max_resolution(beam.get_s0()) vmax = (1.0 / params.d_min)**2 # Print some info logger.info("Min 1/d^2: %f" % vmin) logger.info("Max 1/d^2: %f" % vmax) logger.info("Num bins: %d" % num_bins) # Compute the radial average from dials.algorithms.background import RadialAverage radial_average = RadialAverage(beam, detector, vmin, vmax, num_bins) for d, m in zip(summed_data, summed_mask): radial_average.add(d.as_double() / (scan_range[1] - scan_range[0]), m) mean = radial_average.mean() reso = radial_average.inv_d2() logger.info("Writing to %s" % params.output.filename) with open(params.output.filename, "w") as outfile: for r, m in zip(reso, mean): outfile.write("%f, %f\n" % (r, m))
def run(args): import libtbx.load_env from libtbx.utils import Sorry from dials.util import log usage = "%s [options] datablock.json strong.pickle" % libtbx.env.dispatcher_name parser = OptionParser(usage=usage, phil=phil_scope, read_reflections=True, read_datablocks=True, read_experiments=True, check_format=False, epilog=help_message) params, options = parser.parse_args(show_diff_phil=False) # Configure the logging log.config(params.verbosity, info=params.output.log, debug=params.output.debug_log) from dials.util.version import dials_version logger.info(dials_version()) # Log the diff phil diff_phil = parser.diff_phil.as_str() if diff_phil is not '': logger.info('The following parameters have been modified:\n') logger.info(diff_phil) datablocks = flatten_datablocks(params.input.datablock) experiments = flatten_experiments(params.input.experiments) reflections = flatten_reflections(params.input.reflections) if len(datablocks) == 0: if len(experiments) > 0: imagesets = experiments.imagesets() else: parser.print_help() return #elif len(datablocks) > 1: #raise Sorry("Only one DataBlock can be processed at a time") else: imagesets = [] for datablock in datablocks: imagesets.extend(datablock.extract_imagesets()) if len(experiments): known_crystal_models = experiments.crystals() else: known_crystal_models = None if len(reflections) == 0: raise Sorry("No reflection lists found in input") if len(reflections) > 1: #raise Sorry("Multiple reflections lists provided in input") assert len(reflections) == len(imagesets) from scitbx.array_family import flex for i in range(len(reflections)): reflections[i]['imageset_id'] = flex.int(len(reflections[i]), i) if i > 0: reflections[0].extend(reflections[i]) #assert(len(reflections) == 1) reflections = reflections[0] for imageset in imagesets: if (imageset.get_goniometer() is not None and imageset.get_scan() is not None and imageset.get_scan().get_oscillation()[1] == 0): imageset.set_goniometer(None) imageset.set_scan(None) from dials.algorithms.indexing.indexer import indexer_base idxr = indexer_base.from_parameters( reflections, imagesets, known_crystal_models=known_crystal_models, params=params) refined_experiments = idxr.refined_experiments reflections = copy.deepcopy(idxr.refined_reflections) reflections.extend(idxr.unindexed_reflections) if len(refined_experiments): logger.info("Saving refined experiments to %s" % params.output.experiments) idxr.export_as_json(refined_experiments, file_name=params.output.experiments) logger.info("Saving refined reflections to %s" % params.output.reflections) idxr.export_reflections(reflections, file_name=params.output.reflections) if params.output.unindexed_reflections is not None: logger.info("Saving unindexed reflections to %s" % params.output.unindexed_reflections) idxr.export_reflections( idxr.unindexed_reflections, file_name=params.output.unindexed_reflections) return
def run(args): from dials.util.options import OptionParser from dials.util.options import flatten_datablocks import libtbx.load_env usage = "%s [options] datablock.json reference=reference_datablock.json" % ( libtbx.env.dispatcher_name ) parser = OptionParser( usage=usage, phil=phil_scope, read_datablocks=True, check_format=False, epilog=help_message, ) params, options = parser.parse_args(show_diff_phil=True) datablocks = flatten_datablocks(params.input.datablock) if len(datablocks) == 0: parser.print_help() exit() # Load reference geometry reference_detector = None if params.input.reference is not None: from dxtbx.serialize import load try: reference_experiments = load.experiment_list( params.input.reference, check_format=False ) assert len(reference_experiments.detectors()) == 1 reference_detector = reference_experiments.detectors()[0] except Exception as e: reference_datablocks = load.datablock(params.input.reference) assert len(reference_datablocks) == 1 imageset = reference_datablocks[0].extract_imagesets()[0] reference_detector = imageset.get_detector() assert len(datablocks) == 1 imageset = datablocks[0].extract_imagesets()[0] detector = imageset.get_detector() h = detector.hierarchy() href = reference_detector.hierarchy() assert len(h) == len(href) assert ( abs(h.get_directed_distance() - href.get_directed_distance()) < params.max_delta_distance ) for panel, panel_ref in zip(h.children(), href.children()): panel.set_local_frame( panel_ref.get_local_fast_axis(), panel_ref.get_local_slow_axis(), panel_ref.get_local_origin(), ) print("Writing metrology-corrected datablock to %s" % params.output.datablock) from dxtbx.serialize import dump dump.datablock(datablocks, params.output.datablock) return
def run(self): ''' Parse the options. ''' from dials.util.options import flatten_experiments, flatten_datablocks, flatten_reflections # Parse the command line arguments params, options = self.parser.parse_args(show_diff_phil=True) self.params = params experiments = flatten_experiments(params.input.experiments) datablocks = flatten_datablocks(params.input.datablock) reflections = flatten_reflections(params.input.reflections) # Find all detector objects detectors = [] detectors.extend(experiments.detectors()) dbs = [] for datablock in datablocks: dbs.extend(datablock.unique_detectors()) detectors.extend(dbs) # Verify inputs if len(detectors) != 2: print "Please provide two experiments and or datablocks for comparison" return # These lines exercise the iterate_detector_at_level and iterate_panels functions # for a detector with 4 hierarchy levels """ print "Testing iterate_detector_at_level" for level in xrange(4): print "iterating at level", level for panelg in iterate_detector_at_level(detectors[0].hierarchy(), 0, level): print panelg.get_name() print "Testing iterate_panels" for level in xrange(4): print "iterating at level", level for panelg in iterate_detector_at_level(detectors[0].hierarchy(), 0, level): for panel in iterate_panels(panelg): print panel.get_name() """ tmp = [] for refls in reflections: print "N reflections total:", len(refls) refls = refls.select( refls.get_flags(refls.flags.used_in_refinement)) print "N reflections used in refinement", len(refls) print "Reporting only on those reflections used in refinement" refls['difference_vector_norms'] = ( refls['xyzcal.mm'] - refls['xyzobs.mm.value']).norms() tmp.append(refls) reflections = tmp # Iterate through the detectors, computing the congruence statistics delta_normals = {} z_angles = {} f_deltas = {} s_deltas = {} z_deltas = {} o_deltas = {} # overall z_offsets_d = {} refl_counts = {} all_delta_normals = flex.double() all_rdelta_normals = flex.double() all_tdelta_normals = flex.double() all_z_angles = flex.double() all_f_deltas = flex.double() all_s_deltas = flex.double() all_z_deltas = flex.double() all_deltas = flex.double() all_refls_count = flex.int() all_normal_angles = flex.double() all_rnormal_angles = flex.double() all_tnormal_angles = flex.double() pg_normal_angle_sigmas = flex.double() pg_rnormal_angle_sigmas = flex.double() pg_tnormal_angle_sigmas = flex.double() all_rot_z = flex.double() pg_rot_z_sigmas = flex.double() pg_bc_dists = flex.double() all_bc_dist = flex.double() all_f_offsets = flex.double() all_s_offsets = flex.double() all_z_offsets = flex.double() pg_f_offset_sigmas = flex.double() pg_s_offset_sigmas = flex.double() pg_z_offset_sigmas = flex.double() pg_offset_sigmas = flex.double() all_weights = flex.double() congruence_table_data = [] detector_table_data = [] rmsds_table_data = [] root1 = detectors[0].hierarchy() root2 = detectors[1].hierarchy() s0 = col( flex.vec3_double([col(b.get_s0()) for b in experiments.beams()]).mean()) # Compute a set of radial and transverse displacements for each reflection print "Setting up stats..." tmp_refls = [] for refls, expts in zip( reflections, [wrapper.data for wrapper in params.input.experiments]): tmp = flex.reflection_table() assert len(expts.detectors()) == 1 dect = expts.detectors()[0] # Need to construct a variety of vectors for panel_id, panel in enumerate(dect): panel_refls = refls.select(refls['panel'] == panel_id) bcl = flex.vec3_double() # Compute the beam center in lab space (a vector pointing from the origin to where the beam would intersect # the panel, if it did intersect the panel) for expt_id in set(panel_refls['id']): beam = expts[expt_id].beam s0 = beam.get_s0() expt_refls = panel_refls.select( panel_refls['id'] == expt_id) beam_centre = panel.get_beam_centre_lab(s0) bcl.extend(flex.vec3_double(len(expt_refls), beam_centre)) panel_refls['beam_centre_lab'] = bcl # Compute obs in lab space x, y, _ = panel_refls['xyzobs.mm.value'].parts() c = flex.vec2_double(x, y) panel_refls['obs_lab_coords'] = panel.get_lab_coord(c) # Compute deltaXY in panel space. This vector is relative to the panel origin x, y, _ = (panel_refls['xyzcal.mm'] - panel_refls['xyzobs.mm.value']).parts() # Convert deltaXY to lab space, subtracting off of the panel origin panel_refls['delta_lab_coords'] = panel.get_lab_coord( flex.vec2_double(x, y)) - panel.get_origin() tmp.extend(panel_refls) refls = tmp # The radial vector points from the center of the reflection to the beam center radial_vectors = (refls['obs_lab_coords'] - refls['beam_centre_lab']).each_normalize() # The transverse vector is orthogonal to the radial vector and the beam vector transverse_vectors = radial_vectors.cross( refls['beam_centre_lab']).each_normalize() # Compute the raidal and transverse components of each deltaXY refls['radial_displacements'] = refls['delta_lab_coords'].dot( radial_vectors) refls['transverse_displacements'] = refls['delta_lab_coords'].dot( transverse_vectors) tmp_refls.append(refls) reflections = tmp_refls for pg_id, (pg1, pg2) in enumerate( zip( iterate_detector_at_level(root1, 0, params.hierarchy_level), iterate_detector_at_level(root2, 0, params.hierarchy_level))): """ First compute statistics for detector congruence """ # Count up the number of reflections in this panel group pair for use as a weighting scheme total_refls = 0 pg1_refls = 0 pg2_refls = 0 for p1, p2 in zip(iterate_panels(pg1), iterate_panels(pg2)): r1 = len(reflections[0].select( reflections[0]['panel'] == id_from_name( detectors[0], p1.get_name()))) r2 = len(reflections[1].select( reflections[1]['panel'] == id_from_name( detectors[1], p2.get_name()))) total_refls += r1 + r2 pg1_refls += r1 pg2_refls += r2 if pg1_refls == 0 and pg2_refls == 0: print "No reflections on panel group", pg_id continue assert pg1.get_name() == pg2.get_name() refl_counts[pg1.get_name()] = total_refls row = ["%d" % pg_id] for pg, refls, det in zip([pg1, pg2], reflections, detectors): pg_refls = flex.reflection_table() for p in iterate_panels(pg): pg_refls.extend( refls.select( refls['panel'] == id_from_name(det, p.get_name()))) if len(pg_refls) == 0: rmsd = r_rmsd = t_rmsd = 0 else: rmsd = math.sqrt( flex.sum_sq(pg_refls['difference_vector_norms']) / len(pg_refls)) * 1000 r_rmsd = math.sqrt( flex.sum_sq(pg_refls['radial_displacements']) / len(pg_refls)) * 1000 t_rmsd = math.sqrt( flex.sum_sq(pg_refls['transverse_displacements']) / len(pg_refls)) * 1000 row.extend([ "%6.1f" % rmsd, "%6.1f" % r_rmsd, "%6.1f" % t_rmsd, "%8d" % len(pg_refls) ]) rmsds_table_data.append(row) # Angle between normals of pg1 and pg2 delta_norm_angle = col(pg1.get_normal()).angle(col( pg2.get_normal()), deg=True) all_delta_normals.append(delta_norm_angle) # compute radial and transverse components of the delta between normal angles pgo = (get_center(pg1) + get_center(pg2)) / 2 ro = (get_center(root1) + get_center(root2)) / 2 rn = (col(root1.get_normal()) + col(root2.get_normal())) / 2 rf = (col(root1.get_fast_axis()) + col(root2.get_fast_axis())) / 2 rs = (col(root1.get_slow_axis()) + col(root2.get_slow_axis())) / 2 ro_pgo = pgo - ro # vector from the detector origin to the average panel group origin if ro_pgo.length() == 0: radial = col((0, 0, 0)) transverse = col((0, 0, 0)) else: radial = ((rf.dot(ro_pgo) * rf) + (rs.dot(ro_pgo) * rs) ).normalize() # component of ro_pgo in rf rs plane transverse = rn.cross(radial).normalize() # now radial and transverse are vectors othogonal to each other and the detector normal, such that # radial points at the panel group origin # v1 and v2 are the components of pg 1 and 2 normals in the rn radial plane v1 = (radial.dot(col(pg1.get_normal())) * radial) + (rn.dot(col(pg1.get_normal())) * rn) v2 = (radial.dot(col(pg2.get_normal())) * radial) + (rn.dot(col(pg2.get_normal())) * rn) rdelta_norm_angle = v1.angle(v2, deg=True) if v1.cross(v2).dot(transverse) < 0: rdelta_norm_angle = -rdelta_norm_angle all_rdelta_normals.append(rdelta_norm_angle) # v1 and v2 are the components of pg 1 and 2 normals in the rn transverse plane v1 = (transverse.dot(col(pg1.get_normal())) * transverse) + (rn.dot(col(pg1.get_normal())) * rn) v2 = (transverse.dot(col(pg2.get_normal())) * transverse) + (rn.dot(col(pg2.get_normal())) * rn) tdelta_norm_angle = v1.angle(v2, deg=True) if v1.cross(v2).dot(radial) < 0: tdelta_norm_angle = -tdelta_norm_angle all_tdelta_normals.append(tdelta_norm_angle) # compute the angle between fast axes of these panel groups z_angle = col(pg1.get_fast_axis()[0:2]).angle(col( pg2.get_fast_axis()[0:2]), deg=True) all_z_angles.append(z_angle) z_angles[pg1.get_name()] = z_angle all_refls_count.append(total_refls) all_weights.append(pg1_refls) all_weights.append(pg2_refls) """ Now compute statistics measuring the reality of the detector. For example, instead of the distance between two things, we are concerned with the location of those things relative to laboratory space """ # Compute distances between panel groups and beam center # Also compute offset along Z axis dists = flex.double() f_offsets = flex.double() s_offsets = flex.double() z_offsets = flex.double() for pg, r in zip([pg1, pg2], [root1, root2]): bc = col(pg.get_beam_centre_lab(s0)) ori = get_center(pg) dists.append((ori - bc).length()) rori = col(r.get_origin()) delta_ori = ori - rori r_norm = col(r.get_normal()) r_fast = col(r.get_fast_axis()) r_slow = col(r.get_slow_axis()) f_offsets.append(r_fast.dot(delta_ori) * 1000) s_offsets.append(r_slow.dot(delta_ori) * 1000) z_offsets.append(r_norm.dot(delta_ori) * 1000) fd = abs(f_offsets[0] - f_offsets[1]) sd = abs(s_offsets[0] - s_offsets[1]) zd = abs(z_offsets[0] - z_offsets[1]) od = math.sqrt(fd**2 + sd**2 + zd**2) f_deltas[pg1.get_name()] = fd s_deltas[pg1.get_name()] = sd z_deltas[pg1.get_name()] = zd o_deltas[pg1.get_name()] = od all_f_deltas.append(fd) all_s_deltas.append(sd) all_z_deltas.append(zd) all_deltas.append(od) all_f_offsets.extend(f_offsets) all_s_offsets.extend(s_offsets) all_z_offsets.extend(z_offsets) # Compute angle between detector normal and panel group normal # Compute rotation of panel group around detector normal pg_rotz = flex.double() norm_angles = flex.double() rnorm_angles = flex.double() tnorm_angles = flex.double() for pg, r in zip([pg1, pg2], [root1, root2]): pgo = get_center(pg) pgn = col(pg.get_normal()) pgf = col(pg.get_fast_axis()) ro = get_center(r) rn = col(r.get_normal()) rf = col(r.get_fast_axis()) rs = col(r.get_slow_axis()) norm_angle = rn.angle(pgn, deg=True) norm_angles.append(norm_angle) all_normal_angles.append(norm_angle) ro_pgo = pgo - ro # vector from the detector origin to the panel group origin if ro_pgo.length() == 0: radial = col((0, 0, 0)) transverse = col((0, 0, 0)) else: radial = ( (rf.dot(ro_pgo) * rf) + (rs.dot(ro_pgo) * rs) ).normalize() # component of ro_pgo in rf rs plane transverse = rn.cross(radial).normalize() # now radial and transverse are vectors othogonal to each other and the detector normal, such that # radial points at the panel group origin # v is the component of pgn in the rn radial plane v = (radial.dot(pgn) * radial) + (rn.dot(pgn) * rn) angle = rn.angle(v, deg=True) if rn.cross(v).dot(transverse) < 0: angle = -angle rnorm_angles.append(angle) all_rnormal_angles.append(angle) # v is the component of pgn in the rn transverse plane v = (transverse.dot(pgn) * transverse) + (rn.dot(pgn) * rn) angle = rn.angle(v, deg=True) if rn.cross(v).dot(radial) < 0: angle = -angle tnorm_angles.append(angle) all_tnormal_angles.append(angle) # v is the component of pgf in the rf rs plane v = (rf.dot(pgf) * rf) + (rs.dot(pgf) * rs) angle = rf.angle(v, deg=True) angle = angle - (round(angle / 90) * 90 ) # deviation from 90 degrees pg_rotz.append(angle) all_rot_z.append(angle) # Set up table rows using stats aggregated from above pg_weights = flex.double([pg1_refls, pg2_refls]) if 0 in pg_weights: dist_m = dist_s = norm_angle_m = norm_angle_s = rnorm_angle_m = rnorm_angle_s = 0 tnorm_angle_m = tnorm_angle_s = rotz_m = rotz_s = 0 fo_m = fo_s = so_m = so_s = zo_m = zo_s = o_s = 0 else: stats = flex.mean_and_variance(dists, pg_weights) dist_m = stats.mean() dist_s = stats.gsl_stats_wsd() stats = flex.mean_and_variance(norm_angles, pg_weights) norm_angle_m = stats.mean() norm_angle_s = stats.gsl_stats_wsd() stats = flex.mean_and_variance(rnorm_angles, pg_weights) rnorm_angle_m = stats.mean() rnorm_angle_s = stats.gsl_stats_wsd() stats = flex.mean_and_variance(tnorm_angles, pg_weights) tnorm_angle_m = stats.mean() tnorm_angle_s = stats.gsl_stats_wsd() stats = flex.mean_and_variance(pg_rotz, pg_weights) rotz_m = stats.mean() rotz_s = stats.gsl_stats_wsd() stats = flex.mean_and_variance(f_offsets, pg_weights) fo_m = stats.mean() fo_s = stats.gsl_stats_wsd() stats = flex.mean_and_variance(s_offsets, pg_weights) so_m = stats.mean() so_s = stats.gsl_stats_wsd() stats = flex.mean_and_variance(z_offsets, pg_weights) zo_m = stats.mean() zo_s = stats.gsl_stats_wsd() o_s = math.sqrt(fo_s**2 + so_s**2 + zo_s**2) pg_bc_dists.append(dist_m) all_bc_dist.extend(dists) pg_normal_angle_sigmas.append(norm_angle_s) pg_rnormal_angle_sigmas.append(rnorm_angle_s) pg_tnormal_angle_sigmas.append(tnorm_angle_s) pg_rot_z_sigmas.append(rotz_s) pg_f_offset_sigmas.append(fo_s) pg_s_offset_sigmas.append(so_s) pg_z_offset_sigmas.append(zo_s) pg_offset_sigmas.append(o_s) z_offsets_d[pg1.get_name()] = zo_m congruence_table_data.append([ "%d" % pg_id, "%5.1f" % dist_m, #"%.4f"%dist_s, "%.4f" % delta_norm_angle, "%.4f" % rdelta_norm_angle, "%.4f" % tdelta_norm_angle, "%.4f" % z_angle, "%4.1f" % fd, "%4.1f" % sd, "%4.1f" % zd, "%4.1f" % od, "%6d" % total_refls ]) detector_table_data.append([ "%d" % pg_id, "%5.1f" % dist_m, #"%.4f"%dist_s, "%.4f" % norm_angle_m, "%.4f" % norm_angle_s, "%.4f" % rnorm_angle_m, "%.4f" % rnorm_angle_s, "%.4f" % tnorm_angle_m, "%.4f" % tnorm_angle_s, "%10.6f" % rotz_m, "%.6f" % rotz_s, #"%9.1f"%fo_m, "%5.3f"%fo_s, #"%9.1f"%so_m, "%5.3f"%so_s, "%9.3f" % fo_s, "%9.3f" % so_s, "%9.1f" % zo_m, "%9.1f" % zo_s, "%9.3f" % o_s, "%6d" % total_refls ]) # Set up table output table_d = { d: row for d, row in zip(pg_bc_dists, congruence_table_data) } table_header = [ "PanelG", "Dist", "Normal", "RNormal", "TNormal", "Z rot", "Delta", "Delta", "Delta", "Delta", "N" ] table_header2 = [ "Id", "", "Angle", "Angle", "Angle", "Angle", "F", "S", "Z", "O", "Refls" ] table_header3 = [ "", "(mm)", "(mm)", "(deg)", "(deg)", "(microns)", "(microns)", "(microns)", "(microns)", "(microns)", "" ] congruence_table_data = [table_header, table_header2, table_header3] congruence_table_data.extend([table_d[key] for key in sorted(table_d)]) table_d = {d: row for d, row in zip(pg_bc_dists, detector_table_data)} table_header = [ "PanelG", "Dist", "Normal", "Normal", "RNormal", "RNormal", "TNormal", "TNormal", "RotZ", "RotZ", "F Offset", "S Offset", "Z Offset", "Z Offset", "Offset", "N" ] table_header2 = [ "Id", "", "", "Sigma", "", "Sigma", "", "Sigma", "", "Sigma", "Sigma", "Sigma", "", "Sigma", "Sigma", "Refls" ] table_header3 = [ "", "(mm)", "(deg)", "(deg)", "(deg)", "(deg)", "(deg)", "(deg)", "(deg)", "(deg)", "(microns)", "(microns)", "(microns)", "(microns)", "(microns)", "" ] detector_table_data = [table_header, table_header2, table_header3] detector_table_data.extend([table_d[key] for key in sorted(table_d)]) table_d = {d: row for d, row in zip(pg_bc_dists, rmsds_table_data)} table_header = ["PanelG"] table_header2 = ["Id"] table_header3 = [""] for i in xrange(len(detectors)): table_header.extend(["D%d" % i] * 4) table_header2.extend(["RMSD", "rRMSD", "tRMSD", "N refls"]) table_header3.extend(["(microns)"] * 3) table_header3.append("") rmsds_table_data = [table_header, table_header2, table_header3] rmsds_table_data.extend([table_d[key] for key in sorted(table_d)]) if len(all_refls_count) > 1: r1 = ["Weighted mean"] r2 = ["Weighted stddev"] r1.append("") r2.append("") #r1.append("") #r2.append("") stats = flex.mean_and_variance(all_delta_normals, all_refls_count.as_double()) r1.append("%.4f" % stats.mean()) r2.append("%.4f" % stats.gsl_stats_wsd()) stats = flex.mean_and_variance(all_rdelta_normals, all_refls_count.as_double()) r1.append("%.4f" % stats.mean()) r2.append("%.4f" % stats.gsl_stats_wsd()) stats = flex.mean_and_variance(all_tdelta_normals, all_refls_count.as_double()) r1.append("%.4f" % stats.mean()) r2.append("%.4f" % stats.gsl_stats_wsd()) stats = flex.mean_and_variance(all_z_angles, all_refls_count.as_double()) r1.append("%.4f" % stats.mean()) r2.append("%.4f" % stats.gsl_stats_wsd()) stats = flex.mean_and_variance(all_f_deltas, all_refls_count.as_double()) r1.append("%4.1f" % stats.mean()) r2.append("%4.1f" % stats.gsl_stats_wsd()) stats = flex.mean_and_variance(all_s_deltas, all_refls_count.as_double()) r1.append("%4.1f" % stats.mean()) r2.append("%4.1f" % stats.gsl_stats_wsd()) stats = flex.mean_and_variance(all_z_deltas, all_refls_count.as_double()) r1.append("%4.1f" % stats.mean()) r2.append("%4.1f" % stats.gsl_stats_wsd()) stats = flex.mean_and_variance(all_deltas, all_refls_count.as_double()) r1.append("%4.1f" % stats.mean()) r2.append("%4.1f" % stats.gsl_stats_wsd()) r1.append("") r2.append("") congruence_table_data.append(r1) congruence_table_data.append(r2) congruence_table_data.append([ "Mean", "", "", "", "", "", "", "", "", "", "", "%6.1f" % flex.mean(all_refls_count.as_double()) ]) from libtbx import table_utils print "Congruence statistics, I.E. the differences between the input detectors:" print table_utils.format(congruence_table_data, has_header=3, justify='center', delim=" ") print "PanelG Id: panel group id or panel id, depending on hierarchy_level. For each panel group, statistics are computed between the matching panel groups between the two input experiments." print "Dist: distance from center of panel group to the beam center" print "Dist Sigma: weighted standard deviation of the measurements used to compute Dist" print "Normal angle: angle between the normal vectors of matching panel groups." print "RNormal angle: radial component of the angle between the normal vectors of matching panel groups" print "TNormal angle: transverse component of the angle between the normal vectors of matching panel groups" print "Z rot: angle between the XY components of the fast axes of the panel groups." print "Delta F: shift between matching panel groups along the detector fast axis." print "Delta S: shift between matching panel groups along the detector slow axis." print "Delta Z: Z shift between matching panel groups along the detector normal." print "Delta O: Overall shift between matching panel groups along the detector normal." print "N refls: number of reflections summed between both matching panel groups. This number is used as a weight when computing means and standard deviations." print print if len(all_weights) > 1: r1 = ["All"] r2 = ["Mean"] for data, weights, fmt in [ [None, None, None], #[None,None,None], [all_normal_angles, all_weights.as_double(), "%.4f"], [pg_normal_angle_sigmas, all_refls_count.as_double(), "%.4f"], [all_rnormal_angles, all_weights.as_double(), "%.4f"], [pg_rnormal_angle_sigmas, all_refls_count.as_double(), "%.4f"], [all_tnormal_angles, all_weights.as_double(), "%.4f"], [pg_tnormal_angle_sigmas, all_refls_count.as_double(), "%.4f"], [all_rot_z, all_weights.as_double(), "%10.6f"], [pg_rot_z_sigmas, all_refls_count.as_double(), "%.6f"], #[all_f_offsets, all_weights.as_double(), "%9.1f"], [pg_f_offset_sigmas, all_refls_count.as_double(), "%9.3f"], #[all_s_offsets, all_weights.as_double(), "%9.1f"], [pg_s_offset_sigmas, all_refls_count.as_double(), "%9.3f"], [all_z_offsets, all_weights.as_double(), "%9.1f"], [pg_z_offset_sigmas, all_refls_count.as_double(), "%9.1f"], [pg_offset_sigmas, all_refls_count.as_double(), "%9.1f"] ]: r2.append("") if data is None and weights is None: r1.append("") continue stats = flex.mean_and_variance(data, weights) r1.append(fmt % stats.mean()) r1.append("") r2.append("%6.1f" % flex.mean(all_refls_count.as_double())) detector_table_data.append(r1) detector_table_data.append(r2) print "Detector statistics, I.E. measurements of parameters relative to the detector plane:" print table_utils.format(detector_table_data, has_header=3, justify='center', delim=" ") print "PanelG Id: panel group id or panel id, depending on hierarchy_level. For each panel group, weighted means and weighted standard deviations (Sigmas) for the properties listed below are computed using the matching panel groups between the input experiments." print "Dist: distance from center of panel group to the beam center" print "Dist Sigma: weighted standard deviation of the measurements used to compute Dist" print "Normal Angle: angle between the normal vector of the detector at its root hierarchy level and the normal of the panel group" print "RNormal Angle: radial component of Normal Angle" print "TNormal Angle: transverse component of Normal Angle" print "RotZ: deviation from 90 degrees of the rotation of each panel group around the detector normal" print "F Offset: offset of panel group along the detector's fast axis" print "S Offset: offset of panel group along the detector's slow axis" print "Z Offset: offset of panel group along the detector normal" print "Offset: offset of panel group in F,S,Z space. Sigma is F, S, Z offset sigmas summed in quadrature." print "N refls: number of reflections summed between both matching panel groups. This number is used as a weight when computing means and standard deviations." print "All: weighted mean of the values shown" print print "Sigmas in this table are computed using the standard deviation of 2 measurements (I.E. a panel's Z Offset is measured twice, once in each input dataset). This is related by a factor of sqrt(2)/2 to the mean of the Delta Z parameter in the congruence statistics table above, which is the difference between Z parameters." print row = ["Overall"] for refls in reflections: row.append("%6.1f" % (math.sqrt( flex.sum_sq(refls['difference_vector_norms']) / len(refls)) * 1000)) row.append("%6.1f" % (math.sqrt( flex.sum_sq(refls['radial_displacements']) / len(refls)) * 1000)) row.append("%6.1f" % (math.sqrt( flex.sum_sq(refls['transverse_displacements']) / len(refls)) * 1000)) row.append("%8d" % len(refls)) rmsds_table_data.append(row) print "RMSDs by detector number" print table_utils.format(rmsds_table_data, has_header=3, justify='center', delim=" ") print "PanelG Id: panel group id or panel id, depending on hierarchy_level" print "RMSD: root mean squared deviation between observed and predicted spot locations" print "rRMSD: RMSD of radial components of the observed-predicted vectors" print "tRMSD: RMSD of transverse components of the observed-predicted vectors" print "N refls: number of reflections" # Show stats for detector hierarchy root def _print_vector(v): for i in v: print "%10.5f" % i, print for d_id, d in enumerate(detectors): ori = d.hierarchy().get_origin() norm = d.hierarchy().get_normal() fast = d.hierarchy().get_fast_axis() slow = d.hierarchy().get_slow_axis() print "Detector", d_id, "origin: ", _print_vector(ori) print "Detector", d_id, "normal: ", _print_vector(norm) print "Detector", d_id, "fast axis:", _print_vector(fast) print "Detector", d_id, "slow axis:", _print_vector(slow) # Unit cell statstics lengths = flex.vec3_double() angles = flex.vec3_double() weights = flex.double() for refls, expts in zip(reflections, [d.data for d in params.input.experiments]): for crystal_id, crystal in enumerate(expts.crystals()): lengths.append(crystal.get_unit_cell().parameters()[0:3]) angles.append(crystal.get_unit_cell().parameters()[3:6]) weights.append(len(refls.select(refls['id'] == crystal_id))) print "Unit cell stats (angstroms and degrees), weighted means and standard deviations" for subset, tags in zip([lengths, angles], [["Cell a", "Cell b", "Cell c"], ["Cell alpha", "Cell beta", "Cell gamma"]]): for data, tag in zip(subset.parts(), tags): stats = flex.mean_and_variance(data, weights) print "%s %5.1f +/- %6.3f" % (tag, stats.mean(), stats.gsl_stats_wsd()) if params.tag is None: tag = "" else: tag = "%s " % params.tag if params.show_plots: # Plot the results detector_plot_dict(self.params, detectors[0], refl_counts, u"%sN reflections" % tag, u"%6d", show=False) #detector_plot_dict(self.params, detectors[0], delta_normals, u"%sAngle between normal vectors (\N{DEGREE SIGN})"%tag, u"%.2f\N{DEGREE SIGN}", show=False) detector_plot_dict( self.params, detectors[0], z_angles, u"%sZ rotation angle between panels (\N{DEGREE SIGN})" % tag, u"%.2f\N{DEGREE SIGN}", show=False) detector_plot_dict( self.params, detectors[0], f_deltas, u"%sFast displacements between panels (microns)" % tag, u"%4.1f", show=False) detector_plot_dict( self.params, detectors[0], s_deltas, u"%sSlow displacements between panels (microns)" % tag, u"%4.1f", show=False) detector_plot_dict(self.params, detectors[0], z_offsets_d, u"%sZ offsets along detector normal (microns)" % tag, u"%4.1f", show=False) detector_plot_dict(self.params, detectors[0], z_deltas, u"%sZ displacements between panels (microns)" % tag, u"%4.1f", show=False) detector_plot_dict( self.params, detectors[0], o_deltas, u"%sOverall displacements between panels (microns)" % tag, u"%4.1f", show=False) plt.show()
def run(self): ''' Parse the options. ''' from dials.util.options import flatten_experiments, flatten_datablocks, flatten_reflections # Parse the command line arguments params, options = self.parser.parse_args(show_diff_phil=True) self.params = params experiments = flatten_experiments(params.input.experiments) datablocks = flatten_datablocks(params.input.datablock) reflections = flatten_reflections(params.input.reflections) # Find all detector objects detectors = [] detectors.extend(experiments.detectors()) dbs = [] for datablock in datablocks: dbs.extend(datablock.unique_detectors()) detectors.extend(dbs) # Verify inputs if len(detectors) != 2: raise Sorry( "Please provide a reference and a moving set of experiments and or datablocks" ) reflections = reflections[1] detector = detectors[1] if not hasattr(detector, 'hierarchy'): raise Sorry("Script intended for hierarchical detectors") if params.max_hierarchy_level is None or str( params.max_hierarchy_level).lower() == 'auto': params.max_hierarchy_level = 0 root = detector.hierarchy() while root.is_group(): root = root[0] params.max_hierarchy_level += 1 print "Found", params.max_hierarchy_level + 1, "hierarchy levels" reference_root = detectors[0].hierarchy() moving_root = detector.hierarchy() rori = get_center(reference_root) rf = col(reference_root.get_fast_axis()) rs = col(reference_root.get_slow_axis()) r_norm = col(reference_root.get_normal()) s0 = col( flex.vec3_double([col(b.get_s0()) for b in experiments.beams()]).mean()) summary_table_header = [ "Hierarchy", "Delta XY", "Delta XY", "R Offsets", "R Offsets", "T Offsets", "T Offsets", "Z Offsets", "Z Offsets", "dR Norm", "dR Norm", "dT Norm", "dT Norm", "Local dNorm", "Local dNorm", "Rot Z", "Rot Z" ] summary_table_header2 = [ "Level", "", "Sigma", "", "Sigma", "", "Sigma", "", "Sigma", "", "Sigma", "", "Sigma", "", "Sigma", "", "Sigma" ] summary_table_header3 = [ "", "(microns)", "(microns)", "(microns)", "(microns)", "(microns)", "(microns)", "(microns)", "(microns)", "(deg)", "(deg)", "(deg)", "(deg)", "(deg)", "(deg)", "(deg)", "(deg)" ] summary_table_data = [] summary_table_data.append(summary_table_header) summary_table_data.append(summary_table_header2) summary_table_data.append(summary_table_header3) table_header = [ "PanelG", "BC dist", "Delta XY", "R Offsets", "T Offsets", "Z Offsets", "dR Norm", "dT Norm", "Local dNorm", "Rot Z", "N Refls" ] table_header2 = [ "ID", "(mm)", "(microns)", "(microns)", "(microns)", "(microns)", "(deg)", "(deg)", "(deg)", "(deg)", "" ] from xfel.cftbx.detector.cspad_cbf_tbx import basis def get_full_basis_shift(pg): """Compute basis shift from pg to lab space""" shift = basis(panelgroup=pg) while True: parent = pg.parent() if parent is None: break shift = basis(panelgroup=parent) * shift pg = parent return shift # Iterate through the hierarchy levels for level in range(params.max_hierarchy_level + 1): delta_xy = flex.double() r_offsets = flex.double() t_offsets = flex.double() z_offsets = flex.double() rot_z = flex.double() delta_r_norm = flex.double() delta_t_norm = flex.double() local_dnorm = flex.double() bc_dists = flex.double() weights = flex.double() rows = [] for pg_id, (pg1, pg2) in enumerate( zip(iterate_detector_at_level(reference_root, 0, level), iterate_detector_at_level(moving_root, 0, level))): weight = 0 for panel_id, p in enumerate(iterate_panels(pg2)): weight += len( reflections.select( reflections['panel'] == id_from_name( detector, p.get_name()))) weights.append(weight) bc = col(pg1.get_beam_centre_lab(s0)) ori = get_center(pg1) bc_dist = (ori - bc).length() bc_dists.append(bc_dist) z_dists = [] ori_xy = [] for pg in [pg1, pg2]: ori = pg.get_local_origin() ori_xy.append(col((ori[0], ori[1]))) z_dists.append(ori[2] * 1000) dxy = (ori_xy[1] - ori_xy[0]).length() * 1000 delta_xy.append(dxy) z_off = z_dists[1] - z_dists[0] z_offsets.append(z_off) pgo1 = col(pg1.get_origin()) ro_pgo = pgo1 - rori # vector from the detector origin to the panel group origin if ro_pgo.length() == 0: radial = col((0, 0, 0)) transverse = col((0, 0, 0)) else: radial = ( (rf.dot(ro_pgo) * rf) + (rs.dot(ro_pgo) * rs) ).normalize() # component of ro_pgo in rf rs plane transverse = r_norm.cross(radial).normalize() # now radial and transverse are vectors othogonal to each other and the detector normal, such that # radial points at the panel group origin # compute shift in local frame, then convert that shift to lab space, then make it relative to the reference's origin, in lab space lpgo1 = col(pg1.get_local_origin()) lpgo2 = col(pg2.get_local_origin()) delta_pgo = (get_full_basis_shift(pg1) * (lpgo2 - lpgo1)) - pgo1 # v is the component of delta_pgo along the radial vector v = (radial.dot(delta_pgo) * radial) r_offset = v.length() * 1000 angle = r_norm.angle(v, deg=True) if r_norm.cross(v).dot(transverse) < 0: r_offset = -r_offset r_offsets.append(r_offset) # v is the component of delta_pgo along the transverse vector v = (transverse.dot(delta_pgo) * transverse) t_offset = v.length() * 1000 angle = r_norm.angle(v, deg=True) if r_norm.cross(v).dot(radial) < 0: t_offset = -t_offset t_offsets.append(t_offset) pgn1 = col(pg1.get_normal()) pgf1 = col(pg1.get_fast_axis()) pgs1 = col(pg1.get_slow_axis()) pgn2 = col(pg2.get_normal()) pgf2 = col(pg2.get_fast_axis()) # v1 and v2 are the component of pgf1 and pgf2 in the rf rs plane v1 = (rf.dot(pgf1) * rf) + (rs.dot(pgf1) * rs) v2 = (rf.dot(pgf2) * rf) + (rs.dot(pgf2) * rs) rz = v1.angle(v2, deg=True) rot_z.append(rz) # v1 and v2 are the components of pgn1 and pgn2 in the r_norm radial plane v1 = (r_norm.dot(pgn1) * r_norm) + (radial.dot(pgn1) * radial) v2 = (r_norm.dot(pgn2) * r_norm) + (radial.dot(pgn2) * radial) drn = v1.angle(v2, deg=True) if v2.cross(v1).dot(transverse) < 0: drn = -drn delta_r_norm.append(drn) # v1 and v2 are the components of pgn1 and pgn2 in the r_norm transverse plane v1 = (r_norm.dot(pgn1) * r_norm) + (transverse.dot(pgn1) * transverse) v2 = (r_norm.dot(pgn2) * r_norm) + (transverse.dot(pgn2) * transverse) dtn = v1.angle(v2, deg=True) if v2.cross(v1).dot(radial) < 0: dtn = -dtn delta_t_norm.append(dtn) # Determine angle between normals in local space lpgf1 = col(pg1.get_local_fast_axis()) lpgs1 = col(pg1.get_local_slow_axis()) lpgn1 = lpgf1.cross(lpgs1) lpgf2 = col(pg2.get_local_fast_axis()) lpgs2 = col(pg2.get_local_slow_axis()) lpgn2 = lpgf2.cross(lpgs2) ldn = lpgn1.angle(lpgn2, deg=True) local_dnorm.append(ldn) row = [ "%3d" % pg_id, "%6.1f" % bc_dist, "%6.1f" % dxy, "%6.1f" % r_offset, "%6.1f" % t_offset, "%6.1f" % z_off, "%.4f" % drn, "%.4f" % dtn, "%.4f" % ldn, "%.4f" % rz, "%8d" % weight ] rows.append(row) wm_row = ["Weighted mean", ""] ws_row = ["Weighted stddev", ""] s_row = ["%d" % level] iterable = zip([ delta_xy, r_offsets, t_offsets, z_offsets, delta_r_norm, delta_t_norm, local_dnorm, rot_z ], [ "%6.1f", "%6.1f", "%6.1f", "%6.1f", "%.4f", "%.4f", "%.4f", "%.4f" ]) if len(z_offsets) == 0: wm_row.extend(["%6.1f" % 0] * 8) ws_row.extend(["%6.1f" % 0] * 8) s_row.extend(["%6.1f" % 0] * 8) elif len(z_offsets) == 1: for data, fmt in iterable: wm_row.append(fmt % data[0]) ws_row.append(fmt % 0) s_row.append(fmt % data[0]) s_row.append(fmt % 0) else: for data, fmt in iterable: stats = flex.mean_and_variance(data, weights) wm_row.append(fmt % stats.mean()) ws_row.append(fmt % stats.gsl_stats_wsd()) s_row.append(fmt % stats.mean()) s_row.append(fmt % stats.gsl_stats_wsd()) wm_row.append("") ws_row.append("") summary_table_data.append(s_row) table_data = [table_header, table_header2] table_d = {d: row for d, row in zip(bc_dists, rows)} table_data.extend([table_d[key] for key in sorted(table_d)]) table_data.append(wm_row) table_data.append(ws_row) from libtbx import table_utils print "Hierarchy level %d Detector shifts" % level print table_utils.format(table_data, has_header=2, justify='center', delim=" ") print "Detector shifts summary" print table_utils.format(summary_table_data, has_header=3, justify='center', delim=" ") print print """
def run(self): '''Execute the script.''' from dxtbx.datablock import DataBlockTemplateImporter from dials.util.options import flatten_datablocks from dials.util import log from logging import info from time import time from libtbx.utils import Abort # Parse the command line params, options = self.parser.parse_args(show_diff_phil=False) datablocks = flatten_datablocks(params.input.datablock) # Check we have some filenames if len(datablocks) == 0: # Check if a template has been set and print help if not, otherwise try to # import the images based on the template input if len(params.input.template) == 0: self.parser.print_help() exit(0) else: importer = DataBlockTemplateImporter(params.input.template, options.verbose) datablocks = importer.datablocks # Save the options self.options = options self.params = params self.load_reference_geometry() st = time() # Import stuff if len(datablocks) == 0: raise Abort('No datablocks specified') elif len(datablocks) > 1: raise Abort('Only 1 datablock can be processed at a time.') datablock = datablocks[0] if self.reference_detector is not None: for imageset in datablock.extract_imagesets(): imageset.set_detector(self.reference_detector) # Configure logging log.config(params.verbosity, info='dials.process.log', debug='dials.process.debug.log') # Log the diff phil diff_phil = self.parser.diff_phil.as_str() if diff_phil is not '': info('The following parameters have been modified:\n') info(diff_phil) if self.params.output.datablock_filename: from dxtbx.datablock import DataBlockDumper dump = DataBlockDumper(datablock) dump.as_json(self.params.output.datablock_filename) # Do the processing observed = self.find_spots(datablock) experiments, indexed = self.index(datablock, observed) experiments, indexed = self.refine(experiments, indexed) integrated = self.integrate(experiments, indexed) # Total Time info("") info("Total Time Taken = %f seconds" % (time() - st))
def run(self): ''' Extract the shoeboxes. ''' from dials.util.options import flatten_reflections from dials.util.options import flatten_experiments from dials.util.options import flatten_datablocks from dials.util import log from dials.array_family import flex from libtbx.utils import Sorry # Parse the command line params, options = self.parser.parse_args(show_diff_phil=False) # Configure logging log.config() # Log the diff phil diff_phil = self.parser.diff_phil.as_str() if diff_phil is not '': logger.info('The following parameters have been modified:\n') logger.info(diff_phil) # Get the data reflections = flatten_reflections(params.input.reflections) experiments = flatten_experiments(params.input.experiments) datablocks = flatten_datablocks(params.input.datablock) if not any([experiments, datablocks, reflections]): self.parser.print_help() exit(0) elif experiments and datablocks: raise Sorry('Both experiment list and datablocks set') elif len(experiments) > 1: raise Sorry('More than 1 experiment set') elif len(datablocks) > 1: raise Sorry('More than 1 datablock set') elif len(experiments) == 1: imageset = experiments[0].imageset elif len(datablocks) == 1: imagesets = datablocks[0].extract_imagesets() if len(imagesets) != 1: raise Sorry('Need 1 imageset, got %d' % len(imagesets)) imageset = imagesets[0] if len(reflections) != 1: raise Sorry('Need 1 reflection table, got %d' % len(reflections)) else: reflections = reflections[0] # Check the reflections contain the necessary stuff assert ("bbox" in reflections) assert ("panel" in reflections) # Get some models detector = imageset.get_detector() scan = imageset.get_scan() frame0, frame1 = scan.get_array_range() # Add some padding but limit to image volume if params.padding > 0: logger.info('Adding %d pixels as padding' % params.padding) x0, x1, y0, y1, z0, z1 = reflections['bbox'].parts() x0 -= params.padding x1 += params.padding y0 -= params.padding y1 += params.padding panel = reflections['panel'] for i in range(len(reflections)): width, height = detector[panel[i]].get_image_size() if x0[i] < 0: x0[i] = 0 if x1[i] > width: x1[i] = width if y0[i] < 0: y0[i] = 0 if y1[i] > height: y1[i] = height reflections['bbox'] = flex.int6(x0, x1, y0, y1, z0, z1) # Now iterate through the images, masking the shoebox pixels as necessary, # then model the background & compute intensity statistics x0, x1, y0, y1, z0, z1 = reflections['bbox'].parts() for frame in range(frame0, frame1): data = imageset.get_raw_data(frame)[0] mask = (data < 0) data = data.as_double() sel = (z0 <= frame) & (z1 >= frame) _x0 = x0.select(sel) _x1 = x1.select(sel) _y0 = y0.select(sel) _y1 = y1.select(sel) for __x0, __x1, __y0, __y1 in zip(_x0, _x1, _y0, _y1): for y in range(__y0, __y1): for x in range(__x0, __x1): data[y, x] = 0.0 mask[y, x] = True imask = (~mask).as_1d().as_int() imask.reshape(data.accessor()) from dials.algorithms.image.filter import summed_area # smooth over scale corresponding to max shoebox size d = max(flex.max(_x1 - _x0), flex.max(_y1 - _y0)) summed_background = summed_area(data, (d, d)) summed_mask = summed_area(imask, (d, d)) mean_background = (summed_background / summed_mask.as_double()) data.as_1d().set_selected(mask.as_1d(), mean_background.as_1d()) print flex.sum(data.select(data.as_1d() > 0))
def run(args): from dials.util.options import OptionParser from dials.util.options import flatten_datablocks from dials.util.options import flatten_experiments from dials.util.options import flatten_reflections import libtbx.load_env usage = "%s [options] datablock.json reflections.pickle" % ( libtbx.env.dispatcher_name) parser = OptionParser(usage=usage, phil=phil_scope, read_datablocks=True, read_experiments=True, read_reflections=True, check_format=False, epilog=help_message) params, options = parser.parse_args(show_diff_phil=True) datablocks = flatten_datablocks(params.input.datablock) experiments = flatten_experiments(params.input.experiments) reflections = flatten_reflections(params.input.reflections) if (len(datablocks) == 0 and len(experiments) == 0) or len(reflections) == 0: parser.print_help() exit(0) if len(datablocks) == 0 and len(experiments) > 0: imagesets = experiments.imagesets() crystals = experiments.crystals() else: imagesets = [] crystals = None for datablock in datablocks: imagesets.extend(datablock.extract_imagesets()) if len(reflections) > 1: assert len(reflections) == len(imagesets) for i in range(len(reflections)): reflections[i]['imageset_id'] = flex.int(len(reflections[i]), i) if i > 0: reflections[0].extend(reflections[i]) elif 'imageset_id' not in reflections[0]: reflections[0]['imageset_id'] = reflections[0]['id'] reflections[0]['id'] = flex.int(reflections[0].size(), -1) reflections = reflections[0] import wxtbx.app a = wxtbx.app.CCTBXApp(0) a.settings = params f = ReciprocalLatticeViewer(None, -1, "Reflection data viewer", size=(1024, 768)) f.load_models(imagesets, reflections, crystals) f.Show() a.SetTopWindow(f) #a.Bind(wx.EVT_WINDOW_DESTROY, lambda evt: tb_icon.Destroy(), f) a.MainLoop()
def run(args): from dials.util.options import OptionParser from dials.util.options import flatten_experiments from dials.util.options import flatten_datablocks from dials.util.options import flatten_reflections import libtbx.load_env usage = "%s [options] datablock.json | experiments.json | image_*.cbf" %( libtbx.env.dispatcher_name) parser = OptionParser( usage=usage, phil=phil_scope, read_experiments=True, read_datablocks=True, read_datablocks_from_images=True, read_reflections=True, check_format=False, epilog=help_message) params, options = parser.parse_args(show_diff_phil=True) experiments = flatten_experiments(params.input.experiments) datablocks = flatten_datablocks(params.input.datablock) reflections = flatten_reflections(params.input.reflections) if len(datablocks) == 0 and len(experiments) == 0 and len(reflections) == 0: parser.print_help() exit() for i_expt, expt in enumerate(experiments): print "Experiment %i:" %i_expt print str(expt.detector) print 'Max resolution (at corners): %f' % ( expt.detector.get_max_resolution(expt.beam.get_s0())) print 'Max resolution (inscribed): %f' % ( expt.detector.get_max_inscribed_resolution(expt.beam.get_s0())) print '' panel_id, (x, y) = beam_centre(expt.detector, expt.beam) if panel_id >= 0 and x is not None and y is not None: if len(expt.detector) > 1: beam_centre_str = "Beam centre: panel %i, (%.2f,%.2f)" %(panel_id, x, y) else: beam_centre_str = "Beam centre: (%.2f,%.2f)" %(x, y) else: beam_centre_str = "" print str(expt.beam) + beam_centre_str + '\n' if expt.scan is not None: print expt.scan if expt.goniometer is not None: print expt.goniometer expt.crystal.show(show_scan_varying=params.show_scan_varying) if expt.crystal.num_scan_points: from scitbx.array_family import flex from cctbx import uctbx abc = flex.vec3_double() angles = flex.vec3_double() for n in range(expt.crystal.num_scan_points): a, b, c, alpha, beta, gamma = expt.crystal.get_unit_cell_at_scan_point(n).parameters() abc.append((a, b, c)) angles.append((alpha, beta, gamma)) a, b, c = abc.mean() alpha, beta, gamma = angles.mean() mean_unit_cell = uctbx.unit_cell((a, b, c, alpha, beta, gamma)) print " Average unit cell: %s" %mean_unit_cell print for datablock in datablocks: if datablock.format_class() is not None: print 'Format: %s' %datablock.format_class() imagesets = datablock.extract_imagesets() for imageset in imagesets: try: print imageset.get_template() except Exception: pass detector = imageset.get_detector() print str(detector) + 'Max resolution: %f\n' %( detector.get_max_resolution(imageset.get_beam().get_s0())) if params.show_panel_distance: for ipanel, panel in enumerate(detector): from scitbx import matrix fast = matrix.col(panel.get_fast_axis()) slow = matrix.col(panel.get_slow_axis()) normal = fast.cross(slow) origin = matrix.col(panel.get_origin()) distance = origin.dot(normal) fast_origin = - (origin - distance * normal).dot(fast) slow_origin = - (origin - distance * normal).dot(slow) print 'Panel %d: distance %.2f origin %.2f %.2f' % \ (ipanel, distance, fast_origin, slow_origin) print '' panel_id, (x, y) = beam_centre(detector, imageset.get_beam()) if panel_id >= 0 and x is not None and y is not None: if len(detector) > 1: beam_centre_str = "Beam centre: panel %i, (%.2f,%.2f)" %(panel_id, x, y) else: beam_centre_str = "Beam centre: (%.2f,%.2f)" %(x, y) else: beam_centre_str = "" print str(imageset.get_beam()) + beam_centre_str + '\n' if imageset.get_scan() is not None: print imageset.get_scan() if imageset.get_goniometer() is not None: print imageset.get_goniometer() from libtbx.containers import OrderedDict, OrderedSet formats = OrderedDict([ ('miller_index', '%i, %i, %i'), ('d','%.2f'), ('dqe','%.3f'), ('id','%i'), ('imageset_id','%i'), ('panel','%i'), ('flags', '%i'), ('background.mean', '%.1f'), ('background.dispersion','%.1f'), ('background.mse', '%.1f'), ('background.sum.value', '%.1f'), ('background.sum.variance', '%.1f'), ('intensity.prf.value','%.1f'), ('intensity.prf.variance','%.1f'), ('intensity.sum.value','%.1f'), ('intensity.sum.variance','%.1f'), ('intensity.cor.value','%.1f'), ('intensity.cor.variance','%.1f'), ('lp','%.3f'), ('num_pixels.background','%i'), ('num_pixels.background_used','%i'), ('num_pixels.foreground','%i'), ('num_pixels.valid','%i'), ('partial_id','%i'), ('partiality','%.4f'), ('profile.correlation','%.3f'), ('profile.rmsd','%.3f'), ('xyzcal.mm','%.2f, %.2f, %.2f'), ('xyzcal.px','%.2f, %.2f, %.2f'), ('delpsical.rad','%.3f'), ('delpsical2','%.3f'), ('xyzobs.mm.value','%.2f, %.2f, %.2f'), ('xyzobs.mm.variance','%.4e, %.4e, %.4e'), ('xyzobs.px.value','%.2f, %.2f, %.2f'), ('xyzobs.px.variance','%.4f, %.4f, %.4f'), ('s1','%.4f, %.4f, %.4f'), ('rlp','%.4f, %.4f, %.4f'), ('zeta','%.3f'), ('x_resid','%.3f'), ('x_resid2','%.3f'), ('y_resid','%.3f'), ('y_resid2','%.3f'), ]) for rlist in reflections: from cctbx.array_family import flex print print "Reflection list contains %i reflections" %(len(rlist)) rows = [["Column", "min", "max", "mean"]] for k, col in rlist.cols(): if type(col) in (flex.double, flex.int, flex.size_t): if type(col) in (flex.int, flex.size_t): col = col.as_double() rows.append([k, formats[k] %flex.min(col), formats[k] %flex.max(col), formats[k]%flex.mean(col)]) elif type(col) in (flex.vec3_double, flex.miller_index): if type(col) == flex.miller_index: col = col.as_vec3_double() rows.append([k, formats[k] %col.min(), formats[k] %col.max(), formats[k]%col.mean()]) from libtbx import table_utils print table_utils.format(rows, has_header=True, prefix="| ", postfix=" |") intensity_keys = ( 'miller_index', 'd', 'intensity.prf.value', 'intensity.prf.variance', 'intensity.sum.value', 'intensity.sum.variance', 'background.mean', 'profile.correlation', 'profile.rmsd' ) profile_fit_keys = ('miller_index', 'd',) centroid_keys = ( 'miller_index', 'd', 'xyzcal.mm', 'xyzcal.px', 'xyzobs.mm.value', 'xyzobs.mm.variance', 'xyzobs.px.value', 'xyzobs.px.variance' ) keys_to_print = OrderedSet() if params.show_intensities: for k in intensity_keys: keys_to_print.add(k) if params.show_profile_fit: for k in profile_fit_keys: keys_to_print.add(k) if params.show_centroids: for k in centroid_keys: keys_to_print.add(k) if params.show_all_reflection_data: for k in formats: keys_to_print.add(k) def format_column(key, data, format_strings=None): if isinstance(data, flex.vec3_double): c_strings = [c.as_string(format_strings[i].strip()) for i, c in enumerate(data.parts())] elif isinstance(data, flex.miller_index): c_strings = [c.as_string(format_strings[i].strip()) for i, c in enumerate(data.as_vec3_double().parts())] elif isinstance(data, flex.size_t): c_strings = [data.as_int().as_string(format_strings[0].strip())] else: c_strings = [data.as_string(format_strings[0].strip())] column = flex.std_string() max_element_lengths = [c.max_element_length() for c in c_strings] for i in range(len(c_strings[0])): column.append(('%%%is' %len(key)) %', '.join( ('%%%is' %max_element_lengths[j]) %c_strings[j][i] for j in range(len(c_strings)))) return column if keys_to_print: keys = [k for k in keys_to_print if k in rlist] rows = [keys] max_reflections = len(rlist) if params.max_reflections is not None: max_reflections = min(len(rlist), params.max_reflections) columns = [] for k in keys: columns.append(format_column(k, rlist[k], format_strings=formats[k].split(','))) print print "Printing %i of %i reflections:" %(max_reflections, len(rlist)) for j in range(len(columns)): key = keys[j] width = max(len(key), columns[j].max_element_length()) print ("%%%is" %width) %key, print for i in range(max_reflections): for j in range(len(columns)): print columns[j][i], print return
def run(self): '''Execute the script.''' from dials.array_family import flex from dials.util.options import flatten_datablocks from time import time from dials.util import log from libtbx.utils import Sorry start_time = time() # Parse the command line params, options = self.parser.parse_args(show_diff_phil=False) # Configure the logging log.config(params.verbosity, info=params.output.log, debug=params.output.debug_log) from dials.util.version import dials_version logger.info(dials_version()) # Log the diff phil diff_phil = self.parser.diff_phil.as_str() if diff_phil is not '': logger.info('The following parameters have been modified:\n') logger.info(diff_phil) # Ensure we have a data block datablocks = flatten_datablocks(params.input.datablock) if len(datablocks) == 0: self.parser.print_help() return elif len(datablocks) != 1: raise Sorry('only 1 datablock can be processed at a time') # Loop through all the imagesets and find the strong spots reflections = flex.reflection_table.from_observations( datablocks[0], params) # Delete the shoeboxes if not params.output.shoeboxes: del reflections['shoebox'] # ascii spot count per image plot from dials.util.ascii_art import spot_counts_per_image_plot for i, imageset in enumerate(datablocks[0].extract_imagesets()): ascii_plot = spot_counts_per_image_plot( reflections.select(reflections['id'] == i)) if len(ascii_plot): logger.info( '\nHistogram of per-image spot count for imageset %i:' % i) logger.info(ascii_plot) # Save the reflections to file logger.info('\n' + '-' * 80) reflections.as_pickle(params.output.reflections) logger.info('Saved {0} reflections to {1}'.format( len(reflections), params.output.reflections)) # Save the datablock if params.output.datablock: from dxtbx.datablock import DataBlockDumper logger.info('Saving datablocks to {0}'.format( params.output.datablock)) dump = DataBlockDumper(datablocks) dump.as_file(params.output.datablock) # Print some per image statistics if params.per_image_statistics: from dials.algorithms.spot_finding import per_image_analysis from cStringIO import StringIO s = StringIO() for i, imageset in enumerate(datablocks[0].extract_imagesets()): print >> s, "Number of centroids per image for imageset %i:" % i stats = per_image_analysis.stats_imageset( imageset, reflections.select(reflections['id'] == i), resolution_analysis=False) per_image_analysis.print_table(stats, out=s) logger.info(s.getvalue()) # Print the time logger.info("Time Taken: %f" % (time() - start_time))
def run(args): from dials.util.options import OptionParser from dials.util.options import flatten_datablocks from dials.util.options import flatten_experiments from dials.util.options import flatten_reflections from dials.util import log import libtbx.load_env usage = "%s [options] datablock.json reflections.pickle" % ( libtbx.env.dispatcher_name) parser = OptionParser(usage=usage, phil=phil_scope, read_datablocks=True, read_experiments=True, read_reflections=True, check_format=False, epilog=help_message) params, options = parser.parse_args() datablocks = flatten_datablocks(params.input.datablock) experiments = flatten_experiments(params.input.experiments) reflections = flatten_reflections(params.input.reflections) if (len(datablocks) == 0 and len(experiments) == 0) or len(reflections) == 0: parser.print_help() exit(0) # Configure the logging log.config(info='dials.rl_png.log') # Log the diff phil diff_phil = parser.diff_phil.as_str() if diff_phil is not '': logger.info('The following parameters have been modified:\n') logger.info(diff_phil) reflections = reflections[0] if len(datablocks) == 0 and len(experiments) > 0: imagesets = experiments.imagesets() else: imagesets = [] for datablock in datablocks: imagesets.extend(datablock.extract_imagesets()) f = ReciprocalLatticePng(settings=params) f.load_models(imagesets, reflections) imageset = imagesets[0] rotation_axis = matrix.col(imageset.get_goniometer().get_rotation_axis()) s0 = matrix.col(imageset.get_beam().get_s0()) e1 = rotation_axis.normalize() e2 = s0.normalize() e3 = e1.cross(e2).normalize() #print e1 #print e2 #print e3 f.viewer.plot('rl_rotation_axis.png', n=e1.elems) f.viewer.plot('rl_beam_vector', n=e2.elems) f.viewer.plot('rl_e3.png', n=e3.elems) n_solutions = params.basis_vector_search.n_solutions if len(experiments): for i, c in enumerate(experiments.crystals()): A = c.get_A() astar = A[:3] bstar = A[3:6] cstar = A[6:9] direct_matrix = A.inverse() a = direct_matrix[:3] b = direct_matrix[3:6] c = direct_matrix[6:9] prefix = '' if len(experiments.crystals()) > 1: prefix = '%i_' % (i + 1) f.viewer.plot('rl_%sa.png' % prefix, n=a) f.viewer.plot('rl_%sb.png' % prefix, n=b) f.viewer.plot('rl_%sc.png' % prefix, n=c) elif n_solutions: from dials.command_line.discover_better_experimental_model \ import run_dps, dps_phil_scope hardcoded_phil = dps_phil_scope.extract() hardcoded_phil.d_min = params.d_min result = run_dps((imagesets[0], reflections, hardcoded_phil)) solutions = [matrix.col(v) for v in result['solutions']] for i in range(min(n_solutions, len(solutions))): v = solutions[i] #if i > 0: #for v1 in solutions[:i-1]: #angle = v.angle(v1, deg=True) #print angle f.viewer.plot('rl_solution_%s.png' % (i + 1), n=v.elems)
# Configure the logging log.config( info=params.output.log, debug=params.output.debug_log) # Print the version number logger.info(dials_version()) # Log the diff phil diff_phil = parser.diff_phil.as_str() if diff_phil is not '': logger.info('The following parameters have been modified:\n') logger.info(diff_phil) # Get the experiments and reflections datablocks = flatten_datablocks(params.input.datablock) experiments = flatten_experiments(params.input.experiments) reflections = flatten_reflections(params.input.reflections) if len(reflections) == 0 and len(experiments) == 0 and len(datablocks) == 0: parser.print_help() exit(0) # Choose the exporter if params.format == 'mtz': exporter = MTZExporter(params, experiments, reflections) elif params.format == 'sadabs': exporter = SadabsExporter(params, experiments, reflections) elif params.format == 'xds_ascii': exporter = XDSASCIIExporter(params, experiments, reflections) elif params.format == 'nxs':
def run(args): from dials.util.options import OptionParser from dials.util.options import flatten_datablocks from dials.util.options import flatten_experiments from dials.util.options import flatten_reflections parser = OptionParser( phil=master_phil, read_datablocks=True, read_experiments=True, read_reflections=True, check_format=False, ) params, options = parser.parse_args(show_diff_phil=True) datablocks = flatten_datablocks(params.input.datablock) experiments = flatten_experiments(params.input.experiments) reflections = flatten_reflections(params.input.reflections)[0] if len(params.input.reflections) == 2: reflections2 = flatten_reflections(params.input.reflections)[1] else: reflections2 = None # find the reflections in the second set that DO NOT match those in the # first set mask, _ = reflections2.match_with_reference(reflections) reflections2 = reflections2.select(~mask) print("{0} reflections from the second set do not match the first".format( len(reflections2))) # reflections2 = reflections2.select(reflections2["miller_index"] == (-7,2,-25)) if len(datablocks) == 0: if len(experiments) > 0: imagesets = experiments.imagesets() else: parser.print_help() return elif len(datablocks) > 1: raise Sorry("Only one DataBlock can be processed at a time") else: imagesets = datablocks[0].extract_imagesets() if len(imagesets) > 1: raise Sorry("Only one ImageSet can be processed at a time") imageset = imagesets[0] import wxtbx.app a = wxtbx.app.CCTBXApp(0) a.settings = params f = PredRelpViewer(None, -1, "Prediction reciprocal lattice viewer", size=(1024, 768)) f.load_reflections2(reflections2) f.load_models(imageset, reflections) f.Show() a.SetTopWindow(f) # a.Bind(wx.EVT_WINDOW_DESTROY, lambda evt: tb_icon.Destroy(), f) a.MainLoop()
def run(self): ''' Extract the shoeboxes. ''' from dials.util.options import flatten_reflections from dials.util.options import flatten_experiments from dials.util.options import flatten_datablocks from dials.util import log from dials.array_family import flex from libtbx.utils import Sorry # Parse the command line params, options = self.parser.parse_args(show_diff_phil=False) # Configure logging log.config() # Log the diff phil diff_phil = self.parser.diff_phil.as_str() if diff_phil is not '': logger.info('The following parameters have been modified:\n') logger.info(diff_phil) # Get the data reflections = flatten_reflections(params.input.reflections) experiments = flatten_experiments(params.input.experiments) datablocks = flatten_datablocks(params.input.datablock) if not any([experiments, datablocks, reflections]): self.parser.print_help() exit(0) elif experiments and datablocks: raise Sorry('Both experiment list and datablocks set') elif len(experiments) > 1: raise Sorry('More than 1 experiment set') elif len(datablocks) > 1: raise Sorry('More than 1 datablock set') elif len(experiments) == 1: imageset = experiments[0].imageset elif len(datablocks) == 1: imagesets = datablocks[0].extract_imagesets() if len(imagesets) != 1: raise Sorry('Need 1 imageset, got %d' % len(imagesets)) imageset = imagesets[0] if len(reflections) != 1: raise Sorry('Need 1 reflection table, got %d' % len(reflections)) else: reflections = reflections[0] # Check the reflections contain the necessary stuff assert("bbox" in reflections) assert("panel" in reflections) # Get some models detector = imageset.get_detector() scan = imageset.get_scan() frame0, frame1 = scan.get_array_range() # Add some padding but limit to image volume if params.padding > 0: logger.info('Adding %d pixels as padding' % params.padding) x0, x1, y0, y1, z0, z1 = reflections['bbox'].parts() x0 -= params.padding x1 += params.padding y0 -= params.padding y1 += params.padding # z0 -= params.padding # z1 += params.padding panel = reflections['panel'] for i in range(len(reflections)): width, height = detector[panel[i]].get_image_size() if x0[i] < 0: x0[i] = 0 if x1[i] > width: x1[i] = width if y0[i] < 0: y0[i] = 0 if y1[i] > height: y1[i] = height if z0[i] < frame0: z0[i] = frame0 if z1[i] > frame1: z1[i] = frame1 reflections['bbox'] = flex.int6(x0, x1, y0, y1, z0, z1) # Save the old shoeboxes if "shoebox" in reflections: old_shoebox = reflections['shoebox'] else: old_shoebox = None # Allocate the shoeboxes reflections["shoebox"] = flex.shoebox( reflections["panel"], reflections["bbox"], allocate=True) # Extract the shoeboxes reflections.extract_shoeboxes(imageset, verbose=True) # Preserve masking if old_shoebox is not None: from dials.algorithms.shoebox import MaskCode logger.info("Applying old shoebox mask") new_shoebox = reflections['shoebox'] for i in range(len(reflections)): bbox0 = old_shoebox[i].bbox bbox1 = new_shoebox[i].bbox mask0 = old_shoebox[i].mask mask1 = new_shoebox[i].mask mask2 = flex.int(mask1.accessor(), 0) x0 = bbox0[0] - bbox1[0] x1 = bbox0[1] - bbox0[0] + x0 y0 = bbox0[2] - bbox1[2] y1 = bbox0[3] - bbox0[2] + y0 z0 = bbox0[4] - bbox1[4] z1 = bbox0[5] - bbox0[4] + z0 mask2[z0:z1,y0:y1,x0:x1] = mask0 mask1 = mask1.as_1d() | mask2.as_1d() if params.padding_is_background: selection = flex.size_t(range(len(mask1))).select(mask1 == MaskCode.Valid) values = flex.int(len(selection), MaskCode.Valid | MaskCode.Background) mask1.set_selected(selection, values) mask1.reshape(new_shoebox[i].mask.accessor()) new_shoebox[i].mask = mask1 # Saving the reflections to disk filename = params.output.reflections logger.info('Saving %d reflections to %s' % (len(reflections), filename)) reflections.as_pickle(filename)
def run(self): '''Execute the script.''' from dials.array_family import flex from dials.util.options import flatten_datablocks from time import time from dials.util import log from libtbx.utils import Sorry start_time = time() # Parse the command line params, options = self.parser.parse_args(show_diff_phil=False) # Configure the logging log.config( params.verbosity, info=params.output.log, debug=params.output.debug_log) from dials.util.version import dials_version logger.info(dials_version()) # Log the diff phil diff_phil = self.parser.diff_phil.as_str() if diff_phil is not '': logger.info('The following parameters have been modified:\n') logger.info(diff_phil) # Ensure we have a data block datablocks = flatten_datablocks(params.input.datablock) if len(datablocks) == 0: self.parser.print_help() return elif len(datablocks) != 1: raise Sorry('only 1 datablock can be processed at a time') # Loop through all the imagesets and find the strong spots reflections = flex.reflection_table.from_observations( datablocks[0], params) # Delete the shoeboxes if not params.output.shoeboxes: del reflections['shoebox'] # ascii spot count per image plot from dials.util.ascii_art import spot_counts_per_image_plot for i, imageset in enumerate(datablocks[0].extract_imagesets()): ascii_plot = spot_counts_per_image_plot( reflections.select(reflections['id'] == i)) if len(ascii_plot): logger.info('\nHistogram of per-image spot count for imageset %i:' %i) logger.info(ascii_plot) # Save the reflections to file logger.info('\n' + '-' * 80) reflections.as_pickle(params.output.reflections) logger.info('Saved {0} reflections to {1}'.format( len(reflections), params.output.reflections)) # Save the datablock if params.output.datablock: from dxtbx.datablock import DataBlockDumper logger.info('Saving datablocks to {0}'.format( params.output.datablock)) dump = DataBlockDumper(datablocks) dump.as_file(params.output.datablock) # Print some per image statistics if params.per_image_statistics: from dials.algorithms.spot_finding import per_image_analysis from cStringIO import StringIO s = StringIO() for i, imageset in enumerate(datablocks[0].extract_imagesets()): print >> s, "Number of centroids per image for imageset %i:" %i stats = per_image_analysis.stats_imageset( imageset, reflections.select(reflections['id'] == i), resolution_analysis=False) per_image_analysis.print_table(stats, out=s) logger.info(s.getvalue()) # Print the time logger.info("Time Taken: %f" % (time() - start_time))
def run(args): from dials.util.options import OptionParser from dials.util.options import flatten_experiments from dials.util.options import flatten_datablocks from dials.util.options import flatten_reflections import libtbx.load_env usage = "%s [options] datablock.json | experiments.json | image_*.cbf" %( libtbx.env.dispatcher_name) parser = OptionParser( usage=usage, phil=phil_scope, read_experiments=True, read_datablocks=True, read_datablocks_from_images=True, read_reflections=True, check_format=False, epilog=help_message) params, options = parser.parse_args(show_diff_phil=True) experiments = flatten_experiments(params.input.experiments) datablocks = flatten_datablocks(params.input.datablock) reflections = flatten_reflections(params.input.reflections) if len(datablocks) == 0 and len(experiments) == 0 and len(reflections) == 0: parser.print_help() exit() for i_expt, expt in enumerate(experiments): print "Experiment %i:" %i_expt print str(expt.detector) print 'Max resolution (at corners): %f' % ( expt.detector.get_max_resolution(expt.beam.get_s0())) print 'Max resolution (inscribed): %f' % ( expt.detector.get_max_inscribed_resolution(expt.beam.get_s0())) if params.show_panel_distance: for ipanel, panel in enumerate(expt.detector): from scitbx import matrix fast = matrix.col(panel.get_fast_axis()) slow = matrix.col(panel.get_slow_axis()) normal = fast.cross(slow) origin = matrix.col(panel.get_origin()) distance = origin.dot(normal) fast_origin = - (origin - distance * normal).dot(fast) slow_origin = - (origin - distance * normal).dot(slow) print 'Panel %d: distance %.2f origin %.2f %.2f' % \ (ipanel, distance, fast_origin, slow_origin) print '' print '' panel_id, (x, y) = beam_centre(expt.detector, expt.beam) if panel_id >= 0 and x is not None and y is not None: if len(expt.detector) > 1: beam_centre_str = "Beam centre: panel %i, (%.2f,%.2f)" %(panel_id, x, y) else: beam_centre_str = "Beam centre: (%.2f,%.2f)" %(x, y) else: beam_centre_str = "" print str(expt.beam) + beam_centre_str + '\n' if expt.scan is not None: print expt.scan if expt.goniometer is not None: print expt.goniometer expt.crystal.show(show_scan_varying=params.show_scan_varying) if expt.crystal.num_scan_points: from scitbx.array_family import flex from cctbx import uctbx abc = flex.vec3_double() angles = flex.vec3_double() for n in range(expt.crystal.num_scan_points): a, b, c, alpha, beta, gamma = expt.crystal.get_unit_cell_at_scan_point(n).parameters() abc.append((a, b, c)) angles.append((alpha, beta, gamma)) a, b, c = abc.mean() alpha, beta, gamma = angles.mean() mean_unit_cell = uctbx.unit_cell((a, b, c, alpha, beta, gamma)) print " Average unit cell: %s" %mean_unit_cell print for datablock in datablocks: if datablock.format_class() is not None: print 'Format: %s' %datablock.format_class() imagesets = datablock.extract_imagesets() for imageset in imagesets: try: print imageset.get_template() except Exception: pass detector = imageset.get_detector() print str(detector) + 'Max resolution: %f\n' %( detector.get_max_resolution(imageset.get_beam().get_s0())) if params.show_panel_distance: for ipanel, panel in enumerate(detector): from scitbx import matrix fast = matrix.col(panel.get_fast_axis()) slow = matrix.col(panel.get_slow_axis()) normal = fast.cross(slow) origin = matrix.col(panel.get_origin()) distance = origin.dot(normal) fast_origin = - (origin - distance * normal).dot(fast) slow_origin = - (origin - distance * normal).dot(slow) print 'Panel %d: distance %.2f origin %.2f %.2f' % \ (ipanel, distance, fast_origin, slow_origin) print '' panel_id, (x, y) = beam_centre(detector, imageset.get_beam()) if panel_id >= 0 and x is not None and y is not None: if len(detector) > 1: beam_centre_str = "Beam centre: panel %i, (%.2f,%.2f)" %(panel_id, x, y) else: beam_centre_str = "Beam centre: (%.2f,%.2f)" %(x, y) else: beam_centre_str = "" print str(imageset.get_beam()) + beam_centre_str + '\n' if imageset.get_scan() is not None: print imageset.get_scan() if imageset.get_goniometer() is not None: print imageset.get_goniometer() from libtbx.containers import OrderedDict, OrderedSet formats = OrderedDict([ ('miller_index', '%i, %i, %i'), ('d','%.2f'), ('dqe','%.3f'), ('id','%i'), ('imageset_id','%i'), ('panel','%i'), ('flags', '%i'), ('background.mean', '%.1f'), ('background.dispersion','%.1f'), ('background.mse', '%.1f'), ('background.sum.value', '%.1f'), ('background.sum.variance', '%.1f'), ('intensity.prf.value','%.1f'), ('intensity.prf.variance','%.1f'), ('intensity.sum.value','%.1f'), ('intensity.sum.variance','%.1f'), ('intensity.cor.value','%.1f'), ('intensity.cor.variance','%.1f'), ('lp','%.3f'), ('num_pixels.background','%i'), ('num_pixels.background_used','%i'), ('num_pixels.foreground','%i'), ('num_pixels.valid','%i'), ('partial_id','%i'), ('partiality','%.4f'), ('profile.correlation','%.3f'), ('profile.rmsd','%.3f'), ('xyzcal.mm','%.2f, %.2f, %.2f'), ('xyzcal.px','%.2f, %.2f, %.2f'), ('delpsical.rad','%.3f'), ('delpsical2','%.3f'), ('xyzobs.mm.value','%.2f, %.2f, %.2f'), ('xyzobs.mm.variance','%.4e, %.4e, %.4e'), ('xyzobs.px.value','%.2f, %.2f, %.2f'), ('xyzobs.px.variance','%.4f, %.4f, %.4f'), ('s1','%.4f, %.4f, %.4f'), ('rlp','%.4f, %.4f, %.4f'), ('zeta','%.3f'), ('x_resid','%.3f'), ('x_resid2','%.3f'), ('y_resid','%.3f'), ('y_resid2','%.3f'), ]) for rlist in reflections: from cctbx.array_family import flex print print "Reflection list contains %i reflections" %(len(rlist)) rows = [["Column", "min", "max", "mean"]] for k, col in rlist.cols(): if type(col) in (flex.double, flex.int, flex.size_t): if type(col) in (flex.int, flex.size_t): col = col.as_double() rows.append([k, formats[k] %flex.min(col), formats[k] %flex.max(col), formats[k]%flex.mean(col)]) elif type(col) in (flex.vec3_double, flex.miller_index): if type(col) == flex.miller_index: col = col.as_vec3_double() rows.append([k, formats[k] %col.min(), formats[k] %col.max(), formats[k]%col.mean()]) from libtbx import table_utils print table_utils.format(rows, has_header=True, prefix="| ", postfix=" |") intensity_keys = ( 'miller_index', 'd', 'intensity.prf.value', 'intensity.prf.variance', 'intensity.sum.value', 'intensity.sum.variance', 'background.mean', 'profile.correlation', 'profile.rmsd' ) profile_fit_keys = ('miller_index', 'd',) centroid_keys = ( 'miller_index', 'd', 'xyzcal.mm', 'xyzcal.px', 'xyzobs.mm.value', 'xyzobs.mm.variance', 'xyzobs.px.value', 'xyzobs.px.variance' ) keys_to_print = OrderedSet() if params.show_intensities: for k in intensity_keys: keys_to_print.add(k) if params.show_profile_fit: for k in profile_fit_keys: keys_to_print.add(k) if params.show_centroids: for k in centroid_keys: keys_to_print.add(k) if params.show_all_reflection_data: for k in formats: keys_to_print.add(k) def format_column(key, data, format_strings=None): if isinstance(data, flex.vec3_double): c_strings = [c.as_string(format_strings[i].strip()) for i, c in enumerate(data.parts())] elif isinstance(data, flex.miller_index): c_strings = [c.as_string(format_strings[i].strip()) for i, c in enumerate(data.as_vec3_double().parts())] elif isinstance(data, flex.size_t): c_strings = [data.as_int().as_string(format_strings[0].strip())] else: c_strings = [data.as_string(format_strings[0].strip())] column = flex.std_string() max_element_lengths = [c.max_element_length() for c in c_strings] for i in range(len(c_strings[0])): column.append(('%%%is' %len(key)) %', '.join( ('%%%is' %max_element_lengths[j]) %c_strings[j][i] for j in range(len(c_strings)))) return column if keys_to_print: keys = [k for k in keys_to_print if k in rlist] rows = [keys] max_reflections = len(rlist) if params.max_reflections is not None: max_reflections = min(len(rlist), params.max_reflections) columns = [] for k in keys: columns.append(format_column(k, rlist[k], format_strings=formats[k].split(','))) print print "Printing %i of %i reflections:" %(max_reflections, len(rlist)) for j in range(len(columns)): key = keys[j] width = max(len(key), columns[j].max_element_length()) print ("%%%is" %width) %key, print for i in range(max_reflections): for j in range(len(columns)): print columns[j][i], print return
def run(args): import libtbx.load_env usage = """\ %s datablock.json reflections.pickle [options]""" %libtbx.env.dispatcher_name from dials.util.options import OptionParser from dials.util.options import flatten_datablocks from dials.util.options import flatten_experiments from dials.util.options import flatten_reflections from scitbx.array_family import flex from scitbx import matrix from libtbx.utils import Sorry parser = OptionParser( usage=usage, phil=master_phil_scope, read_datablocks=True, read_experiments=True, read_reflections=True, check_format=False) params, options = parser.parse_args(show_diff_phil=True) datablocks = flatten_datablocks(params.input.datablock) reflections = flatten_reflections(params.input.reflections) experiments = flatten_experiments(params.input.experiments) if len(datablocks) == 1: imageset = datablocks[0].extract_imagesets()[0] elif len(datablocks) > 1: raise Sorry("Only one DataBlock can be processed at a time") elif len(experiments.imagesets()) > 0: imageset = experiments.imagesets()[0] imageset.set_detector(experiments[0].detector) imageset.set_beam(experiments[0].beam) imageset.set_goniometer(experiments[0].goniometer) else: parser.print_help() return detector = imageset.get_detector() scan = imageset.get_scan() panel_origin_shifts = {0: (0,0,0)} try: hierarchy = detector.hierarchy() except AttributeError: hierarchy = None for i_panel in range(1, len(detector)): origin_shift = matrix.col(detector[0].get_origin()) \ - matrix.col(detector[i_panel].get_origin()) panel_origin_shifts[i_panel] = origin_shift observed_xyz = flex.vec3_double() predicted_xyz = flex.vec3_double() for reflection_list in reflections: if len(params.scan_range): sel = flex.bool(len(reflection_list), False) xyzcal_px = None xyzcal_px = None if 'xyzcal.px' in reflection_list: xyzcal_px = reflection_list['xyzcal.px'] if 'xyzobs.px.value' in reflection_list: xyzobs_px = reflection_list['xyzobs.px.value'] if xyzcal_px is not None and not xyzcal_px.norms().all_eq(0): centroids_frame = xyzcal_px.parts()[2] elif xyzobs_px is not None and not xyzobs_px.norms().all_eq(0): centroids_frame = xyzobs_px.parts()[2] else: raise Sorry("No pixel coordinates given in input reflections.") reflections_in_range = False for scan_range in params.scan_range: if scan_range is None: continue range_start, range_end = scan_range sel |= ((centroids_frame >= range_start) & (centroids_frame < range_end)) reflection_list = reflection_list.select(sel) if params.first_n_reflections is not None: centroid_positions = reflection_list.centroid_position() centroids_frame = centroid_positions.parts()[2] perm = flex.sort_permutation(centroids_frame) perm = perm[:min(reflection_list.size(), params.first_n_reflections)] reflection_list = reflection_list.select(perm) if params.crystal_id is not None: reflection_list = reflection_list.select( reflection_list['id'] == params.crystal_id) xyzcal_px = None xyzcal_px = None xyzobs_mm = None xyzcal_mm = None if 'xyzcal.px' in reflection_list: xyzcal_px = reflection_list['xyzcal.px'] if 'xyzobs.px.value' in reflection_list: xyzobs_px = reflection_list['xyzobs.px.value'] if 'xyzcal.mm' in reflection_list: xyzcal_mm = reflection_list['xyzcal.mm'] if 'xyzobs.mm.value' in reflection_list: xyzobs_mm = reflection_list['xyzobs.mm.value'] panel_ids = reflection_list['panel'] if xyzobs_mm is None and xyzobs_px is not None: xyzobs_mm = flex.vec3_double() for i_panel in range(len(detector)): xyzobs_px_panel = xyzobs_px.select(panel_ids == i_panel) from dials.algorithms.centroid import centroid_px_to_mm_panel xyzobs_mm_panel, _, _ = centroid_px_to_mm_panel( detector[i_panel], scan, xyzobs_px_panel, flex.vec3_double(xyzobs_px_panel.size()), flex.vec3_double(xyzobs_px_panel.size())) xyzobs_mm.extend(xyzobs_mm_panel) if xyzobs_mm is not None: observed_xyz.extend(xyzobs_mm) if xyzcal_mm is not None: predicted_xyz.extend(xyzcal_mm) obs_x, obs_y, _ = observed_xyz.parts() pred_x, pred_y, _ = predicted_xyz.parts() try: import matplotlib if not params.output.show_plot: # http://matplotlib.org/faq/howto_faq.html#generate-images-without-having-a-window-appear matplotlib.use('Agg') # use a non-interactive backend from matplotlib import pyplot except ImportError: raise Sorry("matplotlib must be installed to generate a plot.") fig = pyplot.figure() fig.set_size_inches(params.output.size_inches) fig.set_dpi(params.output.dpi) pyplot.axes().set_aspect('equal') marker_size = params.output.marker_size if obs_x.size(): pyplot.scatter(obs_x, obs_y, marker='o', c='white', s=marker_size, alpha=1) if pred_x.size(): pyplot.scatter(pred_x, pred_y, marker='+', s=marker_size, c='blue') #assert len(detector) == 1 panel = detector[0] #if len(detector) > 1: xmin = max([detector[i_panel].get_image_size_mm()[0] + panel_origin_shifts[i_panel][0] for i_panel in range(len(detector))]) xmax = max([detector[i_panel].get_image_size_mm()[0] + panel_origin_shifts[i_panel][0] for i_panel in range(len(detector))]) ymax = max([detector[i_panel].get_image_size_mm()[1] + panel_origin_shifts[i_panel][1] for i_panel in range(len(detector))]) ymax = max([detector[i_panel].get_image_size_mm()[1] + panel_origin_shifts[i_panel][1] for i_panel in range(len(detector))]) try: beam_centre = hierarchy.get_beam_centre(imageset.get_beam().get_s0()) except Exception: beam_centre = detector[0].get_beam_centre(imageset.get_beam().get_s0()) pyplot.scatter([beam_centre[0]], [beam_centre[1]], marker='+', c='blue', s=100) pyplot.xlim(0, xmax) pyplot.ylim(0, ymax) pyplot.gca().invert_yaxis() pyplot.title('Centroid x,y-coordinates') pyplot.xlabel('x-coordinate (mm)') pyplot.ylabel('y-coordinate (mm)') if params.output.file_name is not None: pyplot.savefig(params.output.file_name, size_inches=params.output.size_inches, dpi=params.output.dpi, bbox_inches='tight') if params.output.show_plot: pyplot.show()
def run(args): import os import libtbx.load_env from libtbx.utils import Sorry from dials.util.options import OptionParser usage = "%s [options] datablock.json | image.cbf" %libtbx.env.dispatcher_name parser = OptionParser( usage=usage, phil=phil_scope, read_datablocks=True, read_datablocks_from_images=True, check_format=True, epilog=help_message) params, options = parser.parse_args(show_diff_phil=True) datablocks = flatten_datablocks(params.input.datablock) if len(datablocks) == 0: parser.print_help() exit(0) imagesets = datablocks[0].extract_imagesets() brightness = params.brightness / 100 vendortype = "made up" # check that binning is a power of 2 binning = params.binning if not (binning > 0 and ((binning & (binning - 1)) == 0)): raise Sorry("binning must be a power of 2") output_dir = params.output_dir if output_dir is None: output_dir = "." elif not os.path.exists(output_dir): os.makedirs(output_dir) from rstbx.slip_viewer.tile_generation \ import _get_flex_image, _get_flex_image_multipanel for imageset in imagesets: detector = imageset.get_detector() panel = detector[0] # XXX is this inclusive or exclusive? saturation = panel.get_trusted_range()[1] if params.saturation: saturation = params.saturation for i_image, image in enumerate(imageset): if len(detector) == 1: image = [image] trange = [p.get_trusted_range() for p in detector] mask = [] mask = imageset.get_mask(i_image) if mask is None: mask = [p.get_trusted_range_mask(im) for im, p in zip(image, detector)] image = image_filter(image, mask, display=params.display, gain_value=params.gain, nsigma_b=params.nsigma_b, nsigma_s=params.nsigma_s, global_threshold=params.global_threshold, min_local=params.min_local, kernel_size=params.kernel_size) if len(detector) > 1: # FIXME This doesn't work properly, as flex_image.size2() is incorrect # also binning doesn't work assert binning == 1 flex_image = _get_flex_image_multipanel( brightness=brightness, panels=detector, raw_data=image) else: flex_image = _get_flex_image( brightness=brightness, data=image[0], binning=binning, saturation=saturation, vendortype=vendortype) flex_image.setWindow(0, 0, 1) flex_image.adjust(color_scheme=colour_schemes.get(params.colour_scheme)) # now export as a bitmap flex_image.prep_string() import Image # XXX is size//binning safe here? pil_img = Image.fromstring( 'RGB', (flex_image.size2()//binning, flex_image.size1()//binning), flex_image.export_string) path = os.path.join( output_dir, params.prefix + ("%04d" % i_image) + '.' + params.format) print "Exporting %s" %path tmp_stream = open(path, 'wb') pil_img.save(tmp_stream, format=params.format) tmp_stream.close()
def run(args): from dials.util.options import OptionParser from dials.util.options import flatten_datablocks from dials.util.masking import GoniometerShadowMaskGenerator from libtbx.utils import Sorry import libtbx.load_env usage = "%s [options] experiments.json" % libtbx.env.dispatcher_name parser = OptionParser( usage=usage, phil=phil_scope, read_datablocks=True, check_format=False, epilog=help_message, ) params, options = parser.parse_args(show_diff_phil=True) datablocks = flatten_datablocks(params.input.datablock) if len(datablocks) == 0: parser.print_help() return imagesets = [] for datablock in datablocks: imagesets.extend(datablock.extract_imagesets()) for imageset in imagesets: import math height = params.height # mm radius = params.radius # mm steps_per_degree = 10 steps_per_degree = 1 theta = ( flex.double([range(360 * steps_per_degree)]) * math.pi / 180 * 1 / steps_per_degree ) y = radius * flex.cos(theta) # x z = radius * flex.sin(theta) # y x = flex.double(theta.size(), height) # z coords = flex.vec3_double(zip(x, y, z)) coords.insert(0, (0, 0, 0)) gonio = imageset.get_goniometer() scan = imageset.get_scan() beam = imageset.get_beam() detector = imageset.get_detector() if params.angle is not None: angle = params.angle else: angle = scan.get_oscillation()[0] gonio_masker = GoniometerShadowMaskGenerator( gonio, coords, flex.size_t(len(coords), 0) ) from matplotlib import pyplot as plt if params.output.animation is not None: import matplotlib.animation as manimation import os.path ext = os.path.splitext(params.output.animation) metadata = dict( title="Movie Test", artist="Matplotlib", comment="Movie support!" ) if ext[1] == ".mp4": FFMpegWriter = manimation.writers["ffmpeg"] writer = FFMpegWriter(fps=15, metadata=metadata) elif ext[1] == ".gif": ImagemagickWriter = manimation.writers["imagemagick_file"] writer = ImagemagickWriter(fps=15, metadata=metadata) fig = plt.figure() (l,) = plt.plot([], [], c="r", marker=None) plt.axes().set_aspect("equal") plt.xlim(0, detector[0].get_image_size()[0]) plt.ylim(0, detector[0].get_image_size()[0]) plt.gca().invert_yaxis() title = plt.axes().set_title("") with writer.saving(fig, params.output.animation, 100): start, end = scan.get_array_range() step_size = 5 for i in range(start, end, step_size): angle = scan.get_angle_from_array_index(i) shadow_boundary = gonio_masker.project_extrema(detector, angle) x, y = shadow_boundary[0].parts() l.set_data(x.as_numpy_array(), y.as_numpy_array()) title.set_text("scan_angle = %.1f degrees" % angle) writer.grab_frame() plt.close() shadow_boundary = gonio_masker.project_extrema(detector, angle) with open("shadow.phil", "wb") as f: print("untrusted {", file=f) print(" polygon = \\", file=f) for c in shadow_boundary[0]: print(" %0.f %.0f \\" % (max(c[0], 0), max(c[1], 0)), file=f) print("}", file=f) import matplotlib.pyplot as plt fig = plt.figure() x, y, z = coords.parts() plt.scatter(x.as_numpy_array(), y.as_numpy_array()) plt.axes().set_aspect("equal") plt.xlabel("x (gonio axis)") plt.ylabel("y (perpendicular to beam)") plt.savefig("gonio_xy.png") plt.scatter(y.as_numpy_array(), z.as_numpy_array()) plt.axes().set_aspect("equal") plt.xlabel("y (perpendicular to beam)") plt.ylabel("z (towards beam))") plt.savefig("gonio_yz.png") plt.scatter(z.as_numpy_array(), x.as_numpy_array()) plt.axes().set_aspect("equal") plt.xlabel("z (towards beam)") plt.ylabel("x (gonio axis)") plt.savefig("gonio_zx.png") for p_id in range(len(detector)): x, y = shadow_boundary[p_id].parts() fig = plt.figure() plt.scatter(x.as_numpy_array(), y.as_numpy_array(), c="r", s=1, marker="x") plt.axes().set_aspect("equal") plt.xlim(0, detector[p_id].get_image_size()[0]) plt.ylim(0, detector[p_id].get_image_size()[0]) plt.gca().invert_yaxis() plt.savefig("shadow.png")
def run(self): ''' Parse the options. ''' from dials.util.options import flatten_experiments, flatten_datablocks, flatten_reflections # Parse the command line arguments params, options = self.parser.parse_args(show_diff_phil=True) self.params = params experiments = flatten_experiments(params.input.experiments) datablocks = flatten_datablocks(params.input.datablock) reflections = flatten_reflections(params.input.reflections) # Find all detector objects detectors = [] detectors.extend(experiments.detectors()) dbs = [] for datablock in datablocks: dbs.extend(datablock.unique_detectors()) detectors.extend(dbs) # Verify inputs if len(detectors) != 2: print "Please provide two experiments and or datablocks for comparison" return # These lines exercise the iterate_detector_at_level and iterate_panels functions # for a detector with 4 hierarchy levels """ print "Testing iterate_detector_at_level" for level in xrange(4): print "iterating at level", level for panelg in iterate_detector_at_level(detectors[0].hierarchy(), 0, level): print panelg.get_name() print "Testing iterate_panels" for level in xrange(4): print "iterating at level", level for panelg in iterate_detector_at_level(detectors[0].hierarchy(), 0, level): for panel in iterate_panels(panelg): print panel.get_name() """ tmp = [] for refls in reflections: print "N reflections total:", len(refls) sel = refls.get_flags(refls.flags.used_in_refinement) if sel.count(True) > 0: refls = refls.select(sel) print "N reflections used in refinement", len(refls) print "Reporting only on those reflections used in refinement" refls['difference_vector_norms'] = (refls['xyzcal.mm']-refls['xyzobs.mm.value']).norms() tmp.append(refls) reflections = tmp s0 = col(flex.vec3_double([col(b.get_s0()) for b in experiments.beams()]).mean()) # Compute a set of radial and transverse displacements for each reflection print "Setting up stats..." tmp_refls = [] for refls, expts in zip(reflections, [wrapper.data for wrapper in params.input.experiments]): tmp = flex.reflection_table() assert len(expts.detectors()) == 1 dect = expts.detectors()[0] # Need to construct a variety of vectors for panel_id, panel in enumerate(dect): panel_refls = refls.select(refls['panel'] == panel_id) bcl = flex.vec3_double() # Compute the beam center in lab space (a vector pointing from the origin to where the beam would intersect # the panel, if it did intersect the panel) for expt_id in set(panel_refls['id']): beam = expts[expt_id].beam s0_ = beam.get_s0() expt_refls = panel_refls.select(panel_refls['id'] == expt_id) beam_centre = panel.get_beam_centre_lab(s0_) bcl.extend(flex.vec3_double(len(expt_refls), beam_centre)) panel_refls['beam_centre_lab'] = bcl # Compute obs in lab space x, y, _ = panel_refls['xyzobs.mm.value'].parts() c = flex.vec2_double(x, y) panel_refls['obs_lab_coords'] = panel.get_lab_coord(c) # Compute deltaXY in panel space. This vector is relative to the panel origin x, y, _ = (panel_refls['xyzcal.mm'] - panel_refls['xyzobs.mm.value']).parts() # Convert deltaXY to lab space, subtracting off of the panel origin panel_refls['delta_lab_coords'] = panel.get_lab_coord(flex.vec2_double(x,y)) - panel.get_origin() tmp.extend(panel_refls) refls = tmp # The radial vector points from the center of the reflection to the beam center radial_vectors = (refls['obs_lab_coords'] - refls['beam_centre_lab']).each_normalize() # The transverse vector is orthogonal to the radial vector and the beam vector transverse_vectors = radial_vectors.cross(refls['beam_centre_lab']).each_normalize() # Compute the raidal and transverse components of each deltaXY refls['radial_displacements'] = refls['delta_lab_coords'].dot(radial_vectors) refls['transverse_displacements'] = refls['delta_lab_coords'].dot(transverse_vectors) tmp_refls.append(refls) reflections = tmp_refls # storage for plots refl_counts = {} # Data for all tables pg_bc_dists = flex.double() root1 = detectors[0].hierarchy() root2 = detectors[1].hierarchy() all_weights = flex.double() all_refls_count = flex.int() # Data for lab space table lab_table_data = [] lab_delta_table_data = [] all_lab_x = flex.double() all_lab_y = flex.double() all_lab_z = flex.double() pg_lab_x_sigmas = flex.double() pg_lab_y_sigmas = flex.double() pg_lab_z_sigmas = flex.double() all_rotX = flex.double() all_rotY = flex.double() all_rotZ = flex.double() pg_rotX_sigmas = flex.double() pg_rotY_sigmas = flex.double() pg_rotZ_sigmas = flex.double() all_delta_x = flex.double() all_delta_y = flex.double() all_delta_z = flex.double() all_delta_xy = flex.double() all_delta_xyz = flex.double() all_delta_r = flex.double() all_delta_t = flex.double() all_delta_norm = flex.double() if params.hierarchy_level > 0: # Data for local table local_table_data = [] local_delta_table_data = [] all_local_x = flex.double() all_local_y = flex.double() all_local_z = flex.double() pg_local_x_sigmas = flex.double() pg_local_y_sigmas = flex.double() pg_local_z_sigmas = flex.double() all_local_rotX = flex.double() all_local_rotY = flex.double() all_local_rotZ = flex.double() pg_local_rotX_sigmas = flex.double() pg_local_rotY_sigmas = flex.double() pg_local_rotZ_sigmas = flex.double() all_local_delta_x = flex.double() all_local_delta_y = flex.double() all_local_delta_z = flex.double() all_local_delta_xy = flex.double() all_local_delta_xyz = flex.double() # Data for RMSD table rmsds_table_data = [] for pg_id, (pg1, pg2) in enumerate(zip(iterate_detector_at_level(root1, 0, params.hierarchy_level), iterate_detector_at_level(root2, 0, params.hierarchy_level))): # Count up the number of reflections in this panel group pair for use as a weighting scheme total_refls = 0 pg1_refls = 0 pg2_refls = 0 for p1, p2 in zip(iterate_panels(pg1), iterate_panels(pg2)): r1 = len(reflections[0].select(reflections[0]['panel'] == id_from_name(detectors[0], p1.get_name()))) r2 = len(reflections[1].select(reflections[1]['panel'] == id_from_name(detectors[1], p2.get_name()))) total_refls += r1 + r2 pg1_refls += r1 pg2_refls += r2 if pg1_refls == 0 and pg2_refls == 0: print "No reflections on panel group", pg_id continue all_refls_count.append(total_refls) all_weights.append(pg1_refls) all_weights.append(pg2_refls) assert pg1.get_name() == pg2.get_name() refl_counts[pg1.get_name()] = total_refls # Compute RMSDs row = ["%d"%pg_id] for pg, refls, det in zip([pg1, pg2], reflections, detectors): pg_refls = flex.reflection_table() for p in iterate_panels(pg): pg_refls.extend(refls.select(refls['panel'] == id_from_name(det, p.get_name()))) if len(pg_refls) == 0: rmsd = r_rmsd = t_rmsd = 0 else: rmsd = math.sqrt(flex.sum_sq(pg_refls['difference_vector_norms'])/len(pg_refls))*1000 r_rmsd = math.sqrt(flex.sum_sq(pg_refls['radial_displacements'])/len(pg_refls))*1000 t_rmsd = math.sqrt(flex.sum_sq(pg_refls['transverse_displacements'])/len(pg_refls))*1000 row.extend(["%6.1f"%rmsd, "%6.1f"%r_rmsd, "%6.1f"%t_rmsd, "%8d"%len(pg_refls)]) rmsds_table_data.append(row) dists = flex.double() lab_x = flex.double() lab_y = flex.double() lab_z = flex.double() rot_X = flex.double() rot_Y = flex.double() rot_Z = flex.double() for pg in [pg1, pg2]: bc = col(pg.get_beam_centre_lab(s0)) ori = get_center(pg) dists.append((ori-bc).length()) ori_lab = pg.get_origin() lab_x.append(ori_lab[0]) lab_y.append(ori_lab[1]) lab_z.append(ori_lab[2]) f = col(pg.get_fast_axis()) s = col(pg.get_slow_axis()) n = col(pg.get_normal()) basis = sqr([f[0], s[0], n[0], f[1], s[1], n[1], f[2], s[2], n[2]]) rotX, rotY, rotZ = basis.r3_rotation_matrix_as_x_y_z_angles(deg=True) rot_X.append(rotX) rot_Y.append(rotY) rot_Z.append(rotZ) all_lab_x.extend(lab_x) all_lab_y.extend(lab_y) all_lab_z.extend(lab_z) all_rotX.extend(rot_X) all_rotY.extend(rot_Y) all_rotZ.extend(rot_Z) pg_weights = flex.double([pg1_refls, pg2_refls]) if 0 in pg_weights: dist_m = dist_s = 0 lx_m = lx_s = ly_m = ly_s = lz_m = lz_s = 0 lrx_m = lrx_s = lry_m = lry_s = lrz_m = lrz_s = 0 dx = dy = dz = dxy = dxyz = dr = dt = dnorm = 0 else: stats = flex.mean_and_variance(dists, pg_weights) dist_m = stats.mean() dist_s = stats.gsl_stats_wsd() stats = flex.mean_and_variance(lab_x, pg_weights) lx_m = stats.mean() lx_s = stats.gsl_stats_wsd() stats = flex.mean_and_variance(lab_y, pg_weights) ly_m = stats.mean() ly_s = stats.gsl_stats_wsd() stats = flex.mean_and_variance(lab_z, pg_weights) lz_m = stats.mean() lz_s = stats.gsl_stats_wsd() stats = flex.mean_and_variance(rot_X, pg_weights) lrx_m = stats.mean() lrx_s = stats.gsl_stats_wsd() stats = flex.mean_and_variance(rot_Y, pg_weights) lry_m = stats.mean() lry_s = stats.gsl_stats_wsd() stats = flex.mean_and_variance(rot_Z, pg_weights) lrz_m = stats.mean() lrz_s = stats.gsl_stats_wsd() dx = lab_x[0] - lab_x[1] dy = lab_y[0] - lab_y[1] dz = lab_z[0] - lab_z[1] dxy = math.sqrt(dx**2+dy**2) dxyz = math.sqrt(dx**2+dy**2+dz**2) delta = col([lab_x[0], lab_y[0], lab_z[0]]) - col([lab_x[1], lab_y[1], lab_z[1]]) pg1_center = get_center_lab(pg1).normalize() transverse = s0.cross(pg1_center).normalize() radial = transverse.cross(s0).normalize() dr = delta.dot(radial) dt = delta.dot(transverse) dnorm = col(pg1.get_normal()).angle(col(pg2.get_normal()), deg=True) pg_bc_dists.append(dist_m) pg_lab_x_sigmas.append(lx_s) pg_lab_y_sigmas.append(ly_s) pg_lab_z_sigmas.append(lz_s) pg_rotX_sigmas.append(lrx_s) pg_rotY_sigmas.append(lry_s) pg_rotZ_sigmas.append(lrz_s) all_delta_x.append(dx) all_delta_y.append(dy) all_delta_z.append(dz) all_delta_xy.append(dxy) all_delta_xyz.append(dxyz) all_delta_r.append(dr) all_delta_t.append(dt) all_delta_norm.append(dnorm) lab_table_data.append(["%d"%pg_id, "%5.1f"%dist_m, "%9.3f"%lx_m, "%9.3f"%lx_s, "%9.3f"%ly_m, "%9.3f"%ly_s, "%9.3f"%lz_m, "%9.3f"%lz_s, "%9.3f"%lrx_m, "%9.3f"%lrx_s, "%9.3f"%lry_m, "%9.3f"%lry_s, "%9.3f"%lrz_m, "%9.3f"%lrz_s, "%6d"%total_refls]) lab_delta_table_data.append(["%d"%pg_id, "%5.1f"%dist_m, "%9.1f"%(dx*1000), "%9.1f"%(dy*1000), "%9.3f"%dz, "%9.1f"%(dxy*1000), "%9.3f"%dxyz, "%9.1f"%(dr*1000), "%9.1f"%(dt*1000), "%9.3f"%dnorm, "%6d"%total_refls]) if params.hierarchy_level > 0: local_x = flex.double() local_y = flex.double() local_z = flex.double() l_rot_X = flex.double() l_rot_Y = flex.double() l_rot_Z = flex.double() l_dx = flex.double() l_dy = flex.double() l_dz = flex.double() l_dxy = flex.double() l_dxyz = flex.double() for pg in [pg1, pg2]: l_ori = pg.get_local_origin() local_x.append(l_ori[0]) local_y.append(l_ori[1]) local_z.append(l_ori[2]) f = col(pg.get_local_fast_axis()) s = col(pg.get_local_slow_axis()) n = f.cross(s) basis = sqr([f[0], s[0], n[0], f[1], s[1], n[1], f[2], s[2], n[2]]) rotX, rotY, rotZ = basis.r3_rotation_matrix_as_x_y_z_angles(deg=True) l_rot_X.append(rotX) l_rot_Y.append(rotY) l_rot_Z.append(rotZ) all_local_x.extend(local_x) all_local_y.extend(local_y) all_local_z.extend(local_z) all_local_rotX.extend(l_rot_X) all_local_rotY.extend(l_rot_Y) all_local_rotZ.extend(l_rot_Z) pg_weights = flex.double([pg1_refls, pg2_refls]) if 0 in pg_weights: lx_m = lx_s = ly_m = ly_s = lz_m = lz_s = 0 lrx_m = lrx_s = lry_m = lry_s = lrz_m = lrz_s = 0 ldx = ldy = ldz = ldxy = ldxyz = 0 else: stats = flex.mean_and_variance(local_x, pg_weights) lx_m = stats.mean() lx_s = stats.gsl_stats_wsd() stats = flex.mean_and_variance(local_y, pg_weights) ly_m = stats.mean() ly_s = stats.gsl_stats_wsd() stats = flex.mean_and_variance(local_z, pg_weights) lz_m = stats.mean() lz_s = stats.gsl_stats_wsd() stats = flex.mean_and_variance(l_rot_X, pg_weights) lrx_m = stats.mean() lrx_s = stats.gsl_stats_wsd() stats = flex.mean_and_variance(l_rot_Y, pg_weights) lry_m = stats.mean() lry_s = stats.gsl_stats_wsd() stats = flex.mean_and_variance(l_rot_Z, pg_weights) lrz_m = stats.mean() lrz_s = stats.gsl_stats_wsd() ldx = local_x[0] - local_x[1] ldy = local_y[0] - local_y[1] ldz = local_z[0] - local_z[1] ldxy = math.sqrt(ldx**2+ldy**2) ldxyz = math.sqrt(ldx**2+ldy**2+ldz**2) pg_local_x_sigmas.append(lx_s) pg_local_y_sigmas.append(ly_s) pg_local_z_sigmas.append(lz_s) pg_local_rotX_sigmas.append(lrx_s) pg_local_rotY_sigmas.append(lry_s) pg_local_rotZ_sigmas.append(lrz_s) all_local_delta_x.append(ldx) all_local_delta_y.append(ldy) all_local_delta_z.append(ldz) all_local_delta_xy.append(ldxy) all_local_delta_xyz.append(ldxyz) local_table_data.append(["%d"%pg_id, "%5.1f"%dist_m, "%9.3f"%lx_m, "%9.3f"%lx_s, "%9.3f"%ly_m, "%9.3f"%ly_s, "%9.3f"%lz_m, "%9.3f"%lz_s, "%9.3f"%lrx_m, "%9.3f"%lrx_s, "%9.3f"%lry_m, "%9.3f"%lry_s, "%9.3f"%lrz_m, "%9.3f"%lrz_s, "%6d"%total_refls]) local_delta_table_data.append(["%d"%pg_id, "%5.1f"%dist_m, "%9.1f"%(ldx*1000), "%9.1f"%(ldy*1000), "%9.3f"%ldz, "%9.1f"%(ldxy*1000), "%9.3f"%ldxyz, "%6d"%total_refls]) # Set up table output, starting with lab table table_d = {d:row for d, row in zip(pg_bc_dists, lab_table_data)} table_header = ["PanelG","Radial","Lab X","Lab X","Lab Y","Lab Y","Lab Z","Lab Z","Rot X","Rot X","Rot Y","Rot Y","Rot Z","Rot Z","N"] table_header2 = ["Id","Dist","","Sigma","","Sigma","","Sigma","","Sigma","","Sigma","","Sigma","Refls"] table_header3 = ["","(mm)","(mm)","(mm)","(mm)","(mm)","(mm)","(mm)","(deg)","(deg)","(deg)","(deg)","(deg)","(deg)",""] lab_table_data = [table_header, table_header2, table_header3] lab_table_data.extend([table_d[key] for key in sorted(table_d)]) if len(all_weights) > 1: r1 = ["All"] r2 = ["Mean"] for data, weights, fmt in [[None,None,None], [all_lab_x, all_weights.as_double(), "%9.3f"], [pg_lab_x_sigmas, all_refls_count.as_double(), "%9.3f"], [all_lab_y, all_weights.as_double(), "%9.3f"], [pg_lab_y_sigmas, all_refls_count.as_double(), "%9.3f"], [all_lab_z, all_weights.as_double(), "%9.3f"], [pg_lab_z_sigmas, all_refls_count.as_double(), "%9.3f"], [all_rotX, all_weights.as_double(), "%9.3f"], [pg_rotX_sigmas, all_refls_count.as_double(), "%9.3f"], [all_rotY, all_weights.as_double(), "%9.3f"], [pg_rotY_sigmas, all_refls_count.as_double(), "%9.3f"], [all_rotZ, all_weights.as_double(), "%9.3f"], [pg_rotZ_sigmas, all_refls_count.as_double(), "%9.3f"]]: r2.append("") if data is None and weights is None: r1.append("") continue stats = flex.mean_and_variance(data, weights) r1.append(fmt%stats.mean()) r1.append("") r2.append("%6.1f"%flex.mean(all_refls_count.as_double())) lab_table_data.append(r1) lab_table_data.append(r2) from libtbx import table_utils print "Detector statistics relative to lab origin" print table_utils.format(lab_table_data,has_header=3,justify='center',delim=" ") print "PanelG Id: panel group id or panel id, depending on hierarchy_level. For each panel group, weighted means and weighted standard deviations (Sigmas) for the properties listed below are computed using the matching panel groups between the input experiments." print "Radial dist: distance from center of panel group to the beam center" print "Lab X, Y and Z: mean coordinate in lab space" print "Rot X, Y and Z: rotation of panel group around lab X, Y and Z axes" print "N refls: number of reflections summed between both matching panel groups. This number is used as a weight when computing means and standard deviations." print "All: weighted mean of the values shown" print # Next, deltas in lab space table_d = {d:row for d, row in zip(pg_bc_dists, lab_delta_table_data)} table_header = ["PanelG","Radial","Lab dX","Lab dY","Lab dZ","Lab dXY","Lab dXYZ","Lab dR","Lab dT","Lab dNorm","N"] table_header2 = ["Id","Dist","","","","","","","","","Refls"] table_header3 = ["","(mm)","(microns)","(microns)","(mm)","(microns)","(mm)","(microns)","(microns)","(deg)",""] lab_delta_table_data = [table_header, table_header2, table_header3] lab_delta_table_data.extend([table_d[key] for key in sorted(table_d)]) if len(all_weights) > 1: r1 = ["WMean"] r2 = ["WStddev"] r3 = ["Mean"] for data, weights, fmt in [[None,None,None], [all_delta_x*1000, all_refls_count.as_double(), "%9.1f"], [all_delta_y*1000, all_refls_count.as_double(), "%9.1f"], [all_delta_z, all_refls_count.as_double(), "%9.3f"], [all_delta_xy*1000, all_refls_count.as_double(), "%9.1f"], [all_delta_xyz, all_refls_count.as_double(), "%9.3f"], [all_delta_r*1000, all_refls_count.as_double(), "%9.1f"], [all_delta_t*1000, all_refls_count.as_double(), "%9.1f"], [all_delta_norm, all_refls_count.as_double(), "%9.3f"]]: r3.append("") if data is None and weights is None: r1.append("") r2.append("") continue stats = flex.mean_and_variance(data, weights) r1.append(fmt%stats.mean()) if len(data) > 1: r2.append(fmt%stats.gsl_stats_wsd()) else: r2.append("-") r1.append("") r2.append("") r3.append("%6.1f"%flex.mean(all_refls_count.as_double())) lab_delta_table_data.append(r1) lab_delta_table_data.append(r2) lab_delta_table_data.append(r3) print "Detector deltas in lab space" print table_utils.format(lab_delta_table_data,has_header=3,justify='center',delim=" ") print "PanelG Id: panel group id or panel id, depending on hierarchy_level. For each panel group, weighted means and weighted standard deviations (Sigmas) for the properties listed below are computed using the matching panel groups between the input experiments." print "Radial dist: distance from center of panel group to the beam center" print "Lab dX, dY and dZ: delta between X, Y and Z coordinates in lab space" print "Lab dR, dT and dZ: radial and transverse components of dXY in lab space" print "Lab dNorm: angle between normal vectors in lab space" print "N refls: number of reflections summed between both matching panel groups. This number is used as a weight when computing means and standard deviations." print "WMean: weighted mean of the values shown" print "WStddev: weighted standard deviation of the values shown" print "Mean: mean of the values shown" print if params.hierarchy_level > 0: # Local table table_d = {d:row for d, row in zip(pg_bc_dists, local_table_data)} table_header = ["PanelG","Radial","Local X","Local X","Local Y","Local Y","Local Z","Local Z","Rot X","Rot X","Rot Y","Rot Y","Rot Z","Rot Z","N"] table_header2 = ["Id","Dist","","Sigma","","Sigma","","Sigma","","Sigma","","Sigma","","Sigma","Refls"] table_header3 = ["","(mm)","(mm)","(mm)","(mm)","(mm)","(mm)","(mm)","(deg)","(deg)","(deg)","(deg)","(deg)","(deg)",""] local_table_data = [table_header, table_header2, table_header3] local_table_data.extend([table_d[key] for key in sorted(table_d)]) if len(all_weights) > 1: r1 = ["All"] r2 = ["Mean"] for data, weights, fmt in [[None,None,None], [all_local_x, all_weights.as_double(), "%9.3f"], [pg_local_x_sigmas, all_refls_count.as_double(), "%9.3f"], [all_local_y, all_weights.as_double(), "%9.3f"], [pg_local_y_sigmas, all_refls_count.as_double(), "%9.3f"], [all_local_z, all_weights.as_double(), "%9.3f"], [pg_local_z_sigmas, all_refls_count.as_double(), "%9.3f"], [all_local_rotX, all_weights.as_double(), "%9.3f"], [pg_local_rotX_sigmas, all_refls_count.as_double(), "%9.3f"], [all_local_rotY, all_weights.as_double(), "%9.3f"], [pg_local_rotY_sigmas, all_refls_count.as_double(), "%9.3f"], [all_local_rotZ, all_weights.as_double(), "%9.3f"], [pg_local_rotZ_sigmas, all_refls_count.as_double(), "%9.3f"]]: r2.append("") if data is None and weights is None: r1.append("") continue stats = flex.mean_and_variance(data, weights) r1.append(fmt%stats.mean()) r1.append("") r2.append("%6.1f"%flex.mean(all_refls_count.as_double())) local_table_data.append(r1) local_table_data.append(r2) print "Detector statistics in local frame of each panel group" print table_utils.format(local_table_data,has_header=3,justify='center',delim=" ") print "PanelG Id: panel group id or panel id, depending on hierarchy_level. For each panel group, weighted means and weighted standard deviations (Sigmas) for the properties listed below are computed using the matching panel groups between the input experiments." print "Radial dist: distance from center of panel group to the beam center" print "Lab X, Y and Z: mean coordinate in relative to parent panel group" print "Rot X, Y and Z: rotation of panel group around parent panel group X, Y and Z axes" print "N refls: number of reflections summed between both matching panel groups. This number is used as a weight when computing means and standard deviations." print "All: weighted mean of the values shown" print # Next, deltas in local space table_d = {d:row for d, row in zip(pg_bc_dists, local_delta_table_data)} table_header = ["PanelG","Radial","Local dX","Local dY","Local dZ","Local dXY","Local dXYZ","N"] table_header2 = ["Id","Dist","","","","","","Refls"] table_header3 = ["","(mm)","(microns)","(microns)","(mm)","(microns)","(mm)",""] local_delta_table_data = [table_header, table_header2, table_header3] local_delta_table_data.extend([table_d[key] for key in sorted(table_d)]) if len(all_weights) > 1: r1 = ["WMean"] r2 = ["WStddev"] r3 = ["Mean"] for data, weights, fmt in [[None,None,None], [all_local_delta_x*1000, all_refls_count.as_double(), "%9.1f"], [all_local_delta_y*1000, all_refls_count.as_double(), "%9.1f"], [all_local_delta_z, all_refls_count.as_double(), "%9.3f"], [all_local_delta_xy*1000, all_refls_count.as_double(), "%9.1f"], [all_local_delta_xyz, all_refls_count.as_double(), "%9.3f"]]: r3.append("") if data is None and weights is None: r1.append("") r2.append("") continue stats = flex.mean_and_variance(data, weights) r1.append(fmt%stats.mean()) r2.append(fmt%stats.gsl_stats_wsd()) r1.append("") r2.append("") r3.append("%6.1f"%flex.mean(all_refls_count.as_double())) local_delta_table_data.append(r1) local_delta_table_data.append(r2) local_delta_table_data.append(r3) print "Detector deltas relative to panel group origin" print table_utils.format(local_delta_table_data,has_header=3,justify='center',delim=" ") print "PanelG Id: panel group id or panel id, depending on hierarchy_level. For each panel group, weighted means and weighted standard deviations (Sigmas) for the properties listed below are computed using the matching panel groups between the input experiments." print "Radial dist: distance from center of panel group to the beam center" print "Local dX, dY and dZ: delta between X, Y and Z coordinates in the local frame of the panel group" print "N refls: number of reflections summed between both matching panel groups. This number is used as a weight when computing means and standard deviations." print "All: weighted mean of the values shown" print #RMSD table table_d = {d:row for d, row in zip(pg_bc_dists, rmsds_table_data)} table_header = ["PanelG"] table_header2 = ["Id"] table_header3 = [""] for i in xrange(len(detectors)): table_header.extend(["D%d"%i]*4) table_header2.extend(["RMSD", "rRMSD", "tRMSD", "N refls"]) table_header3.extend(["(microns)"]*3) table_header3.append("") rmsds_table_data = [table_header, table_header2, table_header3] rmsds_table_data.extend([table_d[key] for key in sorted(table_d)]) row = ["Overall"] for refls in reflections: row.append("%6.1f"%(math.sqrt(flex.sum_sq(refls['difference_vector_norms'])/len(refls))*1000)) row.append("%6.1f"%(math.sqrt(flex.sum_sq(refls['radial_displacements'])/len(refls))*1000)) row.append("%6.1f"%(math.sqrt(flex.sum_sq(refls['transverse_displacements'])/len(refls))*1000)) row.append("%8d"%len(refls)) rmsds_table_data.append(row) print "RMSDs by detector number" print table_utils.format(rmsds_table_data,has_header=3,justify='center',delim=" ") print "PanelG Id: panel group id or panel id, depending on hierarchy_level" print "RMSD: root mean squared deviation between observed and predicted spot locations" print "rRMSD: RMSD of radial components of the observed-predicted vectors" print "tRMSD: RMSD of transverse components of the observed-predicted vectors" print "N refls: number of reflections" if params.tag is None: tag = "" else: tag = "%s "%params.tag if params.show_plots: # Plot the results self.detector_plot_dict(detectors[0], refl_counts, u"%sN reflections"%tag, u"%6d", show=False)
def run(args): import libtbx.load_env usage = "%s [options] datablock.json strong.pickle" % libtbx.env.dispatcher_name parser = OptionParser(usage=usage, read_reflections=True, read_datablocks=True, read_experiments=True, phil=phil_scope, check_format=False, epilog=help_message) from libtbx.utils import Sorry params, options = parser.parse_args(show_diff_phil=False) reflections = flatten_reflections(params.input.reflections) datablocks = flatten_datablocks(params.input.datablock) experiments = flatten_experiments(params.input.experiments) if not any([reflections, experiments, datablocks]): parser.print_help() return if len(reflections) != 1: raise Sorry('exactly 1 reflection table must be specified') if len(datablocks) != 1: if experiments: if len(experiments.imagesets()) != 1: raise Sorry('exactly 1 datablock must be specified') imageset = experiments.imagesets()[0] else: raise Sorry('exactly 1 datablock must be specified') else: imageset = datablocks[0].extract_imagesets()[0] reflections = reflections[0] if params.id is not None: reflections = reflections.select(reflections['id'] == params.id) stats = per_image_analysis.stats_imageset( imageset, reflections, resolution_analysis=params.resolution_analysis, plot=params.individual_plots) per_image_analysis.print_table(stats) from libtbx import table_utils overall_stats = per_image_analysis.stats_single_image( imageset, reflections, resolution_analysis=params.resolution_analysis) rows = [ ("Overall statistics", ""), ("#spots", "%i" % overall_stats.n_spots_total), ("#spots_no_ice", "%i" % overall_stats.n_spots_no_ice), #("total_intensity", "%.0f" %overall_stats.total_intensity), ("d_min", "%.2f" % overall_stats.estimated_d_min), ("d_min (distl method 1)", "%.2f (%.2f)" % (overall_stats.d_min_distl_method_1, overall_stats.noisiness_method_1)), ("d_min (distl method 2)", "%.2f (%.2f)" % (overall_stats.d_min_distl_method_1, overall_stats.noisiness_method_1)), ] print table_utils.format(rows, has_header=True, prefix="| ", postfix=" |") if params.json is not None: import json with open(params.json, 'wb') as fp: json.dump(stats.__dict__, fp) if params.plot is not None: per_image_analysis.plot_stats(stats, filename=params.plot)
def run(args): from dials.util import log usage = "%s [options] datablock.json strong.pickle" % libtbx.env.dispatcher_name parser = OptionParser(usage=usage, phil=phil_scope, read_datablocks=True, read_reflections=True, check_format=False, epilog=help_message) params, options = parser.parse_args(show_diff_phil=False) datablocks = flatten_datablocks(params.input.datablock) reflections = flatten_reflections(params.input.reflections) if len(datablocks) == 0 or len(reflections) == 0: parser.print_help() exit(0) # Configure the logging log.config(info=params.output.log, debug=params.output.debug_log) # Log the diff phil diff_phil = parser.diff_phil.as_str() if diff_phil is not '': logger.info('The following parameters have been modified:\n') logger.info(diff_phil) if params.seed is not None: import random flex.set_random_seed(params.seed) random.seed(params.seed) imagesets = [] for datablock in datablocks: imagesets.extend(datablock.extract_imagesets()) assert len(imagesets) > 0 assert len(reflections) == len(imagesets) if params.scan_range is not None and len(params.scan_range) > 0: reflections = [ filter_reflections_by_scan_range(refl, params.scan_range) for refl in reflections ] dps_params = dps_phil_scope.extract() # for development, we want an exhaustive plot of beam probability map: dps_params.indexing.plot_search_scope = params.plot_search_scope dps_params.indexing.mm_search_scope = params.mm_search_scope for i in range(params.n_macro_cycles): if params.n_macro_cycles > 1: logger.info('Starting macro cycle %i' % (i + 1)) new_detector, new_beam = discover_better_experimental_model( imagesets, reflections, params, dps_params, nproc=params.nproc, wide_search_binning=params.wide_search_binning) for imageset in imagesets: imageset.set_detector(new_detector) imageset.set_beam(new_beam) logger.info('') from dxtbx.serialize import dump logger.info("Saving optimized datablock to %s" % params.output.datablock) dump.datablock(datablock, params.output.datablock)
def run(self): ''' Perform the integration. ''' from dials.util.command_line import heading from dials.util.options import flatten_datablocks, flatten_experiments from dials.util import log from time import time from libtbx.utils import Sorry from dials.array_family import flex # Parse the command line params, options = self.parser.parse_args(show_diff_phil=False) experiments = flatten_experiments(params.input.experiments) datablocks = flatten_datablocks(params.input.datablock) if len(experiments) == 0 and len(datablocks) == 0: self.parser.print_help() return if len(datablocks) > 0: assert len(datablocks) == 1 imagesets = datablocks[0].extract_imagesets() assert len(imagesets) == 1 imageset = imagesets[0] beam = imageset.get_beam() detector = imageset.get_detector() else: assert len(experiments) == 1 imageset = experiments[0].imageset beam = experiments[0].beam detector = experiments[0].detector # Configure logging log.config() # Set the scan range if params.scan_range is None: scan_range = (0, len(imageset)) else: scan_range = params.scan_range i0, i1 = scan_range if i0 < 0 or i1 > len(imageset): raise RuntimeError('Scan range outside image range') if i0 >= i1: raise RuntimeError('Invalid scan range') summed_data = None summed_mask = None # Loop through images for i in range(*scan_range): logger.info("Reading image %d" % i) # Read image data = imageset.get_raw_data(i) mask = imageset.get_mask(i) assert isinstance(data, tuple) assert isinstance(mask, tuple) if summed_data is None: summed_mask = mask summed_data = data else: summed_data = [ sd + d for sd, d in zip(summed_data, data) ] summed_mask = [ sm & m for sm, m in zip(summed_mask, mask) ] # Compute min and max and num if params.num_bins is None: num_bins = sum(sum(p.get_image_size()) for p in detector) if params.d_max is None: vmin = 0 else: vmin = (1.0 / d_max)**2 if params.d_min is None: params.d_min = detector.get_max_resolution(beam.get_s0()) vmax = (1.0 / params.d_min)**2 # Print some info logger.info("Min 1/d^2: %f" % vmin) logger.info("Max 1/d^2: %f" % vmax) logger.info("Num bins: %d" % num_bins) # Compute the radial average from dials.algorithms.background import RadialAverage radial_average = RadialAverage(beam, detector, vmin, vmax, num_bins) for d, m in zip(summed_data, summed_mask): radial_average.add(d.as_double(), m) mean = radial_average.mean() reso = radial_average.inv_d2() logger.info("Writing to %s" % params.output.filename) with open(params.output.filename, "w") as outfile: for r, m in zip(reso, mean): outfile.write("%f, %f\n" % (r, m))