def test_correct(space_group_symbol):
sgi = sgtbx.space_group_info(space_group_symbol)
cs = sgi.any_compatible_crystal_symmetry(volume=1000)
ms = cs.build_miller_set(anomalous_flag=True, d_min=1).expand_to_p1()
# the reciprocal matrix
B = scitbx.matrix.sqr(cs.unit_cell().fractionalization_matrix()).transpose()
crystal = Crystal(B, sgtbx.space_group())
expts = ExperimentList([Experiment(crystal=crystal)])
refl = flex.reflection_table()
refl["miller_index"] = ms.indices()
refl["rlp"] = B.elems * ms.indices().as_vec3_double()
refl["imageset_id"] = flex.int(len(refl))
refl["xyzobs.mm.value"] = flex.vec3_double(len(refl))
non_primitive_basis.correct(expts, refl, assign_indices.AssignIndicesGlobal())
cs_corrected = expts.crystals()[0].get_crystal_symmetry()
assert cs_corrected.change_of_basis_op_to_primitive_setting().is_identity_op()
assert (
cs.change_of_basis_op_to_primitive_setting().apply(ms.indices())
== refl["miller_index"]
)
def choose_best_orientation_matrix(self, candidate_orientation_matrices):
from dials.algorithms.indexing import model_evaluation
solution_scorer = self.params.basis_vector_combinations.solution_scorer
if solution_scorer == "weighted":
weighted_params = self.params.basis_vector_combinations.weighted
solutions = model_evaluation.ModelRankWeighted(
power=weighted_params.power,
volume_weight=weighted_params.volume_weight,
n_indexed_weight=weighted_params.n_indexed_weight,
rmsd_weight=weighted_params.rmsd_weight,
)
else:
filter_params = self.params.basis_vector_combinations.filter
solutions = model_evaluation.ModelRankFilter(
check_doubled_cell=filter_params.check_doubled_cell,
likelihood_cutoff=filter_params.likelihood_cutoff,
volume_cutoff=filter_params.volume_cutoff,
n_indexed_cutoff=filter_params.n_indexed_cutoff,
)
args = []
for cm in candidate_orientation_matrices:
sel = self.reflections["id"] == -1
if self.d_min is not None:
sel &= 1 / self.reflections["rlp"].norms() > self.d_min
xo, yo, zo = self.reflections["xyzobs.mm.value"].parts()
imageset_id = self.reflections["imageset_id"]
experiments = ExperimentList()
for i_expt, expt in enumerate(self.experiments):
# XXX Not sure if we still need this loop over self.experiments
if expt.scan is not None:
start, end = expt.scan.get_oscillation_range()
if (end - start) > 360:
# only use reflections from the first 360 degrees of the scan
sel.set_selected(
(imageset_id == i_expt)
& (zo > ((start * math.pi / 180) + 2 * math.pi)),
False,
)
experiments.append(
Experiment(
imageset=expt.imageset,
beam=expt.beam,
detector=expt.detector,
goniometer=expt.goniometer,
scan=expt.scan,
crystal=cm,
)
)
refl = self.reflections.select(sel)
self.index_reflections(experiments, refl)
if refl.get_flags(refl.flags.indexed).count(True) == 0:
continue
from rstbx.dps_core.cell_assessment import SmallUnitCellVolume
from dials.algorithms.indexing import non_primitive_basis
threshold = self.params.basis_vector_combinations.sys_absent_threshold
if threshold and (
self._symmetry_handler.target_symmetry_primitive is None
or self._symmetry_handler.target_symmetry_primitive.unit_cell() is None
):
try:
non_primitive_basis.correct(
experiments, refl, self._assign_indices, threshold
)
if refl.get_flags(refl.flags.indexed).count(True) == 0:
continue
except SmallUnitCellVolume:
logger.debug(
"correct_non_primitive_basis SmallUnitCellVolume error for unit cell %s:",
experiments[0].crystal.get_unit_cell(),
)
continue
except RuntimeError as e:
if "Krivy-Gruber iteration limit exceeded" in str(e):
logger.debug(
"correct_non_primitive_basis Krivy-Gruber iteration limit exceeded error for unit cell %s:",
experiments[0].crystal.get_unit_cell(),
)
continue
raise
if (
experiments[0].crystal.get_unit_cell().volume()
< self.params.min_cell_volume
):
continue
if self.params.known_symmetry.space_group is not None:
new_crystal, _ = self._symmetry_handler.apply_symmetry(
experiments[0].crystal
)
if new_crystal is None:
continue
experiments[0].crystal.update(new_crystal)
args.append((experiments, refl))
if len(args) == self.params.basis_vector_combinations.max_refine:
break
from libtbx import easy_mp
evaluator = model_evaluation.ModelEvaluation(self.all_params)
results = easy_mp.parallel_map(
evaluator.evaluate,
args,
iterable_type=easy_mp.posiargs,
processes=self.params.nproc,
preserve_exception_message=True,
)
for soln in results:
if soln is None:
continue
solutions.append(soln)
if len(solutions):
logger.info("Candidate solutions:")
logger.info(str(solutions))
best_model = solutions.best_model()
logger.debug("best model_likelihood: %.2f", best_model.model_likelihood)
logger.debug("best n_indexed: %i", best_model.n_indexed)
self.hkl_offset = best_model.hkl_offset
return best_model.crystal, best_model.n_indexed
else:
return None, None