def test_TargetScalerFactory(generated_param, mock_scaling_component):
"""Test the target scaler factory."""
refl_list, explist = test_refl_and_exp_list(mock_scaling_component, 3)
# Test standard initialisation.
assert generated_param.scaling_options.use_free_set is False # just to check
explist[0].scaling_model.is_scaled = True
explist[1].scaling_model.is_scaled = True
target = TargetScalerFactory.create(generated_param, explist, refl_list)
assert isinstance(target, TargetScaler)
assert len(target.single_scalers) == 2
assert len(target.unscaled_scalers) == 1
assert set(target.single_scalers[0].reflection_table["id"]) == {0}
assert set(target.single_scalers[1].reflection_table["id"]) == {1}
assert set(target.unscaled_scalers[0].reflection_table["id"]) == {2}
# Now test converting targetscaler to multiscaler
multiscaler = MultiScalerFactory.create_from_targetscaler(target)
assert isinstance(multiscaler, MultiScaler)
assert len(multiscaler.single_scalers) == 3
# Test for correct initialisation when scaling against a target model.
generated_param.scaling_options.target_model = True
target = TargetScalerFactory.create_for_target_against_reference(
generated_param, explist, refl_list)
assert isinstance(target.single_scalers[0], NullScaler)
# This time make one dataset bad, and check it gets removed
refl_list, explist = test_refl_and_exp_list(mock_scaling_component, 3)
generated_param.scaling_options.target_model = False
refl_list[1].unset_flags(flex.bool(4, True),
refl_list[1].flags.integrated_prf)
refl_list[1].unset_flags(flex.bool(4, True),
refl_list[1].flags.integrated_sum)
explist[0].scaling_model.is_scaled = True
target = TargetScalerFactory.create(generated_param, explist, refl_list)
assert isinstance(target, TargetScaler)
assert len(target.single_scalers) == 1
assert len(target.unscaled_scalers) == 1
assert set(target.single_scalers[0].reflection_table["id"]) == {0}
assert set(target.unscaled_scalers[0].reflection_table["id"]) == {2}
refl_list, explist = test_refl_and_exp_list(mock_scaling_component, 3)
refl_list[0].unset_flags(flex.bool(4, True),
refl_list[0].flags.integrated_prf)
refl_list[0].unset_flags(flex.bool(4, True),
refl_list[0].flags.integrated_sum)
explist[0].scaling_model.is_scaled = True
explist[1].scaling_model.is_scaled = True
target = TargetScalerFactory.create(generated_param, explist, refl_list)
assert isinstance(target, TargetScaler)
assert len(target.single_scalers) == 1
assert len(target.unscaled_scalers) == 1
assert set(target.single_scalers[0].reflection_table["id"]) == {1}
assert set(target.unscaled_scalers[0].reflection_table["id"]) == {2}
def test_TargetScalerFactory(generated_param, mock_scaling_component):
"""Test the target scaler factory."""
refl_list, explist = test_refl_and_exp_list(mock_scaling_component, 3)
# Test standard initialisation.
assert generated_param.scaling_options.use_free_set is False # just to check
target = TargetScalerFactory.create(
generated_param, explist, refl_list, is_scaled_list=[True, True, False]
)
assert isinstance(target, TargetScaler)
assert len(target.single_scalers) == 2
assert len(target.unscaled_scalers) == 1
assert set(target.single_scalers[0].reflection_table["id"]) == {0}
assert set(target.single_scalers[1].reflection_table["id"]) == {1}
assert set(target.unscaled_scalers[0].reflection_table["id"]) == {2}
# Test for correct initialisation hen scaling against a target model.
generated_param.scaling_options.target_model = True
target = TargetScalerFactory.create(
generated_param, explist, refl_list, is_scaled_list=[True, True, False]
)
assert isinstance(target.single_scalers[0], NullScaler)
assert isinstance(target.single_scalers[1], NullScaler)
# Now test converting targetscaler to multiscaler
multiscaler = MultiScalerFactory.create_from_targetscaler(target)
assert isinstance(multiscaler, MultiScaler)
assert len(multiscaler.single_scalers) == 3
# This time make one dataset bad, and check it gets removed
refl_list, explist = test_refl_and_exp_list(mock_scaling_component, 3)
generated_param.scaling_options.target_model = False
refl_list[1]["d"] = flex.double([-0.1, -0.1, -0.1, -0.1])
target = TargetScalerFactory.create(
generated_param, explist, refl_list, is_scaled_list=[True, False, False]
)
assert isinstance(target, TargetScaler)
assert len(target.single_scalers) == 1
assert len(target.unscaled_scalers) == 1
assert set(target.single_scalers[0].reflection_table["id"]) == {0}
assert set(target.unscaled_scalers[0].reflection_table["id"]) == {2}
refl_list, explist = test_refl_and_exp_list(mock_scaling_component, 3)
refl_list[0]["d"] = flex.double([-0.1, -0.1, -0.1, -0.1])
target = TargetScalerFactory.create(
generated_param, explist, refl_list, is_scaled_list=[True, True, False]
)
assert isinstance(target, TargetScaler)
assert len(target.single_scalers) == 1
assert len(target.unscaled_scalers) == 1
assert set(target.single_scalers[0].reflection_table["id"]) == {1}
assert set(target.unscaled_scalers[0].reflection_table["id"]) == {2}
def scale_against_target(
reflection_table,
experiment,
target_reflection_table,
target_experiment,
params=None,
model="KB",
):
"""Determine scale factors for a single dataset, by scaling against a target
reflection table. Requires a single reflection table for the reflections to
scale and the target dataset, and an ExperimentList for both datasets. The
params option can also be specified, if None then the default scaling
configuration is used. The scaling model can be specified individually.
Returns the reflection table, with added columns 'inverse_scale_factor' and
'inverse_scale_factor_variance'."""
assert model in ["physical", "array", "KB"]
if not params:
phil_scope = phil.parse(
"""
include scope dials.algorithms.scaling.scaling_options.phil_scope
include scope dials.algorithms.scaling.scaling_refiner.scaling_refinery_phil_scope
""",
process_includes=True,
)
optionparser = OptionParser(phil=phil_scope, check_format=False)
params, _ = optionparser.parse_args(args=[], quick_parse=True)
params.__inject__("model", model)
from dials.algorithms.scaling.scaler_factory import TargetScalerFactory
reflections = [reflection_table, target_reflection_table]
experiment.append(target_experiment[0])
experiments = create_scaling_model(params, experiment, reflections)
scaler = TargetScalerFactory.create(params,
experiments,
reflections,
is_scaled_list=[False, True])
scaler.perform_scaling()
scaler.expand_scales_to_all_reflections(calc_cov=True)
return scaler.unscaled_scalers[0].reflection_table
def test_scale_against_target(KB_test_param):
"""Integration testing of the scale_against_target library function/targeted
scaling."""
# Based on input - have Target Ih of 1.0, 10.0 and d of 1.0, 2.0. Then refl to
# target have I's of 2 and 5, (with the same ds). Therefore for a KB model the
# problem can be minimised exactly by solving the equations:
# 2 = K * exp(B/2)
# 1/2 = K * exp(B/8)
# Solving these gives the form tested for at the end of this test.
target_reflections = test_target_refl()
reflections = test_refl_to_scale()
target_experiments = test_exp()
experiments = test_exp(idval=1)
scaled_reflections = scale_against_target(
reflections, experiments, target_reflections, target_experiments
)
assert approx_equal(
list(scaled_reflections["inverse_scale_factor"]),
[2.0, 0.5, 2.0, 2.0 * (4.0 ** (-1.0 / 3.0))],
)
experiments = test_exp()
experiments.append(test_exp(idval=1)[0])
experiments[0].scaling_model = KBSMFactory.create(KB_test_param, [], [])
experiments[1].scaling_model = KBSMFactory.create(KB_test_param, [], [])
target_reflections = test_target_refl()
reflections = test_refl_to_scale()
# Repeat the test but calling the TargetScaler directly, to allow inspection
# of the model components.
targetscaler = TargetScalerFactory.create(
KB_test_param, experiments, [target_reflections, reflections], [True, False]
)
targetscaler.perform_scaling()
assert approx_equal(
list(targetscaler.unscaled_scalers[0].components["scale"].parameters),
[(4.0 ** (-1.0 / 3.0)) / 2.0],
)
assert approx_equal(
list(targetscaler.unscaled_scalers[0].components["decay"].parameters),
[(log(4.0) * 8.0 / 3.0)],
)