コード例 #1
0
class CalibrationModelTest(unittest.TestCase):
    def setUp(self):
        self.model = CalibrationModel()

    def test_fails_on_invalid_run_number(self):
        self.assertRaises(RuntimeError, self.model.create_new_calibration,
                          "FAIL", "305738", True, "ENGINX")
        self.assertRaises(RuntimeError, self.model.create_new_calibration,
                          "307521", "FAIL", True, "ENGINX")

    @patch(class_path + '.update_calibration_params_table')
    @patch(class_path + '.create_output_files')
    @patch(class_path + '.run_calibration')
    @patch(file_path + ".path_handling.load_workspace")
    @patch(file_path + '.vanadium_corrections.fetch_correction_workspaces')
    def test_EnggVanadiumCorrections_algorithm_is_called(
            self, van, load_sample, calib, output_files, update_table):
        van.return_value = ("A", "B")
        self.model.create_new_calibration(VANADIUM_NUMBER, CERIUM_NUMBER,
                                          False, "ENGINX")
        van.assert_called_once()

    @patch(class_path + '.update_calibration_params_table')
    @patch(class_path + '.create_output_files')
    @patch(file_path + ".path_handling.load_workspace")
    @patch(class_path + '.run_calibration')
    @patch(file_path + '.vanadium_corrections.fetch_correction_workspaces')
    def test_fetch_vanadium_is_called(self, van_corr, calibrate_alg,
                                      load_sample, output_files, update_table):
        van_corr.return_value = ("mocked_integration", "mocked_curves")
        self.model.create_new_calibration(VANADIUM_NUMBER, CERIUM_NUMBER,
                                          False, "ENGINX")
        self.assertEqual(van_corr.call_count, 1)

    @patch(file_path + '.path.exists')
    @patch(file_path + '.get_setting')
    @patch(class_path + '.update_calibration_params_table')
    @patch(class_path + '.create_output_files')
    @patch(file_path + '.LoadAscii')
    @patch(file_path + ".path_handling.load_workspace")
    @patch(class_path + '.run_calibration')
    @patch(file_path + '.vanadium_corrections.fetch_correction_workspaces')
    def test_having_full_calib_set_uses_file(self, van_corr, calibrate_alg,
                                             load_workspace, load_ascii,
                                             output_files, update_table,
                                             setting, path):
        path.return_value = True
        setting.return_value = "mocked/out/path"
        van_corr.return_value = ("mocked_integration", "mocked_curves")
        load_workspace.return_value = "mocked_workspace"
        load_ascii.return_value = "mocked_det_pos"
        self.model.create_new_calibration(VANADIUM_NUMBER, CERIUM_NUMBER,
                                          False, "ENGINX")
        calibrate_alg.assert_called_with("mocked_workspace",
                                         "mocked_integration",
                                         "mocked_curves",
                                         None,
                                         None,
                                         full_calib_ws="mocked_det_pos")

    @patch(class_path + '.update_calibration_params_table')
    @patch(class_path + '.create_output_files')
    @patch(file_path + ".path_handling.load_workspace")
    @patch(file_path + '.vanadium_corrections.fetch_correction_workspaces')
    @patch(class_path + '._plot_vanadium_curves')
    @patch(class_path + '._generate_tof_fit_workspace')
    @patch(class_path + '._plot_tof_fit')
    @patch(class_path + '.run_calibration')
    def test_plotting_check(self, calib, plot_tof, gen_tof, plot_van, van,
                            sample, output_files, update_table):
        calib.return_value = [MagicMock(), MagicMock()]
        van.return_value = ("A", "B")
        self.model.create_new_calibration(VANADIUM_NUMBER, CERIUM_NUMBER,
                                          False, "ENGINX")
        plot_van.assert_not_called()
        plot_tof.assert_not_called()
        gen_tof.assert_not_called()
        self.model.create_new_calibration(VANADIUM_NUMBER, CERIUM_NUMBER, True,
                                          "ENGINX")
        plot_van.assert_called_once()
        self.assertEqual(gen_tof.call_count, 2)
        self.assertEqual(plot_tof.call_count, 1)

    @patch(class_path + '.update_calibration_params_table')
    @patch(class_path + '.create_output_files')
    @patch(file_path + ".path_handling.load_workspace")
    @patch(file_path + '.vanadium_corrections.fetch_correction_workspaces')
    @patch(class_path + '._plot_vanadium_curves')
    @patch(class_path + '._generate_tof_fit_workspace')
    @patch(class_path + '._plot_tof_fit')
    @patch(class_path + '._plot_tof_fit_single_bank_or_custom')
    @patch(class_path + '.run_calibration')
    def test_plotting_check_cropped(self, calib, plot_tof_cus, plot_tof_fit,
                                    gen_tof, plot_van, van, sample,
                                    output_files, update_table):
        calib.return_value = [MagicMock()]
        van.return_value = ("A", "B")
        self.model.create_new_calibration(VANADIUM_NUMBER, CERIUM_NUMBER,
                                          False, "ENGINX")
        plot_van.assert_not_called()
        plot_tof_cus.assert_not_called()
        plot_tof_fit.assert_not_called()
        gen_tof.assert_not_called()
        self.model.create_new_calibration(VANADIUM_NUMBER,
                                          CERIUM_NUMBER,
                                          True,
                                          "ENGINX",
                                          bank=1)
        plot_van.assert_called_once()
        self.assertEqual(gen_tof.call_count, 1)
        plot_tof_fit.assert_not_called()
        self.assertEqual(plot_tof_cus.call_count, 1)

    @patch(class_path + '.update_calibration_params_table')
    @patch(class_path + '.create_output_files')
    @patch(file_path + ".path_handling.load_workspace")
    @patch(file_path + '.vanadium_corrections.fetch_correction_workspaces')
    @patch(class_path + '._plot_vanadium_curves')
    @patch(class_path + '._plot_tof_fit')
    @patch(class_path + '.run_calibration')
    def test_present_RB_number_results_in_user_output_files(
            self, calib, plot_tof, plot_van, van, sample, output_files,
            update_table):
        van.return_value = ("A", "B")
        self.model.create_new_calibration(VANADIUM_NUMBER,
                                          CERIUM_NUMBER,
                                          False,
                                          "ENGINX",
                                          rb_num="00110")
        self.assertEqual(output_files.call_count, 2)

    @patch(class_path + '.update_calibration_params_table')
    @patch(class_path + '.create_output_files')
    @patch(file_path + ".path_handling.load_workspace")
    @patch(file_path + '.vanadium_corrections.fetch_correction_workspaces')
    @patch(class_path + '._plot_vanadium_curves')
    @patch(class_path + '._plot_tof_fit')
    @patch(class_path + '.run_calibration')
    def test_absent_run_number_results_in_no_user_output_files(
            self, calib, plot_tof, plot_van, van, sample, output_files,
            update_table):
        van.return_value = ("A", "B")
        self.model.create_new_calibration(VANADIUM_NUMBER, CERIUM_NUMBER,
                                          False, "ENGINX")
        self.assertEqual(output_files.call_count, 1)

    @patch(class_path + '.update_calibration_params_table')
    @patch(class_path + '.create_output_files')
    @patch(file_path + ".path_handling.load_workspace")
    @patch(file_path + '.vanadium_corrections.fetch_correction_workspaces')
    @patch(class_path + '.run_calibration')
    def test_calibration_params_table_is_updated(self, calibrate_alg,
                                                 vanadium_alg, load_sample,
                                                 output_files, update_table):
        vanadium_alg.return_value = ("A", "B")
        self.model.create_new_calibration(VANADIUM_NUMBER, CERIUM_NUMBER,
                                          False, "ENGINX")
        self.assertEqual(calibrate_alg.call_count, 1)

    @patch(class_path + '._generate_output_file_name')
    @patch(
        'Engineering.gui.engineering_diffraction.tabs.calibration.model.makedirs'
    )
    @patch(
        'Engineering.gui.engineering_diffraction.tabs.calibration.model.write_ENGINX_GSAS_iparam_file'
    )
    def test_create_output_files(self, write_file, make_dirs, output_name):
        sample_path = "test2/test3/ENGINX20.nxs"
        vanadium_path = "test4/ENGINX0010.nxs"
        filename = "output"
        output_name.return_value = filename

        self.model.create_output_files("test/", [2, 2], [0, 0], [1, 1],
                                       sample_path,
                                       vanadium_path,
                                       "ENGINX",
                                       bank=None,
                                       spectrum_numbers=None)

        self.assertEqual(make_dirs.call_count, 1)
        self.assertEqual(write_file.call_count, 3)
        write_file.assert_called_with(
            "test/" + filename, [2], [0], [1],
            bank_names=['South'],
            ceria_run="20",
            template_file="template_ENGINX_241391_236516_South_bank.prm",
            vanadium_run="10")

    def test_generate_table_workspace_name(self):
        self.assertEqual(self.model._generate_table_workspace_name(20),
                         "engggui_calibration_bank_20")

    def test_generate_output_file_name_for_north_bank(self):
        filename = self.model._generate_output_file_name(
            "test/20.raw", "test/10.raw", "ENGINX", "north")
        self.assertEqual(filename, "ENGINX_20_10_bank_North.prm")

    def test_generate_output_file_name_for_south_bank(self):
        filename = self.model._generate_output_file_name(
            "test/20.raw", "test/10.raw", "ENGINX", "south")
        self.assertEqual(filename, "ENGINX_20_10_bank_South.prm")

    def test_generate_output_file_name_for_both_banks(self):
        filename = self.model._generate_output_file_name(
            "test/20.raw", "test/10.raw", "ENGINX", "all")
        self.assertEqual(filename, "ENGINX_20_10_all_banks.prm")

    def test_generate_output_file_name_for_cropped_bank(self):
        filename = self.model._generate_output_file_name(
            "test/20.raw", "test/10.raw", "ENGINX", "cropped")
        self.assertEqual(filename, "ENGINX_20_10_cropped.prm")

    def test_generate_output_file_name_for_invalid_bank(self):
        self.assertRaises(ValueError, self.model._generate_output_file_name,
                          "test/20.raw", "test/10.raw", "ENGINX", "INVALID")

    def test_generate_output_file_name_with_no_ext_in_filename(self):
        filename = self.model._generate_output_file_name(
            "test/20", "test/10.raw", "ENGINX", "north")
        self.assertEqual(filename, "ENGINX_20_10_bank_North.prm")

    def test_generate_output_file_name_with_no_path_in_filename(self):
        filename = self.model._generate_output_file_name(
            "20.raw", "test/10.raw", "ENGINX", "north")
        self.assertEqual(filename, "ENGINX_20_10_bank_North.prm")

    @patch("Engineering.gui.engineering_diffraction.tabs.calibration.model.Ads"
           )
    def test_update_calibration_params_table_retrieves_workspace(self, ads):
        table = [[0, 18414.900000000001, 0.0, -11.82],
                 [1, 18497.75, 0.0, -26.5]]

        self.model.update_calibration_params_table(table)

        self.assertEqual(ads.retrieve.call_count, 1)

    @patch("Engineering.gui.engineering_diffraction.tabs.calibration.model.Ads"
           )
    def test_update_calibration_params_table_stops_when_table_empty(self, ads):
        table = []

        self.model.update_calibration_params_table(table)

        self.assertEqual(ads.retrieve.call_count, 0)

    @patch(
        "Engineering.gui.engineering_diffraction.tabs.calibration.model.EnggCalibrate"
    )
    def test_run_calibration_no_bank_no_spec_nums_no_full_calib(self, alg):
        self.model.run_calibration("sample", "vanadium_int", "vanadium_curves",
                                   None, None)

        alg.assert_any_call(InputWorkspace="sample",
                            VanIntegrationWorkspace="vanadium_int",
                            VanCurvesWorkspace="vanadium_curves",
                            Bank="1",
                            FittedPeaks="engggui_calibration_bank_1")
        alg.assert_any_call(InputWorkspace="sample",
                            VanIntegrationWorkspace="vanadium_int",
                            VanCurvesWorkspace="vanadium_curves",
                            Bank="2",
                            FittedPeaks="engggui_calibration_bank_2")
        self.assertEqual(2, alg.call_count)

    @patch(
        "Engineering.gui.engineering_diffraction.tabs.calibration.model.EnggCalibrate"
    )
    def test_run_calibration_no_bank_no_spec_nums_full_calib(self, alg):
        self.model.run_calibration("sample",
                                   "vanadium_int",
                                   "vanadium_curves",
                                   None,
                                   None,
                                   full_calib_ws="full")

        alg.assert_any_call(InputWorkspace="sample",
                            VanIntegrationWorkspace="vanadium_int",
                            VanCurvesWorkspace="vanadium_curves",
                            Bank="1",
                            FittedPeaks="engggui_calibration_bank_1",
                            DetectorPositions="full")
        alg.assert_any_call(InputWorkspace="sample",
                            VanIntegrationWorkspace="vanadium_int",
                            VanCurvesWorkspace="vanadium_curves",
                            Bank="2",
                            FittedPeaks="engggui_calibration_bank_2",
                            DetectorPositions="full")
        self.assertEqual(2, alg.call_count)

    @patch(
        "Engineering.gui.engineering_diffraction.tabs.calibration.model.EnggCalibrate"
    )
    def test_run_calibration_bank_no_spec_nums_no_full_calib(self, alg):
        self.model.run_calibration("sample", "vanadium_int", "vanadium_curves",
                                   "1", None)

        alg.assert_any_call(InputWorkspace="sample",
                            VanIntegrationWorkspace="vanadium_int",
                            VanCurvesWorkspace="vanadium_curves",
                            Bank="1",
                            FittedPeaks="engggui_calibration_bank_1")
        self.assertEqual(1, alg.call_count)

    @patch(
        "Engineering.gui.engineering_diffraction.tabs.calibration.model.EnggCalibrate"
    )
    def test_run_calibration_no_bank_spec_nums_no_full_calib(self, alg):
        self.model.run_calibration("sample", "vanadium_int", "vanadium_curves",
                                   None, "1-5, 45-102")

        alg.assert_any_call(InputWorkspace="sample",
                            VanIntegrationWorkspace="vanadium_int",
                            VanCurvesWorkspace="vanadium_curves",
                            SpectrumNumbers="1-5, 45-102",
                            FittedPeaks="engggui_calibration_bank_cropped")
        self.assertEqual(1, alg.call_count)

    @patch(
        "Engineering.gui.engineering_diffraction.tabs.calibration.model.EnggCalibrate"
    )
    def test_run_calibration_bank_no_spec_nums_full_calib(self, alg):
        self.model.run_calibration("sample",
                                   "vanadium_int",
                                   "vanadium_curves",
                                   "1",
                                   None,
                                   full_calib_ws="full")

        alg.assert_any_call(InputWorkspace="sample",
                            VanIntegrationWorkspace="vanadium_int",
                            VanCurvesWorkspace="vanadium_curves",
                            Bank="1",
                            FittedPeaks="engggui_calibration_bank_1",
                            DetectorPositions="full")
        self.assertEqual(1, alg.call_count)

    @patch(
        "Engineering.gui.engineering_diffraction.tabs.calibration.model.EnggCalibrate"
    )
    def test_run_calibration_no_bank_spec_nums_full_calib(self, alg):
        self.model.run_calibration("sample",
                                   "vanadium_int",
                                   "vanadium_curves",
                                   None,
                                   "45-102",
                                   full_calib_ws="full")

        alg.assert_any_call(InputWorkspace="sample",
                            VanIntegrationWorkspace="vanadium_int",
                            VanCurvesWorkspace="vanadium_curves",
                            SpectrumNumbers="45-102",
                            FittedPeaks="engggui_calibration_bank_cropped",
                            DetectorPositions="full")
        self.assertEqual(1, alg.call_count)
コード例 #2
0
class CalibrationModelTest(unittest.TestCase):
    def setUp(self):
        self.model = CalibrationModel()
        mock.NonCallableMock.assert_any_call_partial = assert_any_call_partial

    def test_fails_on_invalid_run_number(self):
        self.assertRaises(RuntimeError, self.model.create_new_calibration,
                          "FAIL", "305738", True, "ENGINX")
        self.assertRaises(RuntimeError, self.model.create_new_calibration,
                          "307521", "FAIL", True, "ENGINX")

    @patch(class_path + ".get_info_from_file")
    @patch(file_path + ".path")
    @patch(file_path + ".EnggUtils")
    @patch(class_path + ".update_calibration_params_table")
    def test_load_existing_calibration_files(self, update_table, utils, path,
                                             get_info):
        path.exists.return_value = True
        get_info.return_value = "TESTINST", "ceria_no", [["params"], ["table"]]
        utils.load_custom_grouping_workspace.return_value = "grp_ws", "Region"
        inst, ceria_no, grp_ws, roi_text, bank = self.model.load_existing_calibration_files(
            "dummy.prm")

        table_test_params = [["params"], ["table"]]
        update_table.assert_called_with(table_test_params)
        self.assertEqual(1, update_table.call_count)

        self.assertEqual(1, utils.load_relevant_calibration_files.call_count)

        self.assertEqual("TESTINST", inst)
        self.assertEqual("ceria_no", ceria_no)
        self.assertEqual("grp_ws", grp_ws)
        self.assertEqual("Region", roi_text)

    def test_get_info_from_file(self):
        file_content = """ID    ENGIN-X CALIBRATION WITH CeO2 and V-Nb
INS    CALIB   241391   ceo2
INS  1 ICONS  18306.98      2.99     14.44
INS  2 ICONS  18497.75    -29.68    -26.50"""
        mocked_handle = mock.mock_open(read_data=file_content)
        dummy_file_path = "/foo/bar_123.prm"
        patchable = "builtins.open"
        with mock.patch(patchable, mocked_handle):
            instrument, ceria_no, params_table = self.model.get_info_from_file(
                dummy_file_path)
        self.assertEqual("bar", instrument)
        self.assertEqual("241391", ceria_no)
        self.assertEqual(
            [[0, 18306.98, 2.99, 14.44], [1, 18497.75, -29.68, -26.5]],
            params_table)

    @patch(file_path + ".DeleteWorkspace")
    @patch(class_path + ".update_calibration_params_table")
    @patch(class_path + ".create_output_files")
    @patch(file_path + ".path_handling.load_workspace")
    @patch(file_path + ".Load")
    @patch(file_path + ".EnggUtils")
    @patch(class_path + ".run_calibration")
    def test_plotting_check(self, calib, utils, load, sample, output_files,
                            update_table, delete):
        calib.return_value = _run_calibration_returns()
        self.model.create_new_calibration(CERIUM_NUMBER, False, "ENGINX")
        utils.plot_tof_fit.assert_not_called()
        utils.generate_tof_fit_dictionary.assert_not_called()
        self.model.create_new_calibration(CERIUM_NUMBER, True, "ENGINX")
        self.assertEqual(utils.plot_tof_fit.call_count, 1)
        self.assertEqual(utils.generate_tof_fit_dictionary.call_count, 2)

    @patch(file_path + ".DeleteWorkspace")
    @patch(class_path + ".update_calibration_params_table")
    @patch(class_path + ".create_output_files")
    @patch(file_path + ".path_handling.load_workspace")
    @patch(file_path + ".Load")
    @patch(file_path + ".EnggUtils")
    @patch(class_path + ".run_calibration")
    def test_plotting_check_cropped(self, calib, utils, load, sample,
                                    output_files, update_table, delete):
        calib.return_value = _run_calibration_returns(single_output=True)
        self.model.create_new_calibration(CERIUM_NUMBER, False, "ENGINX")
        utils.plot_tof_fit.assert_not_called()
        utils.generate_tof_fit_dictionary.assert_not_called()
        self.model.create_new_calibration(CERIUM_NUMBER,
                                          True,
                                          "ENGINX",
                                          bank=1)
        self.assertEqual(utils.plot_tof_fit.call_count, 1)
        self.assertEqual(utils.generate_tof_fit_dictionary.call_count, 1)

    @patch(file_path + ".DeleteWorkspace")
    @patch(class_path + ".update_calibration_params_table")
    @patch(class_path + ".create_output_files")
    @patch(file_path + ".path_handling.load_workspace")
    @patch(file_path + ".Load")
    @patch(class_path + ".run_calibration")
    def test_present_RB_number_results_in_user_output_files(
            self, calib, load, sample, output_files, update_table, delete):
        calib.return_value = _run_calibration_returns()
        self.model.create_new_calibration(CERIUM_NUMBER,
                                          False,
                                          "ENGINX",
                                          rb_num="00110")
        self.assertEqual(output_files.call_count, 2)

    @patch(file_path + ".DeleteWorkspace")
    @patch(class_path + ".update_calibration_params_table")
    @patch(class_path + ".create_output_files")
    @patch(file_path + ".path_handling.load_workspace")
    @patch(file_path + ".Load")
    @patch(class_path + ".run_calibration")
    def test_absent_run_number_results_in_no_user_output_files(
            self, calib, load, sample, output_files, update_table, delete):
        calib.return_value = _run_calibration_returns()
        self.model.create_new_calibration(CERIUM_NUMBER, False, "ENGINX")
        self.assertEqual(output_files.call_count, 1)

    @patch(file_path + ".DeleteWorkspace")
    @patch(class_path + ".update_calibration_params_table")
    @patch(class_path + ".create_output_files")
    @patch(file_path + ".path_handling.load_workspace")
    @patch(file_path + ".Load")
    @patch(class_path + ".run_calibration")
    def test_calibration_params_table_is_updated(self, calibrate_alg, load,
                                                 load_sample, output_files,
                                                 update_table, delete):
        calibrate_alg.return_value = _run_calibration_returns()
        self.model.create_new_calibration(CERIUM_NUMBER, False, "ENGINX")
        self.assertEqual(calibrate_alg.call_count, 1)

    def test_generate_table_workspace_name(self):
        self.assertEqual(self.model._generate_table_workspace_name(20),
                         "engggui_calibration_bank_20")

    @patch(file_path + ".Ads")
    def test_update_calibration_params_table_retrieves_workspace(self, ads):
        table = [[0, 18414.900000000001, 0.0, -11.82],
                 [1, 18497.75, 0.0, -26.5]]

        self.model.update_calibration_params_table(table)

        self.assertEqual(ads.retrieve.call_count, 1)

    @patch(file_path + ".Ads")
    def test_update_calibration_params_table_stops_when_table_empty(self, ads):
        table = []

        self.model.update_calibration_params_table(table)

        self.assertEqual(ads.retrieve.call_count, 0)

    @patch(file_path + ".DiffractionFocussing")
    @patch(file_path + ".ConvertUnits")
    @patch(file_path + ".ApplyDiffCal")
    @patch(file_path + ".NormaliseByCurrent")
    @patch(file_path + ".Load")
    @patch(file_path + ".CloneWorkspace")
    @patch(file_path + ".PDCalibration")
    @patch(file_path + ".Ads")
    @patch(file_path + ".EnggUtils")
    def test_run_calibration_no_bank_no_spec_nums(self, utils, ads, pdc,
                                                  clone_ws, load, nbc, adc,
                                                  conv, df):
        df.side_effect = ["focused_bank_1", "focused_bank_2"]
        ads.retrieve.return_value = MagicMock()
        self.model.run_calibration("sample", None, None, None, "full_calib_ws")

        pdc.assert_any_call_partial(
            InputWorkspace="focused_bank_1",
            OutputCalibrationTable="engggui_calibration_bank_1")
        pdc.assert_any_call_partial(
            InputWorkspace="focused_bank_2",
            OutputCalibrationTable="engggui_calibration_bank_2")
        self.assertEqual(2, pdc.call_count)

    @patch(file_path + ".DiffractionFocussing")
    @patch(file_path + ".ConvertUnits")
    @patch(file_path + ".ApplyDiffCal")
    @patch(file_path + ".NormaliseByCurrent")
    @patch(file_path + ".Load")
    @patch(file_path + ".CloneWorkspace")
    @patch(file_path + ".PDCalibration")
    @patch(file_path + ".Ads")
    @patch(file_path + ".EnggUtils")
    def test_run_calibration_bank_no_spec_nums(self, utils, ads, pdc, clone_ws,
                                               load, nbc, adc, conv, df):
        df.side_effect = ["focused_bank_1"]
        ads.retrieve.return_value = MagicMock()
        self.model.run_calibration("sample", '1', None, None, "full_calib_ws")

        pdc.assert_any_call_partial(
            InputWorkspace="focused_bank_1",
            OutputCalibrationTable="engggui_calibration_bank_1")
        self.assertEqual(1, pdc.call_count)

    @patch(file_path + ".DiffractionFocussing")
    @patch(file_path + ".ConvertUnits")
    @patch(file_path + ".ApplyDiffCal")
    @patch(file_path + ".NormaliseByCurrent")
    @patch(file_path + ".Load")
    @patch(file_path + ".CloneWorkspace")
    @patch(file_path + ".PDCalibration")
    @patch(file_path + ".Ads")
    @patch(file_path + ".EnggUtils")
    def test_run_calibration_no_bank_spec_nums(self, utils, ads, pdc, clone_ws,
                                               load, nbc, adc, conv, df):
        df.side_effect = ["focused_Cropped"]
        ads.retrieve.return_value = MagicMock()
        self.model.run_calibration("sample", None, None, '28-98',
                                   "full_calib_ws")

        pdc.assert_any_call_partial(
            InputWorkspace="focused_Cropped",
            OutputCalibrationTable="engggui_calibration_Cropped")
        self.assertEqual(1, pdc.call_count)

    @patch(file_path + ".DiffractionFocussing")
    @patch(file_path + ".ConvertUnits")
    @patch(file_path + ".ApplyDiffCal")
    @patch(file_path + ".NormaliseByCurrent")
    @patch(file_path + ".Load")
    @patch(file_path + ".CloneWorkspace")
    @patch(file_path + ".PDCalibration")
    @patch(file_path + ".Ads")
    @patch(file_path + ".EnggUtils")
    def test_run_calibration_custom_calfile(self, utils, ads, pdc, clone_ws,
                                            load, nbc, adc, conv, df):
        df.side_effect = ["focused_Custom"]
        ads.retrieve.return_value = MagicMock()
        self.model.run_calibration("sample", None, "/stuff/mycalfile.cal",
                                   None, "full_calib_ws")

        pdc.assert_any_call_partial(
            InputWorkspace="focused_Custom",
            OutputCalibrationTable="engggui_calibration_Custom")
        self.assertEqual(1, pdc.call_count)
コード例 #3
0
class CalibrationModelTest(unittest.TestCase):
    def setUp(self):
        self.model = CalibrationModel()

    def test_fails_on_invalid_run_number(self):
        self.assertRaises(RuntimeError, self.model.create_new_calibration, "FAIL", "305738", True,
                          "ENGINX")
        self.assertRaises(RuntimeError, self.model.create_new_calibration, "307521", "FAIL", True,
                          "ENGINX")

    @patch(class_path + '.update_calibration_params_table')
    @patch(class_path + '.create_output_files')
    @patch(class_path + '.run_calibration')
    @patch(class_path + '.load_ceria')
    @patch(class_path + '.calculate_vanadium_correction')
    def test_EnggVanadiumCorrections_algorithm_is_called(self, alg, load_ceria, calib, output_files,
                                                         update_table):
        self.model.create_new_calibration(VANADIUM_NUMBER, CERIUM_NUMBER, False, "ENGINX")
        alg.assert_called_once()

    @patch(class_path + '.update_calibration_params_table')
    @patch(class_path + '.create_output_files')
    @patch(class_path + '.load_ceria')
    @patch(class_path + '.calculate_vanadium_correction')
    @patch(class_path + '.run_calibration')
    def test_EnggCalibrate_algorithm_is_called(self, calibrate_alg, vanadium_alg, load_ceria,
                                               output_files, update_table):
        self.model.create_new_calibration(VANADIUM_NUMBER, CERIUM_NUMBER, False, "ENGINX")
        self.assertEqual(calibrate_alg.call_count, 1)

    @patch(class_path + '.update_calibration_params_table')
    @patch(class_path + '.create_output_files')
    @patch(class_path + '.load_ceria')
    @patch(class_path + '.calculate_vanadium_correction')
    @patch(class_path + '._plot_vanadium_curves')
    @patch(class_path + '._plot_difc_zero')
    @patch(class_path + '.run_calibration')
    def test_plotting_check(self, calib, plot_difc_zero, plot_van, van, ceria, output_files,
                            update_table):
        self.model.create_new_calibration(VANADIUM_NUMBER, CERIUM_NUMBER, False, "ENGINX")
        plot_van.assert_not_called()
        plot_difc_zero.assert_not_called()
        self.model.create_new_calibration(VANADIUM_NUMBER, CERIUM_NUMBER, True, "ENGINX")
        plot_van.assert_called_once()
        self.assertEqual(plot_difc_zero.call_count, 2)

    @patch(class_path + '.update_calibration_params_table')
    @patch(class_path + '.create_output_files')
    @patch(class_path + '.load_ceria')
    @patch(class_path + '.calculate_vanadium_correction')
    @patch(class_path + '._plot_vanadium_curves')
    @patch(class_path + '._plot_difc_zero')
    @patch(class_path + '.run_calibration')
    def test_present_RB_number_results_in_user_output_files(self, calib, plot_difc_zero, plot_van,
                                                            van, ceria, output_files, update_table):
        self.model.create_new_calibration(VANADIUM_NUMBER,
                                          CERIUM_NUMBER,
                                          False,
                                          "ENGINX",
                                          rb_num="00110")
        self.assertEqual(output_files.call_count, 2)

    @patch(class_path + '.update_calibration_params_table')
    @patch(class_path + '.create_output_files')
    @patch(class_path + '.load_ceria')
    @patch(class_path + '.calculate_vanadium_correction')
    @patch(class_path + '._plot_vanadium_curves')
    @patch(class_path + '._plot_difc_zero')
    @patch(class_path + '.run_calibration')
    def test_absent_run_number_results_in_no_user_output_files(self, calib, plot_difc_zero,
                                                               plot_van, van, ceria, output_files,
                                                               update_table):
        self.model.create_new_calibration(VANADIUM_NUMBER, CERIUM_NUMBER, False, "ENGINX")
        self.assertEqual(output_files.call_count, 1)

    @patch(class_path + '.update_calibration_params_table')
    @patch(class_path + '.create_output_files')
    @patch(class_path + '.load_ceria')
    @patch(class_path + '.calculate_vanadium_correction')
    @patch(class_path + '.run_calibration')
    def test_calibration_params_table_is_updated(self, calibrate_alg, vanadium_alg, load_ceria,
                                                 output_files, update_table):
        self.model.create_new_calibration(VANADIUM_NUMBER, CERIUM_NUMBER, False, "ENGINX")
        self.assertEqual(calibrate_alg.call_count, 1)

    @patch(class_path + '._generate_output_file_name')
    @patch('Engineering.gui.engineering_diffraction.tabs.calibration.model.makedirs')
    @patch(
        'Engineering.gui.engineering_diffraction.tabs.calibration.model.write_ENGINX_GSAS_iparam_file'
    )
    def test_create_output_files(self, write_file, make_dirs, output_name):
        ceria_run = "20"
        vanadium_run = "10"
        filename = "output"
        output_name.return_value = filename, vanadium_run, ceria_run

        self.model.create_output_files("test/", [0, 0], [1, 1], "test2/test3", "test4/test5",
                                       "ENGINX")

        self.assertEqual(make_dirs.call_count, 1)
        self.assertEqual(write_file.call_count, 3)
        write_file.assert_called_with("test/" + filename, [0], [1],
                                      bank_names=['South'],
                                      ceria_run=ceria_run,
                                      template_file="template_ENGINX_241391_236516_South_bank.prm",
                                      vanadium_run=vanadium_run)

    def test_generate_table_workspace_name(self):
        self.assertEqual(self.model._generate_table_workspace_name(20),
                         "engggui_calibration_bank_21")

    def test_generate_output_file_name_for_valid_bank(self):
        filename, vanadium, ceria = self.model._generate_output_file_name(
            "test/20.raw", "test/10.raw", "ENGINX", "north")
        self.assertEqual(filename, "ENGINX_20_10_bank_North.prm")
        self.assertEqual(vanadium, '20')
        self.assertEqual(ceria, '10')

        filename, vanadium, ceria = self.model._generate_output_file_name(
            "test/20.raw", "test/10.raw", "ENGINX", "south")
        self.assertEqual(filename, "ENGINX_20_10_bank_South.prm")
        self.assertEqual(vanadium, '20')
        self.assertEqual(ceria, '10')

        filename, vanadium, ceria = self.model._generate_output_file_name(
            "test/20.raw", "test/10.raw", "ENGINX", "all")
        self.assertEqual(filename, "ENGINX_20_10_all_banks.prm")
        self.assertEqual(vanadium, '20')
        self.assertEqual(ceria, '10')

    def test_generate_output_file_name_for_invalid_bank(self):
        self.assertRaises(ValueError, self.model._generate_output_file_name, "test/20.raw",
                          "test/10.raw", "ENGINX", "INVALID")

    def test_generate_output_file_name_for_unconventional_filename(self):
        filename, vanadium, ceria = self.model._generate_output_file_name(
            "test/20", "test/10.raw", "ENGINX", "north")
        self.assertEqual(filename, "ENGINX_20_10_bank_North.prm")
        self.assertEqual(vanadium, '20')
        self.assertEqual(ceria, '10')

        filename, vanadium, ceria = self.model._generate_output_file_name(
            "20", "test/10.raw", "ENGINX", "north")
        self.assertEqual(filename, "ENGINX_20_10_bank_North.prm")
        self.assertEqual(vanadium, '20')
        self.assertEqual(ceria, '10')

    @patch("Engineering.gui.engineering_diffraction.tabs.calibration.model.Ads")
    def test_update_calibration_params_table_retrieves_workspace(self, ads):
        table = [[0, 18414.900000000001, 0.0, -11.82], [1, 18497.75, 0.0, -26.5]]

        self.model.update_calibration_params_table(table)

        self.assertEqual(ads.retrieve.call_count, 1)

    @patch("Engineering.gui.engineering_diffraction.tabs.calibration.model.Ads")
    def test_update_calibration_params_table_stops_when_table_empty(self, ads):
        table = []

        self.model.update_calibration_params_table(table)

        self.assertEqual(ads.retrieve.call_count, 0)