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)
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)