def find_max_cell(self): params = self.params.max_cell_estimation if self.params.max_cell is libtbx.Auto: if self.params.known_symmetry.unit_cell is not None: uc_params = (self._symmetry_handler.target_symmetry_primitive. unit_cell().parameters()) self.params.max_cell = params.multiplier * max(uc_params[:3]) logger.info("Using max_cell: %.1f Angstrom" % (self.params.max_cell)) else: self.params.max_cell = find_max_cell( self.reflections, max_cell_multiplier=params.multiplier, step_size=params.step_size, nearest_neighbor_percentile=params. nearest_neighbor_percentile, histogram_binning=params.histogram_binning, nn_per_bin=params.nn_per_bin, max_height_fraction=params.max_height_fraction, filter_ice=params.filter_ice, filter_overlaps=params.filter_overlaps, overlaps_border=params.overlaps_border, ).max_cell logger.info("Found max_cell: %.1f Angstrom" % (self.params.max_cell))
def index(experiments, observed, params): params.refinement.parameterisation.scan_varying = False params.indexing.stills.indexer = "stills" reflections = observed.split_by_experiment_id() # Calculate necessary quantities for refl, experiment in zip(reflections, experiments): elist = ExperimentList([experiment]) refl["imageset_id"] = flex.int(refl.size(), 0) # needed for centroid_px_to_mm refl.centroid_px_to_mm(elist) refl.map_centroids_to_reciprocal_space(elist) if (params.indexing.max_cell is Auto) and (not params.indexing.known_symmetry.unit_cell): max_cells = [] for refl in reflections: try: max_cells.append(find_max_cell(refl).max_cell) except (DialsIndexError, AssertionError): pass logger.info(f"Setting max cell to {max(max_cells):.1f} " + "\u212B") params.indexing.max_cell = max(max_cells) method_list = params.method if "real_space_grid_search" in method_list: if not params.indexing.known_symmetry.unit_cell: logger.info( "No unit cell given, real_space_grid_search will not be used") method_list.remove("real_space_grid_search") methods = ", ".join(method_list) pl = "s" if (len(method_list) > 1) else "" logger.info(f"Attempting indexing with {methods} method{pl}") indexed_experiments, indexed_reflections, results_summary = index_all_concurrent( experiments, reflections, params, method_list, ) summary_table = make_summary_table(results_summary) logger.info("\nSummary of images sucessfully indexed\n" + summary_table) n_images = len(set(e.imageset.get_path(0) for e in indexed_experiments)) logger.info( f"{indexed_reflections.size()} spots indexed on {n_images} images\n") # combine beam and detector models if not already if (len(indexed_experiments.detectors())) > 1 or (len( indexed_experiments.beams())) > 1: combine = CombineWithReference( detector=indexed_experiments[0].detector, beam=indexed_experiments[0].beam) elist = ExperimentList() for expt in indexed_experiments: elist.append(combine(expt)) indexed_experiments = elist return indexed_experiments, indexed_reflections, results_summary
def preprocess( experiments: ExperimentList, observed: flex.reflection_table, params: phil.scope_extract, ) -> Tuple[List[flex.reflection_table], phil.scope_extract, List[str]]: reflections = observed.split_by_experiment_id() if len(reflections) != len(experiments): # spots may not have been found on every image. In this case, the length # of the list of reflection tables will be less than the length of experiments. # Add in empty items to the list, so that this can be reported on no_refls = set(range(len(experiments))).difference(set(observed["id"])) for i in no_refls: reflections.insert(i, None) if len(experiments) != len(reflections): raise ValueError( f"Unequal number of reflection tables {len(reflections)} and experiments {len(experiments)}" ) # Calculate necessary quantities for refl, experiment in zip(reflections, experiments): if refl: elist = ExperimentList([experiment]) refl["imageset_id"] = flex.int(refl.size(), 0) # needed for centroid_px_to_mm refl.centroid_px_to_mm(elist) refl.map_centroids_to_reciprocal_space(elist) # Determine the max cell if applicable if (params.indexing.max_cell is Auto) and (not params.indexing.known_symmetry.unit_cell): if params.individual_log_verbosity <= 2: # suppress the max cell debug log logging.getLogger("dials.algorithms.indexing.max_cell").setLevel( logging.INFO) max_cells = [] for refl in reflections: if refl: try: max_cells.append(find_max_cell(refl).max_cell) except (DialsIndexError, AssertionError): pass if not max_cells: raise ValueError("Unable to find a max cell for any images") logger.info(f"Setting max cell to {max(max_cells):.1f} " + "\u212B") params.indexing.max_cell = max(max_cells) # Determine which methods to try method_list = params.method if "real_space_grid_search" in method_list: if not params.indexing.known_symmetry.unit_cell: logger.info( "No unit cell given, real_space_grid_search will not be used") method_list.remove("real_space_grid_search") methods = ", ".join(method_list) pl = "s" if (len(method_list) > 1) else "" logger.info(f"Attempting indexing with {methods} method{pl}") return reflections, params, method_list
def test_max_cell(setup, histogram_binning, nearest_neighbor_percentile): reflections = setup["reflections"] crystal_symmetry = setup["crystal_symmetry"] max_cell_multiplier = 1.3 max_cell = find_max_cell( reflections, max_cell_multiplier=max_cell_multiplier, histogram_binning=histogram_binning, nearest_neighbor_percentile=nearest_neighbor_percentile, ) known_max_cell = max( crystal_symmetry.primitive_setting().unit_cell().parameters()[:3]) assert max_cell.max_cell > known_max_cell
def test_max_cell_low_res_with_high_res_noise(setup): reflections = setup["reflections"] crystal_symmetry = setup["crystal_symmetry"] rlp = reflections["rlp"] # select only low resolution reflections reflections = reflections.select(1 / rlp.norms() > 4) n = int(0.1 * reflections.size()) rlp_noise = flex.vec3_double(*(flex.random_double(n) for i in range(3))) reflections["rlp"].extend(rlp_noise) reflections["imageset_id"].extend(flex.int(rlp_noise.size())) reflections["xyzobs.mm.value"].extend(flex.vec3_double(rlp_noise.size())) max_cell_multiplier = 1.3 max_cell = find_max_cell(reflections, max_cell_multiplier=max_cell_multiplier) known_max_cell = max( crystal_symmetry.primitive_setting().unit_cell().parameters()[:3]) assert max_cell.max_cell > known_max_cell