def test_plot_array_decay_plot(): """Test plot generation for array decay correction""" array_dict = { "__id__": "array", "is_scaled": True, "decay": { "n_parameters": 20, "parameters": list(range(1, 21)), "est_standard_devs": [], }, "configuration_parameters": { "corrections": ["decay"], "time_rot_interval": 10.0, "n_res_param": 5, "res_bin_width": 0.1, "n_time_param": 4, "resmin": 0.05, "valid_osc_range": [0, 100], }, } array_model = ArrayScalingModel.from_dict(array_dict) plot = plot_array_decay_plot(array_model) assert plot["array_decay_plot"]["data"][0]["x"] assert plot["array_decay_plot"]["data"][0]["y"]
def test_plot_array_absorption_plot(): """Test plot generation for array absorption_correction""" array_dict = { "__id__": "array", "is_scaled": True, "absorption": { "n_parameters": 45, "parameters": list(range(1, 46)), "est_standard_devs": [], }, "configuration_parameters": { "corrections": ["absorption"], "time_rot_interval": 10.0, "n_x_param": 3, "n_y_param": 3, "n_time_param": 5, "xmin": 0, "x_bin_width": 2, "ymin": 1, "y_bin_width": 2, "valid_osc_range": [0, 100], }, } array_model = ArrayScalingModel.from_dict(array_dict) plot = plot_array_absorption_plot(array_model) assert plot["array_absorption_plot"]["data"][0]["x"] assert plot["array_absorption_plot"]["data"][0]["y"] assert plot["array_absorption_plot"]["data"][0]["z"]
def test_model_creation_from_data(default_params, mock_exp, test_reflections): """Test the factory creation of the three standard scaling models with the default params.""" _ = KBScalingModel.from_data(default_params, [], []) _ = PhysicalScalingModel.from_data(default_params, mock_exp, test_reflections) _ = ArrayScalingModel.from_data(default_params, mock_exp, test_reflections)
def test_ArrayScalingModel(test_reflections, mock_exp): """Test the ArrayScalingModel class.""" configdict = { "corrections": ["decay", "absorption", "modulation"], "n_res_param": 2, "n_time_param": 2, "resmin": 1.0, "res_bin_width": 1.0, "time_norm_fac": 1.0, "time_rot_interval": 1.0, "n_x_param": 2, "n_y_param": 2, "xmin": 0.0, "ymin": 0.0, "x_bin_width": 1.0, "y_bin_width": 2.0, "n_x_mod_param": 2, "n_y_mod_param": 2, "x_det_bin_width": 2.0, "y_det_bin_width": 2.0, } parameters_dict = { "decay": { "parameters": flex.double([1.2, 1.1, 1.0, 0.9]), "parameter_esds": None, }, "absorption": { "parameters": flex.double([0.1, 0.2, 0.1, 0.2, 0.1, 0.2, 0.1, 0.2]), "parameter_esds": None, }, "modulation": { "parameters": flex.double(4, 0.9), "parameter_esds": None }, } # Test standard factory initialisation arraymodel = ArrayScalingModel(parameters_dict, configdict) assert arraymodel.id_ == "array" assert "decay" in arraymodel.components assert "absorption" in arraymodel.components assert "modulation" in arraymodel.components assert list( arraymodel.components["decay"].parameters) == [1.2, 1.1, 1.0, 0.9] assert list(arraymodel.components["absorption"].parameters) == [ 0.1, 0.2, 0.1, 0.2, 0.1, 0.2, 0.1, 0.2, ] assert list(arraymodel.components["modulation"].parameters) == 4 * [0.9] # Test configure reflection table _ = arraymodel.configure_components(test_reflections, mock_exp, []) # Test from_dict initialisation method for previous model case. init_dict = arraymodel.to_dict() new_array_model = ArrayScalingModel.from_dict(init_dict) assert new_array_model.id_ == "array" comps = new_array_model.components assert "modulation" in comps assert "absorption" in comps assert "decay" in comps assert list(comps["decay"].parameters) == [1.2, 1.1, 1.0, 0.9] assert list(comps["absorption"].parameters) == [ 0.1, 0.2, 0.1, 0.2, 0.1, 0.2, 0.1, 0.2, ] assert list(comps["modulation"].parameters) == 4 * [0.9] # Test from_dict initialisation method for another case. array_dict = { "__id__": "array", "is_scaled": True, "decay": { "n_parameters": 4, "parameters": [0.5, 1.0, 0.4, 1.0], "null_parameter_value": 1.0, "est_standard_devs": [0.05, 0.1, 0.05, 0.1], }, "configuration_parameters": { "corrections": ["decay"], "n_res_param": 2, "n_time_param": 2, "resmin": 1.0, "res_bin_width": 1.0, "time_norm_fac": 1.0, "time_rot_interval": 1.0, }, } arraymodel = ArrayScalingModel.from_dict(array_dict) assert arraymodel.id_ == "array" comps = arraymodel.components assert "modulation" not in comps assert "absorption" not in comps assert "decay" in comps assert list(comps["decay"].parameters) == [0.5, 1.0, 0.4, 1.0] assert list(comps["decay"].parameter_esds) == [0.05, 0.1, 0.05, 0.1] new_dict = arraymodel.to_dict() assert new_dict == array_dict with pytest.raises(RuntimeError): array_dict["__id__"] = "physical" arraymodel = ArrayScalingModel.from_dict(array_dict) assert len(arraymodel.consecutive_refinement_order) == 3 assert "Decay component" in str(arraymodel) # test limit batch range configdict = { "corrections": ["decay", "absorption"], "n_res_param": 2, "n_time_param": 3, "resmin": 1.0, "res_bin_width": 1.0, "time_norm_fac": 0.1, "time_rot_interval": 10.0, "n_x_param": 2, "n_y_param": 2, "xmin": 0.0, "ymin": 0.0, "x_bin_width": 1.0, "y_bin_width": 2.0, "n_x_mod_param": 2, "n_y_mod_param": 2, "x_det_bin_width": 2.0, "y_det_bin_width": 2.0, "valid_image_range": (1, 20), "valid_osc_range": (0, 20), } parameters_dict = { "decay": { "parameters": flex.double([1.2, 1.1, 1.0, 0.9, 0.8, 0.7]), "parameter_esds": None, }, "absorption": { "parameters": flex.double( [0.1, 0.2, 0.1, 0.2, 0.1, 0.2, 0.1, 0.2, 0.3, 0.4, 0.3, 0.4]), "parameter_esds": None, }, } array = ArrayScalingModel(parameters_dict, configdict) array.limit_image_range((1, 10)) assert list(array.components["decay"].parameters) == [1.2, 1.1, 1.0, 0.9] assert list(array.components["absorption"].parameters) == [ 0.1, 0.2, 0.1, 0.2, 0.1, 0.2, 0.1, 0.2, ] assert array.configdict["n_time_param"] == 2 assert array.configdict["valid_image_range"] == (1, 10) assert array.configdict["valid_osc_range"] == (0, 10)
def from_dict(d): """creates a scaling model from a dict""" from dials.algorithms.scaling.model.model import ArrayScalingModel return ArrayScalingModel.from_dict(d)