def reflections_as_miller_arrays(self, combined=False):
from dials.util.batch_handling import (
# calculate_batch_offsets,
# get_batch_ranges,
assign_batches_to_reflections, )
from dials.report.analysis import scaled_data_as_miller_array
# offsets = calculate_batch_offsets(experiments)
reflection_tables = []
for id_ in set(self._reflections["id"]).difference({-1}):
reflection_tables.append(
self._reflections.select(self._reflections["id"] == id_))
offsets = [expt.scan.get_batch_offset() for expt in self._experiments]
reflection_tables = assign_batches_to_reflections(
reflection_tables, offsets)
if combined:
# filter bad refls and negative scales
batches = flex.int()
scales = flex.double()
for r in reflection_tables:
sel = ~r.get_flags(r.flags.bad_for_scaling, all=False)
sel &= r["inverse_scale_factor"] > 0
batches.extend(r["batch"].select(sel))
scales.extend(r["inverse_scale_factor"].select(sel))
scaled_array = scaled_data_as_miller_array(reflection_tables,
self._experiments)
batch_array = miller.array(scaled_array, data=batches)
scale_array = miller.array(scaled_array, data=scales)
return scaled_array, batch_array, scale_array
else:
scaled_arrays = []
batch_arrays = []
scale_arrays = []
for expt, r in zip(self._experiments, reflection_tables):
sel = ~r.get_flags(r.flags.bad_for_scaling, all=False)
sel &= r["inverse_scale_factor"] > 0
batches = r["batch"].select(sel)
scales = r["inverse_scale_factor"].select(sel)
scaled_arrays.append(scaled_data_as_miller_array([r], [expt]))
batch_arrays.append(
miller.array(scaled_arrays[-1], data=batches))
scale_arrays.append(
miller.array(scaled_arrays[-1], data=scales))
return scaled_arrays, batch_arrays, scale_arrays
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")
def do_connected_components(
experiments, # type: ExperimentList
reflection_tables, # type: flex.reflection_table
min_component_size=50, # type: int
): # type: (...) -> [{}]
"""
Write the behaviour of the program as functions and classes outside run().
Don't include file output here, remember that this function may be re-used
elsewhere by someone who doesn't need the output written immediately to file.
It can be especially helpful to document any expected exceptions that might be
raised, in order to keep track of what needs to be handled in any code that
re-uses this function.
Args:
experiments: An experiment list.
reflections: A reflection table.
"""
miller_array = scaled_data_as_miller_array(
reflection_tables, experiments,
anomalous_flag=False).primitive_setting()
unique = miller_array.unique_under_symmetry().map_to_asu()
unique = unique.generate_bijvoet_mates()
complete_set = unique.complete_set()
missing_set = complete_set.lone_set(unique)
missing_set = missing_set.expand_to_p1().customized_copy(
crystal_symmetry=missing_set.crystal_symmetry())
mi = missing_set.indices().as_vec3_double().as_double()
k = 6
ann = AnnAdaptor(data=mi, dim=3, k=k)
ann.query(mi)
G = nx.Graph()
distance_cutoff = 2**0.5
for i in range(missing_set.size()):
ik = i * k
for i_ann in range(k):
if ann.distances[ik + i_ann] <= distance_cutoff:
j = ann.nn[ik + i_ann]
G.add_edge(i, j)
conn = sorted(nx.connected_components(G), key=len, reverse=True)
unique_mi = []
unique_ms = []
for i, c in enumerate(conn):
ms = (missing_set.select(flex.size_t(list(c))).customized_copy(
crystal_symmetry=miller_array).as_non_anomalous_set().map_to_asu())
ms = ms.unique_under_symmetry()
mi = set(ms.indices())
if mi not in unique_mi:
unique_ms.append(ms)
unique_mi.append(mi)
n_expected = unique.as_non_anomalous_set().complete_set().size()
unique_ms = sorted(unique_ms, key=lambda ms: ms.size(), reverse=True)
unique_ms = [ms for ms in unique_ms if ms.size() > min_component_size]
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())
logger.info("%i reflections (%.1f%%): %.2f-%.2f Å" %
(ms.size(), 100 * ms.size() / n_expected, d_max, d_min))
return unique_ms