def test_multiscaler_update_for_minimisation():
"""Test the multiscaler update_for_minimisation method."""
p, e = (generated_param(), generated_exp(2))
p.reflection_selection.method = "use_all"
r1 = generated_refl(id_=0)
r1["intensity.sum.value"] = r1["intensity"]
r1["intensity.sum.variance"] = r1["variance"]
r2 = generated_refl(id_=1)
r2["intensity.sum.value"] = r2["intensity"]
r2["intensity.sum.variance"] = r2["variance"]
p.scaling_options.nproc = 2
p.model = "physical"
exp = create_scaling_model(p, e, [r1, r2])
singlescaler1 = create_scaler(p, [exp[0]], [r1])
singlescaler2 = create_scaler(p, [exp[1]], [r2])
multiscaler = MultiScaler([singlescaler1, singlescaler2])
pmg = ScalingParameterManagerGenerator(
multiscaler.active_scalers,
ScalingTarget,
multiscaler.params.scaling_refinery.refinement_order,
)
multiscaler.single_scalers[0].components["scale"].parameters /= 2.0
multiscaler.single_scalers[1].components["scale"].parameters *= 1.5
apm = pmg.parameter_managers()[0]
multiscaler.update_for_minimisation(apm, 0)
multiscaler.update_for_minimisation(apm, 1)
# bf[0], bf[1] should be list of scales and derivatives
s1, d1 = RefinerCalculator.calculate_scales_and_derivatives(
apm.apm_list[0], 0)
s2, d2 = RefinerCalculator.calculate_scales_and_derivatives(
apm.apm_list[1], 0)
s3, d3 = RefinerCalculator.calculate_scales_and_derivatives(
apm.apm_list[0], 1)
s4, d4 = RefinerCalculator.calculate_scales_and_derivatives(
apm.apm_list[1], 1)
expected_scales_for_block_1 = s1
expected_scales_for_block_1.extend(s2)
expected_scales_for_block_2 = s3
expected_scales_for_block_2.extend(s4)
expected_derivatives_for_block_1 = sparse.matrix(
expected_scales_for_block_1.size(), apm.n_active_params)
expected_derivatives_for_block_2 = sparse.matrix(
expected_scales_for_block_2.size(), apm.n_active_params)
expected_derivatives_for_block_1.assign_block(d1, 0, 0)
expected_derivatives_for_block_1.assign_block(d2, d1.n_rows,
apm.apm_data[1]["start_idx"])
expected_derivatives_for_block_2.assign_block(d3, 0, 0)
expected_derivatives_for_block_2.assign_block(d4, d3.n_rows,
apm.apm_data[1]["start_idx"])
block_list = multiscaler.Ih_table.blocked_data_list
assert block_list[0].inverse_scale_factors == expected_scales_for_block_1
assert block_list[1].inverse_scale_factors == expected_scales_for_block_2
assert block_list[1].derivatives == expected_derivatives_for_block_2
assert block_list[0].derivatives == expected_derivatives_for_block_1
def create_from_targetscaler(cls, targetscaler):
"""method to pass scalers from TargetScaler to a MultiScaler"""
single_scalers = []
for scaler in targetscaler.unscaled_scalers:
single_scalers.append(scaler)
single_scalers.extend(targetscaler.single_scalers)
multiscaler = MultiScaler(single_scalers)
multiscaler.observers = targetscaler.observers
return multiscaler
def create_from_targetscaler(cls, targetscaler):
"""method to pass scalers from TargetScaler to a MultiScaler"""
single_scalers = []
for scaler in targetscaler.unscaled_scalers:
# scaler.select_reflections_for_scaling(for_multi=True)
single_scalers.append(scaler)
single_scalers.extend(targetscaler.single_scalers)
multiscaler = MultiScaler(targetscaler.params,
[targetscaler.experiment], single_scalers)
multiscaler.observers = targetscaler.observers
return multiscaler
def create(cls, params, experiments, reflections):
"""create a list of single scalers to pass to a MultiScaler."""
single_scalers = []
offset = 0
for i in range(len(reflections)):
# Remove bad datasets that literally have no integrated reflections
try:
scaler = SingleScalerFactory.create(
params,
experiments[i - offset],
reflections[i - offset],
for_multi=True,
)
single_scalers.append(scaler)
except BadDatasetForScalingException as e:
logger.info(e)
logger.info("Removing experiment " + str(i) + "\n" + "=" * 80 +
"\n")
del experiments[i - offset]
del reflections[i - offset]
offset += 1
assert len(experiments) == len(single_scalers), (
len(experiments),
len(single_scalers),
)
assert len(experiments) == len(reflections), (
len(experiments),
len(reflections),
)
determine_reflection_selection_parameters(params, experiments,
reflections)
return MultiScaler(params, experiments, single_scalers)
def create(cls, params, experiments, reflections):
"""create a list of single scalers to pass to a MultiScaler."""
single_scalers = []
idx_to_remove = []
for i, (expt, refl) in enumerate(zip(experiments, reflections)):
# Remove bad datasets that literally have no integrated reflections
try:
scaler = SingleScalerFactory.create(params,
expt,
refl,
for_multi=True)
except BadDatasetForScalingException as e:
logger.info(e)
idx_to_remove.append(i)
else:
single_scalers.append(scaler)
if idx_to_remove:
for j in idx_to_remove[::-1]:
del experiments[j]
del reflections[j]
logger.info("Removed experiments %s",
" ".join(str(i) for i in idx_to_remove))
n_exp, n_refl, n_ss = (len(experiments), len(reflections),
len(single_scalers))
assert n_exp == n_ss, (n_exp, n_ss)
assert n_exp == n_refl, (n_exp, n_refl)
return MultiScaler(single_scalers)
def test_multiscaler_initialisation():
"""Unit tests for the MultiScalerBase class."""
p, e = (generated_param(), generated_exp(2))
r1 = generated_refl(id_=0)
r1["intensity.sum.value"] = r1["intensity"]
r1["intensity.sum.variance"] = r1["variance"]
r2 = generated_refl(id_=1)
r2["intensity.sum.value"] = r2["intensity"]
r2["intensity.sum.variance"] = r2["variance"]
exp = create_scaling_model(p, e, [r1, r2])
singlescaler1 = create_scaler(p, [exp[0]], [r1])
singlescaler2 = create_scaler(p, [exp[1]], [r2])
multiscaler = MultiScaler([singlescaler1, singlescaler2])
# check initialisation
assert len(multiscaler.active_scalers) == 2
assert multiscaler.active_scalers[0] == singlescaler1
assert multiscaler.active_scalers[1] == singlescaler2
# check for correct setup of global Ih table
assert multiscaler.global_Ih_table.size == 14
assert (
list(multiscaler.global_Ih_table.blocked_data_list[0].intensities)
== [3.0, 1.0, 500.0, 2.0, 2.0, 2.0, 4.0] * 2
)
block_selections = multiscaler.global_Ih_table.blocked_data_list[0].block_selections
assert list(block_selections[0]) == [2, 0, 4, 5, 6, 1, 3]
assert list(block_selections[1]) == [2, 0, 4, 5, 6, 1, 3]
# check for correct setup of Ih_table
assert multiscaler.Ih_table.size == 12
assert (
list(multiscaler.Ih_table.blocked_data_list[0].intensities)
== [3.0, 1.0, 2.0, 2.0, 2.0, 4.0] * 2
)
block_selections = multiscaler.Ih_table.blocked_data_list[0].block_selections
assert list(block_selections[0]) == [2, 0, 5, 6, 1, 3]
assert list(block_selections[1]) == [2, 0, 5, 6, 1, 3]
# check for correct data/d_values in components
for i, scaler in enumerate(multiscaler.active_scalers):
d_suitable = scaler.reflection_table["d"].select(
scaler.suitable_refl_for_scaling_sel
)
decay = scaler.experiment.scaling_model.components["decay"]
# first check 'data' contains all suitable reflections
assert list(decay.data["d"]) == list(d_suitable)
# Now check 'd_values' (which will be used for minim.) matches Ih_table data
assert list(decay.d_values[0]) == list(
d_suitable.select(flumpy.from_numpy(block_selections[i]))
)