def test_determine_reindex_operator_against_reference():
"""Test that the correct reindex operator is returned by the function."""
# create a test dataset of random intensities
data, _ = generate_test_data(
space_group=sgtbx.space_group_info(symbol="P4").group(), sample_size=1)
# reindexing operator is a,-b,-c
op = "a,-b,-c"
# reindex the data into a new array, so that the function should determine
# that the same change of basis operator should be applied to give consistent
# indexing back to the original data.
reindexed_data = data[0].change_basis(op)
cb_op = determine_reindex_operator_against_reference(
data[0], reindexed_data)
assert cb_op.as_abc() == "a,-b,-c"
# Repeat but with no reindexing
cb_op = determine_reindex_operator_against_reference(data[0], data[0])
assert cb_op.as_abc() == "a,b,c"
# Test that a Sorry is raised if inconsistent indexing
data_2, _ = generate_test_data(
space_group=sgtbx.space_group_info(symbol="P1").group(), sample_size=1)
with pytest.raises(Sorry):
cb_op = determine_reindex_operator_against_reference(
data[0], data_2[0])
# Test case for a simple space group with no ambiguity
data, _ = generate_test_data(
space_group=sgtbx.space_group_info(symbol="P1").group(), sample_size=1)
cb_op = determine_reindex_operator_against_reference(data[0], data[0])
assert cb_op.as_abc() == "a,b,c"
def run(args):
import libtbx.load_env
from dials.util import Sorry
usage = "dials.reindex [options] indexed.expt indexed.refl"
parser = OptionParser(
usage=usage,
phil=phil_scope,
read_reflections=True,
read_experiments=True,
check_format=False,
epilog=help_message,
)
params, options = parser.parse_args(show_diff_phil=True)
reflections = flatten_reflections(params.input.reflections)
experiments = flatten_experiments(params.input.experiments)
if len(experiments) == 0 and len(reflections) == 0:
parser.print_help()
return
if params.change_of_basis_op is None:
raise Sorry("Please provide a change_of_basis_op.")
reference_crystal = None
if params.reference.experiments is not None:
from dxtbx.serialize import load
reference_experiments = load.experiment_list(
params.reference.experiments, check_format=False)
assert len(reference_experiments.crystals()) == 1
reference_crystal = reference_experiments.crystals()[0]
if params.reference.reflections is not None:
# First check that we have everything as expected for the reference reindexing
# Currently only supports reindexing one dataset at a time
if params.reference.experiments is None:
raise Sorry(
"""For reindexing against a reference dataset, a reference
experiments file must also be specified with the option: reference= """)
if not os.path.exists(params.reference.reflections):
raise Sorry("Could not locate reference dataset reflection file")
if len(experiments) != 1 or len(reflections) != 1:
raise Sorry(
"Only one dataset can be reindexed to a reference at a time")
reference_reflections = flex.reflection_table().from_file(
params.reference.reflections)
test_reflections = reflections[0]
if (reference_crystal.get_space_group().type().number() !=
experiments.crystals()[0].get_space_group().type().number()):
raise Sorry("Space group of input does not match reference")
# Set some flags to allow filtering, if wanting to reindex against
# reference with data that has not yet been through integration
if (test_reflections.get_flags(
test_reflections.flags.integrated_sum).count(True) == 0):
assert (
"intensity.sum.value"
in test_reflections), "No 'intensity.sum.value' in reflections"
test_reflections.set_flags(
flex.bool(test_reflections.size(), True),
test_reflections.flags.integrated_sum,
)
if (reference_reflections.get_flags(
reference_reflections.flags.integrated_sum).count(True) == 0):
assert ("intensity.sum.value" in test_reflections
), "No 'intensity.sum.value in reference reflections"
reference_reflections.set_flags(
flex.bool(reference_reflections.size(), True),
reference_reflections.flags.integrated_sum,
)
# Make miller array of the two datasets
try:
test_miller_set = filtered_arrays_from_experiments_reflections(
experiments, [test_reflections])[0]
except ValueError:
raise Sorry(
"No reflections remain after filtering the test dataset")
try:
reference_miller_set = filtered_arrays_from_experiments_reflections(
reference_experiments, [reference_reflections])[0]
except ValueError:
raise Sorry(
"No reflections remain after filtering the reference dataset")
from dials.algorithms.symmetry.reindex_to_reference import (
determine_reindex_operator_against_reference, )
change_of_basis_op = determine_reindex_operator_against_reference(
test_miller_set, reference_miller_set)
elif len(experiments) and params.change_of_basis_op is libtbx.Auto:
if reference_crystal is not None:
if len(experiments.crystals()) > 1:
raise Sorry("Only one crystal can be processed at a time")
from dials.algorithms.indexing.compare_orientation_matrices import (
difference_rotation_matrix_axis_angle, )
cryst = experiments.crystals()[0]
R, axis, angle, change_of_basis_op = difference_rotation_matrix_axis_angle(
cryst, reference_crystal)
print("Change of basis op: %s" % change_of_basis_op)
print("Rotation matrix to transform input crystal to reference::")
print(R.mathematica_form(format="%.3f", one_row_per_line=True))
print(
"Rotation of %.3f degrees" % angle,
"about axis (%.3f, %.3f, %.3f)" % axis,
)
elif len(reflections):
assert len(reflections) == 1
# always re-map reflections to reciprocal space
refl_copy = flex.reflection_table()
for i, imageset in enumerate(experiments.imagesets()):
if "imageset_id" in reflections[0]:
sel = reflections[0]["imageset_id"] == i
else:
sel = reflections[0]["id"] == i
refl = reflections[0].select(sel)
refl.centroid_px_to_mm(imageset.get_detector(),
imageset.get_scan())
refl.map_centroids_to_reciprocal_space(
imageset.get_detector(),
imageset.get_beam(),
imageset.get_goniometer(),
)
refl_copy.extend(refl)
# index the reflection list using the input experiments list
refl_copy["id"] = flex.int(len(refl_copy), -1)
index = AssignIndicesGlobal(tolerance=0.2)
index(refl_copy, experiments)
hkl_expt = refl_copy["miller_index"]
hkl_input = reflections[0]["miller_index"]
change_of_basis_op = derive_change_of_basis_op(hkl_input, hkl_expt)
# reset experiments list since we don't want to reindex this
experiments = []
else:
change_of_basis_op = sgtbx.change_of_basis_op(
params.change_of_basis_op)
if len(experiments):
for crystal in experiments.crystals():
cryst_orig = copy.deepcopy(crystal)
cryst_reindexed = cryst_orig.change_basis(change_of_basis_op)
if params.space_group is not None:
a, b, c = cryst_reindexed.get_real_space_vectors()
A_varying = [
cryst_reindexed.get_A_at_scan_point(i)
for i in range(cryst_reindexed.num_scan_points)
]
cryst_reindexed = Crystal(
a, b, c, space_group=params.space_group.group())
cryst_reindexed.set_A_at_scan_points(A_varying)
crystal.update(cryst_reindexed)
print("Old crystal:")
print(cryst_orig)
print()
print("New crystal:")
print(cryst_reindexed)
print()
print("Saving reindexed experimental models to %s" %
params.output.experiments)
experiments.as_file(params.output.experiments)
if len(reflections):
assert len(reflections) == 1
reflections = reflections[0]
miller_indices = reflections["miller_index"]
if params.hkl_offset is not None:
h, k, l = miller_indices.as_vec3_double().parts()
h += params.hkl_offset[0]
k += params.hkl_offset[1]
l += params.hkl_offset[2]
miller_indices = flex.miller_index(h.iround(), k.iround(),
l.iround())
non_integral_indices = change_of_basis_op.apply_results_in_non_integral_indices(
miller_indices)
if non_integral_indices.size() > 0:
print(
"Removing %i/%i reflections (change of basis results in non-integral indices)"
% (non_integral_indices.size(), miller_indices.size()))
sel = flex.bool(miller_indices.size(), True)
sel.set_selected(non_integral_indices, False)
miller_indices_reindexed = change_of_basis_op.apply(
miller_indices.select(sel))
reflections["miller_index"].set_selected(sel, miller_indices_reindexed)
reflections["miller_index"].set_selected(~sel, (0, 0, 0))
print("Saving reindexed reflections to %s" % params.output.reflections)
easy_pickle.dump(params.output.reflections, reflections)
def run(args=None):
import libtbx.load_env
from dials.util import Sorry
usage = "dials.reindex [options] indexed.expt indexed.refl"
parser = ArgumentParser(
usage=usage,
phil=phil_scope,
read_reflections=True,
read_experiments=True,
check_format=False,
epilog=help_message,
)
params, options = parser.parse_args(args, show_diff_phil=True)
reflections, experiments = reflections_and_experiments_from_files(
params.input.reflections, params.input.experiments
)
if len(experiments) == 0 and len(reflections) == 0:
parser.print_help()
return
if params.change_of_basis_op is None:
raise Sorry("Please provide a change_of_basis_op.")
reference_crystal = None
if params.reference.experiments is not None:
from dxtbx.serialize import load
reference_experiments = load.experiment_list(
params.reference.experiments, check_format=False
)
if len(reference_experiments.crystals()) == 1:
reference_crystal = reference_experiments.crystals()[0]
else:
# first check sg all same
sgs = [
expt.crystal.get_space_group().type().number() for expt in experiments
]
if len(set(sgs)) > 1:
raise Sorry(
"""The reference experiments have different space groups:
space group numbers found: %s
Please reanalyse the data so that space groups are consistent,
(consider using dials.reindex, dials.symmetry or dials.cosym)"""
% ", ".join(map(str, set(sgs)))
)
reference_crystal = reference_experiments.crystals()[0]
reference_crystal.unit_cell = determine_best_unit_cell(
reference_experiments
)
if params.reference.reflections is not None:
# First check that we have everything as expected for the reference reindexing
if params.reference.experiments is None:
raise Sorry(
"""For reindexing against a reference dataset, a reference
experiments file must also be specified with the option: reference.experiments= """
)
if not os.path.exists(params.reference.reflections):
raise Sorry("Could not locate reference dataset reflection file")
reference_reflections = flex.reflection_table().from_file(
params.reference.reflections
)
test_reflections = reflections[0]
if (
reference_crystal.get_space_group().type().number()
!= experiments.crystals()[0].get_space_group().type().number()
):
raise Sorry("Space group of input does not match reference")
# Set some flags to allow filtering, if wanting to reindex against
# reference with data that has not yet been through integration
if (
test_reflections.get_flags(test_reflections.flags.integrated_sum).count(
True
)
== 0
):
assert (
"intensity.sum.value" in test_reflections
), "No 'intensity.sum.value' in reflections"
test_reflections.set_flags(
flex.bool(test_reflections.size(), True),
test_reflections.flags.integrated_sum,
)
if (
reference_reflections.get_flags(
reference_reflections.flags.integrated_sum
).count(True)
== 0
):
assert (
"intensity.sum.value" in test_reflections
), "No 'intensity.sum.value in reference reflections"
reference_reflections.set_flags(
flex.bool(reference_reflections.size(), True),
reference_reflections.flags.integrated_sum,
)
# Make miller array of the two datasets
try:
test_miller_set = filtered_arrays_from_experiments_reflections(
experiments, [test_reflections]
)[0]
except ValueError:
raise Sorry("No reflections remain after filtering the test dataset")
try:
reference_miller_set = filtered_arrays_from_experiments_reflections(
reference_experiments, [reference_reflections]
)[0]
except ValueError:
raise Sorry("No reflections remain after filtering the reference dataset")
from dials.algorithms.symmetry.reindex_to_reference import (
determine_reindex_operator_against_reference,
)
change_of_basis_op = determine_reindex_operator_against_reference(
test_miller_set, reference_miller_set
)
elif len(experiments) and params.change_of_basis_op is libtbx.Auto:
if reference_crystal is not None:
if len(experiments.crystals()) > 1:
raise Sorry("Only one crystal can be processed at a time")
from dials.algorithms.indexing.compare_orientation_matrices import (
difference_rotation_matrix_axis_angle,
)
cryst = experiments.crystals()[0]
R, axis, angle, change_of_basis_op = difference_rotation_matrix_axis_angle(
cryst, reference_crystal
)
print(f"Change of basis op: {change_of_basis_op}")
print("Rotation matrix to transform input crystal to reference::")
print(R.mathematica_form(format="%.3f", one_row_per_line=True))
print(
f"Rotation of {angle:.3f} degrees",
"about axis (%.3f, %.3f, %.3f)" % axis,
)
elif len(reflections):
assert len(reflections) == 1
# always re-map reflections to reciprocal space
refl = reflections.deep_copy()
refl.centroid_px_to_mm(experiments)
refl.map_centroids_to_reciprocal_space(experiments)
# index the reflection list using the input experiments list
refl["id"] = flex.int(len(refl), -1)
index = AssignIndicesGlobal(tolerance=0.2)
index(refl, experiments)
hkl_expt = refl["miller_index"]
hkl_input = reflections[0]["miller_index"]
change_of_basis_op = derive_change_of_basis_op(hkl_input, hkl_expt)
# reset experiments list since we don't want to reindex this
experiments = []
else:
change_of_basis_op = sgtbx.change_of_basis_op(params.change_of_basis_op)
if len(experiments):
space_group = params.space_group
if space_group is not None:
space_group = space_group.group()
try:
experiments = reindex_experiments(
experiments, change_of_basis_op, space_group=space_group
)
except RuntimeError as e:
# Only catch specific errors here
if "Unsuitable value for rational rotation matrix." in str(e):
original_message = str(e).split(":")[-1].strip()
sys.exit(f"Error: {original_message} Is your change_of_basis_op valid?")
raise
print(f"Saving reindexed experimental models to {params.output.experiments}")
experiments.as_file(params.output.experiments)
if len(reflections):
assert len(reflections) == 1
reflections = reflections[0]
miller_indices = reflections["miller_index"]
if params.hkl_offset is not None:
h, k, l = miller_indices.as_vec3_double().parts()
h += params.hkl_offset[0]
k += params.hkl_offset[1]
l += params.hkl_offset[2]
miller_indices = flex.miller_index(h.iround(), k.iround(), l.iround())
non_integral_indices = change_of_basis_op.apply_results_in_non_integral_indices(
miller_indices
)
if non_integral_indices.size() > 0:
print(
"Removing %i/%i reflections (change of basis results in non-integral indices)"
% (non_integral_indices.size(), miller_indices.size())
)
sel = flex.bool(miller_indices.size(), True)
sel.set_selected(non_integral_indices, False)
miller_indices_reindexed = change_of_basis_op.apply(miller_indices.select(sel))
reflections["miller_index"].set_selected(sel, miller_indices_reindexed)
reflections["miller_index"].set_selected(~sel, (0, 0, 0))
print(f"Saving reindexed reflections to {params.output.reflections}")
reflections.as_file(params.output.reflections)
