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
