def test_connected_components_centred_cell(dials_data):
experiment = ExperimentList.from_file(
dials_data("insulin_processed").join("scaled.expt").strpath, check_format=False
)[0]
experiment.scan.set_image_range((1, 10))
predict = ScanStaticReflectionPredictor(experiment, dmin=3, margin=1)
refl = predict.for_ub(experiment.crystal.get_A())
miller_set = miller.set(
experiment.crystal.get_crystal_symmetry(),
refl["miller_index"],
anomalous_flag=False,
)
miller_array = miller_set.d_spacings().resolution_filter(d_min=3)
complete_set, unique_ms = missing_reflections.connected_components(miller_array)
assert [ms.size() for ms in unique_ms] == [581, 32, 29, 6, 3, 3, 3, 2]
# Verify that all the indices reported missing are actually missing from the input
for ms in unique_ms:
assert ms.common_set(miller_array.map_to_asu()).size() == 0
assert complete_set.completeness() == 1
def test_connected_components(dials_data):
experiment = ExperimentList.from_file(
dials_data("centroid_test_data").join("experiments.json").strpath
)[0]
image_ranges = [(1, 9), (1, 100), (1, 1000)]
expected_ms_sizes = [[755], [242, 14, 10, 5, 2, 2, 2], []]
for image_range, expected_sizes in zip(image_ranges, expected_ms_sizes):
experiment.scan.set_image_range(image_range)
predict = ScanStaticReflectionPredictor(experiment, dmin=3, margin=1)
refl = predict.for_ub(experiment.crystal.get_A())
miller_set = miller.set(
experiment.crystal.get_crystal_symmetry(),
refl["miller_index"],
anomalous_flag=False,
)
miller_array = miller_set.d_spacings().resolution_filter(d_min=3)
complete_set, unique_ms = missing_reflections.connected_components(miller_array)
assert len(unique_ms) == len(expected_sizes)
assert [ms.size() for ms in unique_ms] == expected_sizes
# Verify that all the indices reported missing are actually missing from the input
for ms in unique_ms:
assert ms.common_set(miller_array.map_to_asu()).size() == 0
assert complete_set.completeness() == 1
def run(args=None,
phil=phil_scope): # type: (List[str], libtbx.phil.scope) -> None
usage = "dials.missing_reflections [options] scaled.expt scaled.refl"
parser = OptionParser(
usage=usage,
phil=phil,
read_reflections=True,
read_experiments=True,
check_format=False,
epilog=__doc__,
)
params, options = parser.parse_args(args=args, show_diff_phil=False)
# Configure the logging.
dials.util.log.config(options.verbose)
logger.info(dials_version())
# Log the difference between the PHIL scope definition and the active PHIL scope,
# which will include the parsed user inputs.
diff_phil = parser.diff_phil.as_str()
if diff_phil:
logger.info("The following parameters have been modified:\n%s",
diff_phil)
experiments = flatten_experiments(params.input.experiments)
reflections = flatten_reflections(params.input.reflections)
if not experiments or not reflections:
parser.print_help()
return
if len(reflections) != 1 and len(experiments) != len(reflections):
sys.exit(
"Number of experiments must equal the number of reflection tables")
from dials.util.multi_dataset_handling import (
assign_unique_identifiers,
parse_multiple_datasets,
)
reflections = parse_multiple_datasets(reflections)
experiments, reflections = assign_unique_identifiers(
experiments, reflections)
if all("inverse_scale_factor" in refl for refl in reflections):
# Assume all arrays have been scaled
miller_array = scaled_data_as_miller_array(reflections,
experiments,
anomalous_flag=False)
else:
# Else get the integrated intensities
miller_arrays = filtered_arrays_from_experiments_reflections(
experiments,
reflections,
)
miller_array = miller_arrays[0]
for ma in miller_arrays[1:]:
miller_array = miller_array.concatenate(ma)
if params.d_min or params.d_max:
miller_array = miller_array.resolution_filter(d_min=params.d_min,
d_max=params.d_max)
# Print overall summary of input miller array
s = io.StringIO()
ma_unique = miller_array.unique_under_symmetry()
ma_unique.show_comprehensive_summary(f=s)
logger.info(f"\n{s.getvalue()}")
# Get the regions of missing reflections
complete_set, unique_ms = missing_reflections.connected_components(
miller_array)
unique_ms = [
ms for ms in unique_ms if ms.size() >= params.min_component_size
]
# Print some output for user
if len(unique_ms):
logger.info(
"The following connected regions of missing reflections have been identified:"
)
n_expected = complete_set.size()
rows = []
for ms in unique_ms:
d_max, d_min = (uctbx.d_star_sq_as_d(ds2)
for ds2 in ms.min_max_d_star_sq())
rows.append([
ms.size(),
f"{100 * ms.size() / n_expected:.1f}",
f"{d_max:.2f}-{d_min:.2f}",
])
logger.info(
tabulate(
rows,
headers=["# reflections", "% missing",
"Resolution range (Å)"]))
else:
logger.info("No connected regions of missing reflections identified")