def test_Simple6ProfileModel_compute_mask(simple6_profile_model,
test_experiment):
experiments = [test_experiment]
# Create the index generator
index_generator = IndexGenerator(
experiments[0].crystal.get_unit_cell(),
experiments[0].crystal.get_space_group().type(),
2.0,
)
# Get an array of miller indices
miller_indices = index_generator.to_array()
reflections = simple6_profile_model.predict_reflections(experiments,
miller_indices,
probability=0.9973)
s2 = reflections["s2"]
s0 = matrix.col(experiments[0].beam.get_s0())
quantile = chisq_quantile(3, 0.9973)
sigma_inv = matrix.sqr(flumpy.from_numpy(
simple6_profile_model.sigma())).inverse()
for s2 in map(matrix.col, reflections["s2"]):
x = s2.normalize() * s0.length() - s2
d = (x.transpose() * sigma_inv * x)[0]
assert d < quantile
simple6_profile_model.compute_bbox(experiments, reflections)
reflections["shoebox"] = flex.shoebox(reflections["panel"],
reflections["bbox"],
allocate=True)
simple6_profile_model.compute_mask(experiments, reflections)
def test_Simple1ProfileModel_predict_reflections(
simple1_profile_model,
test_experiment,
):
# Create the index generator
index_generator = IndexGenerator(
test_experiment.crystal.get_unit_cell(),
test_experiment.crystal.get_space_group().type(),
2.0,
)
# Get an array of miller indices
miller_indices = index_generator.to_array()
reflections = simple1_profile_model.predict_reflections([test_experiment],
miller_indices,
probability=0.9973)
s0 = matrix.col(test_experiment.beam.get_s0())
quantile = chisq_quantile(3, 0.9973)
sigma_inv = matrix.sqr(flumpy.from_numpy(
simple1_profile_model.sigma())).inverse()
for s2 in reflections["s2"]:
s2_ = matrix.col(s2)
x = s2_.normalize() * s0.length() - s2_
d = (x.transpose() * sigma_inv * x)[0]
assert d < quantile
def _filter_reflections_based_on_centroid_distance(
reflection_table,
experiment,
outlier_probability=0.975,
max_separation=2,
):
"""
Filter reflections too far from predicted position
"""
# Compute the x and y residuals
Xobs, Yobs, _ = reflection_table["xyzobs.px.value"].parts()
Xcal, Ycal, _ = reflection_table["xyzcal.px"].parts()
Xres = Xobs - Xcal
Yres = Yobs - Ycal
# Compute the epsilon residual
s0_length = 1.0 / experiment.beam.get_wavelength()
s1x, s1y, s1z = reflection_table["s2"].parts()
s1_length = flex.sqrt(s1x**2 + s1y**2 + s1z**2)
Eres = s1_length - s0_length
# Initialise the fast_mcd outlier algorithm
# fast_mcd = FastMCD((Xres, Yres, Eres))
fast_mcd = FastMCD((Xres, Yres))
# get location and MCD scatter estimate
T, S = fast_mcd.get_corrected_T_and_S()
# get squared Mahalanobis distances
# d2s = maha_dist_sq((Xres, Yres, Eres), T, S)
d2s = maha_dist_sq((Xres, Yres), T, S)
# Compute the cutoff
mahasq_cutoff = chisq_quantile(2, outlier_probability)
# compare to the threshold and select reflections
selection1 = d2s < mahasq_cutoff
selection2 = flex.sqrt(Xres**2 + Yres**2) < max_separation
selection = selection1 & selection2
reflection_table = reflection_table.select(selection)
n_refl = reflection_table.size()
# Print some stuff
logger.info("-" * 80)
logger.info("Centroid outlier rejection")
logger.info(
f" Using MCD algorithm with probability = {outlier_probability}")
logger.info(" Max X residual: %f" % flex.max(flex.abs(Xres)))
logger.info(" Max Y residual: %f" % flex.max(flex.abs(Yres)))
logger.info(" Max E residual: %f" % flex.max(flex.abs(Eres)))
logger.info(" Mean X RMSD: %f" % (sqrt(flex.sum(Xres**2) / len(Xres))))
logger.info(" Mean Y RMSD: %f" % (sqrt(flex.sum(Yres**2) / len(Yres))))
logger.info(" Mean E RMSD: %f" % (sqrt(flex.sum(Eres**2) / len(Eres))))
logger.info(" MCD location estimate: %.4f, %.4f" % tuple(T))
logger.info(""" MCD scatter estimate:
%.7f, %.7f,
%.7f, %.7f""" % tuple(S))
logger.info(" Number of outliers: %d" % selection1.count(False))
logger.info(" Number of reflections with residual > %0.2f pixels: %d" %
(max_separation, selection2.count(False)))
logger.info(f"Number of reflections selection for refinement: {n_refl}")
logger.info("-" * 80)
return reflection_table