def test_get_setting_with_string(self):
settings = QSettings()
settings.beginGroup(GROUP)
settings.setValue(PREFIX + "something", "value")
settings.endGroup()
self.assertEqual(get_setting(GROUP, PREFIX, "something"), "value")
def test_get_setting_with_int(self):
settings = QSettings()
settings.beginGroup(GROUP)
settings.setValue(PREFIX + "something", 10)
settings.endGroup()
self.assertEqual(get_setting(GROUP, PREFIX, "something", return_type=int), 10)
def fetch_correction_workspaces(vanadium_path, instrument, rb_num=""):
"""
Fetch workspaces from the file system or create new ones.
:param vanadium_path: The path to the requested vanadium run raw data.
:param instrument: The instrument the data came from.
:param rb_num: A user identifier, usually an experiment number.
:return: The resultant integration and curves workspaces.
"""
vanadium_number = path_handling.get_run_number_from_path(vanadium_path, instrument)
integ_path, curves_path = _generate_saved_workspace_file_paths(vanadium_number)
force_recalc = get_setting(path_handling.INTERFACES_SETTINGS_GROUP,
path_handling.ENGINEERING_PREFIX, "recalc_vanadium", return_type=bool)
if path.exists(curves_path) and path.exists(integ_path) and not force_recalc: # Check if the cached files exist.
try:
integ_workspace = Load(Filename=integ_path, OutputWorkspace=INTEGRATED_WORKSPACE_NAME)
curves_workspace = Load(Filename=curves_path, OutputWorkspace=CURVES_WORKSPACE_NAME)
if rb_num:
user_integ, user_curves = _generate_saved_workspace_file_paths(vanadium_number,
rb_num=rb_num)
if not path.exists(user_integ) and not path.exists(user_curves):
_save_correction_files(integ_workspace, user_integ, curves_workspace,
user_curves)
return integ_workspace, curves_workspace
except RuntimeError as e:
logger.error(
"Problem loading existing vanadium calculations. Creating new files. Description: "
+ str(e))
integ_workspace, curves_workspace = _calculate_vanadium_correction(vanadium_path)
_save_correction_files(integ_workspace, integ_path, curves_workspace, curves_path)
if rb_num:
user_integ, user_curves = _generate_saved_workspace_file_paths(vanadium_number,
rb_num=rb_num)
_save_correction_files(integ_workspace, user_integ, curves_workspace, user_curves)
return integ_workspace, curves_workspace
def test_get_setting_bool_without_specifying_type(self):
settings = QSettings()
settings.beginGroup(GROUP)
settings.setValue(PREFIX + "something", True)
settings.endGroup()
self.assertEqual(get_setting(GROUP, PREFIX, "something"), "true")
def test_get_setting_with_bool_true(self):
settings = QSettings()
settings.beginGroup(GROUP)
settings.setValue(PREFIX + "something", True)
settings.endGroup()
self.assertEqual(get_setting(GROUP, PREFIX, "something", return_type=bool), True)
def get_ws_sorted_by_primary_log(self):
ws_list = self.get_ws_list()
tof_ws_inds = [ind for ind, ws in enumerate(ws_list) if
self._loaded_workspaces[ws].getAxis(0).getUnit().caption() == 'Time-of-flight']
primary_log = get_setting(output_settings.INTERFACES_SETTINGS_GROUP, output_settings.ENGINEERING_PREFIX,
"primary_log")
sort_ascending = get_setting(output_settings.INTERFACES_SETTINGS_GROUP, output_settings.ENGINEERING_PREFIX,
"sort_ascending")
if primary_log:
log_table = ADS.retrieve(primary_log)
isort = argsort(array(log_table.column('avg')))
ws_list_tof = [ws_list[iws] for iws in isort if iws in tof_ws_inds]
else:
ws_list_tof = ws_list
if sort_ascending == 'false':
# settings can only be saved as text
ws_list_tof = ws_list_tof[::-1]
return ws_list_tof
def __init__(self, canvas, toolbar_manager, parent=None):
super(EngDiffFitPropertyBrowser,
self).__init__(canvas, toolbar_manager, parent)
# overwrite default peak with that in settings (gets init when UI opened)
default_peak = get_setting(output_settings.INTERFACES_SETTINGS_GROUP,
output_settings.ENGINEERING_PREFIX,
"default_peak")
self.setDefaultPeakType(default_peak)
self.fit_notifier = GenericObservable()
self.fit_enabled_notifier = GenericObservable()
def create_log_workspace_group(self):
# run information table
run_info = self.make_runinfo_table()
self._log_workspaces = GroupWorkspaces([run_info], OutputWorkspace='logs')
# a table per logs
logs = get_setting(output_settings.INTERFACES_SETTINGS_GROUP, output_settings.ENGINEERING_PREFIX, "logs")
if logs:
self._log_names = logs.split(',')
for log in self._log_names:
self.make_log_table(log)
self._log_workspaces.add(log)
def create_log_table(self):
# run information table
run_info = CreateEmptyTableWorkspace()
run_info.addColumn(type="str", name="Instrument")
run_info.addColumn(type="int", name="Run")
run_info.addColumn(type="int", name="Bank")
run_info.addColumn(type="float", name="uAmps")
run_info.addColumn(type="str", name="Title")
self._log_workspaces = GroupWorkspaces([run_info], OutputWorkspace='logs')
# a table per logs
logs = get_setting(path_handling.INTERFACES_SETTINGS_GROUP, path_handling.ENGINEERING_PREFIX, "logs")
if logs:
for log in logs.split(','):
ws = CreateEmptyTableWorkspace(OutputWorkspace=log)
ws.addColumn(type="float", name="avg")
ws.addColumn(type="float", name="stdev")
self._log_workspaces.add(log)
def create_vanadium_corrections(vanadium_path: str,
instrument: str): # -> Workspace, Workspace
"""
Runs the vanadium correction algorithm.
:param vanadium_path: The path to the vanadium data.
:return: The integrated workspace and the processed instrument workspace generated.
"""
try:
run_no = path_handling.get_run_number_from_path(
vanadium_path, instrument)
van_ws = Load(Filename=vanadium_path,
OutputWorkspace=str(run_no) + '_' +
VANADIUM_INPUT_WORKSPACE_NAME)
except Exception as e:
logger.error(
"Error when loading vanadium sample data. "
"Could not run Load algorithm with vanadium run number: " +
str(vanadium_path) + ". Error description: " + str(e))
raise RuntimeError
# get full instrument calibration for instrument processing calculation
if Ads.doesExist("full_inst_calib"):
full_calib_ws = Ads.retrieve("full_inst_calib")
else:
full_calib_path = get_setting(
output_settings.INTERFACES_SETTINGS_GROUP,
output_settings.ENGINEERING_PREFIX, "full_calibration")
try:
full_calib_ws = Load(full_calib_path,
OutputWorkspace="full_inst_calib")
except ValueError:
logger.error(
"Error loading Full instrument calibration - this is set in the interface settings."
)
return
integral_ws = _calculate_vanadium_integral(van_ws, run_no)
processed_ws = _calculate_vanadium_processed_instrument(
van_ws, full_calib_ws, integral_ws, run_no)
return integral_ws, processed_ws
def __init__(self, model, view):
self.model = model
self.view = view
self.worker = None
self.calibration_observer = CalibrationObserver(self)
# Observable Setup
self.focus_run_notifier = GenericObservable()
# Connect view signals to local methods.
self.view.set_on_focus_clicked(self.on_focus_clicked)
self.view.set_enable_controls_connection(
self.set_focus_controls_enabled)
# Variables from other GUI tabs.
self.current_calibration = CalibrationInfo()
self.instrument = "ENGINX"
self.rb_num = None
last_van_path = get_setting(output_settings.INTERFACES_SETTINGS_GROUP,
output_settings.ENGINEERING_PREFIX,
"last_vanadium_run")
if last_van_path:
self.view.set_van_file_text_with_search(last_van_path)
def focus_run(self, sample_paths, banks, plot_output, instrument, rb_num,
spectrum_numbers):
"""
Focus some data using the current calibration.
:param sample_paths: The paths to the data to be focused.
:param banks: The banks that should be focused.
:param plot_output: True if the output should be plotted.
:param instrument: The instrument that the data came from.
:param rb_num: The experiment number, used to create directories. Can be None
:param spectrum_numbers: The specific spectra that should be focused. Used instead of banks.
"""
if not Ads.doesExist(vanadium_corrections.INTEGRATED_WORKSPACE_NAME
) and not Ads.doesExist(
vanadium_corrections.CURVES_WORKSPACE_NAME):
return
integration_workspace = Ads.retrieve(
vanadium_corrections.INTEGRATED_WORKSPACE_NAME)
curves_workspace = Ads.retrieve(
vanadium_corrections.CURVES_WORKSPACE_NAME)
output_workspaces = [] # List of collated workspaces to plot.
full_calib_path = get_setting(path_handling.INTERFACES_SETTINGS_GROUP,
path_handling.ENGINEERING_PREFIX,
"full_calibration")
if full_calib_path is not None and path.exists(full_calib_path):
full_calib_workspace = LoadAscii(full_calib_path,
OutputWorkspace="det_pos",
Separator="Tab")
else:
full_calib_workspace = None
if spectrum_numbers is None:
for sample_path in sample_paths:
sample_workspace = path_handling.load_workspace(sample_path)
run_no = path_handling.get_run_number_from_path(
sample_path, instrument)
workspaces_for_run = []
for name in banks:
output_workspace_name = str(
run_no) + "_" + FOCUSED_OUTPUT_WORKSPACE_NAME + str(
name)
self._run_focus(sample_workspace, output_workspace_name,
integration_workspace, curves_workspace,
name, full_calib_workspace)
workspaces_for_run.append(output_workspace_name)
# Save the output to the file system.
self._save_output(instrument, sample_path, name,
output_workspace_name, rb_num)
output_workspaces.append(workspaces_for_run)
else:
for sample_path in sample_paths:
sample_workspace = path_handling.load_workspace(sample_path)
run_no = path_handling.get_run_number_from_path(
sample_path, instrument)
output_workspace_name = str(
run_no) + "_" + FOCUSED_OUTPUT_WORKSPACE_NAME + "cropped"
self._run_focus(sample_workspace, output_workspace_name,
integration_workspace, curves_workspace, None,
full_calib_workspace, spectrum_numbers)
output_workspaces.append([output_workspace_name])
self._save_output(instrument, sample_path, "cropped",
output_workspace_name, rb_num)
# Plot the output
if plot_output:
for ws_names in output_workspaces:
self._plot_focused_workspaces(ws_names)
def create_new_calibration(self,
ceria_path,
plot_output,
instrument,
rb_num=None,
bank=None,
calfile=None,
spectrum_numbers=None):
"""
Create a new calibration from a ceria run
:param ceria_path: Path to ceria (CeO2) data file
:param plot_output: Whether the output should be plotted.
:param instrument: The instrument the data relates to.
:param rb_num: The RB number for file creation.
:param bank: Optional parameter to crop by bank
:param calfile: Optional parameter to crop using a custom calfile
:param spectrum_numbers: Optional parameter to crop using spectrum numbers.
"""
ceria_workspace = path_handling.load_workspace(ceria_path)
if Ads.doesExist("full_inst_calib"):
full_calib = Ads.retrieve("full_inst_calib")
else:
full_calib_path = get_setting(
output_settings.INTERFACES_SETTINGS_GROUP,
output_settings.ENGINEERING_PREFIX, "full_calibration")
try:
full_calib = Load(full_calib_path,
OutputWorkspace="full_inst_calib")
except ValueError:
logger.error(
"Error loading Full instrument calibration - this is set in the interface settings."
)
return
cal_params, ceria_raw, grp_ws = self.run_calibration(
ceria_workspace, bank, calfile, spectrum_numbers, full_calib)
if plot_output:
plot_dicts = list()
if len(cal_params) == 1:
if calfile:
bank_name = "Custom"
elif spectrum_numbers:
bank_name = "Cropped"
else:
bank_name = bank
plot_dicts.append(
EnggUtils.generate_tof_fit_dictionary(bank_name))
EnggUtils.plot_tof_fit(plot_dicts, [bank_name])
else:
plot_dicts.append(
EnggUtils.generate_tof_fit_dictionary("bank_1"))
plot_dicts.append(
EnggUtils.generate_tof_fit_dictionary("bank_2"))
EnggUtils.plot_tof_fit(plot_dicts, ["bank_1", "bank_2"])
difa = [row['difa'] for row in cal_params]
difc = [row['difc'] for row in cal_params]
tzero = [row['tzero'] for row in cal_params]
bk2bk_params = self.extract_b2b_params(ceria_raw)
DeleteWorkspace(ceria_raw)
params_table = []
for i in range(len(difc)):
params_table.append([i, difc[i], difa[i], tzero[i]])
self.update_calibration_params_table(params_table)
calib_dir = path.join(output_settings.get_output_path(), "Calibration",
"")
if calfile:
EnggUtils.save_grouping_workspace(grp_ws,
calib_dir,
ceria_path,
instrument,
calfile=calfile)
elif spectrum_numbers:
EnggUtils.save_grouping_workspace(grp_ws,
calib_dir,
ceria_path,
instrument,
spec_nos=spectrum_numbers)
self.create_output_files(calib_dir, difa, difc, tzero, bk2bk_params,
ceria_path, instrument, bank,
spectrum_numbers, calfile)
if rb_num:
user_calib_dir = path.join(output_settings.get_output_path(),
"User", rb_num, "Calibration", "")
self.create_output_files(user_calib_dir, difa, difc, tzero,
bk2bk_params, ceria_path, instrument,
bank, spectrum_numbers, calfile)
def get_output_path():
location = get_setting(INTERFACES_SETTINGS_GROUP, ENGINEERING_PREFIX,
"save_location")
return location if location is not None else ""
def create_new_calibration(self,
vanadium_path,
sample_path,
plot_output,
instrument,
rb_num=None,
bank=None,
spectrum_numbers=None):
"""
Create a new calibration from a vanadium run and sample run
:param vanadium_path: Path to vanadium data file.
:param sample_path: Path to sample (CeO2) data file
:param plot_output: Whether the output should be plotted.
:param instrument: The instrument the data relates to.
:param rb_num: The RB number for file creation.
:param bank: Optional parameter to crop by bank
:param spectrum_numbers: Optional parameter to crop using spectrum numbers.
"""
van_integration, van_curves = vanadium_corrections.fetch_correction_workspaces(
vanadium_path, instrument, rb_num=rb_num)
sample_workspace = path_handling.load_workspace(sample_path)
full_calib_path = get_setting(path_handling.INTERFACES_SETTINGS_GROUP,
path_handling.ENGINEERING_PREFIX, "full_calibration")
if full_calib_path is not None and path.exists(full_calib_path):
full_calib = LoadAscii(full_calib_path, OutputWorkspace="det_pos", Separator="Tab")
output = self.run_calibration(sample_workspace,
van_integration,
van_curves,
bank,
spectrum_numbers,
full_calib_ws=full_calib)
else:
output = self.run_calibration(sample_workspace, van_integration, van_curves, bank,
spectrum_numbers)
if plot_output:
self._plot_vanadium_curves()
for i in range(len(output)):
if spectrum_numbers:
bank_name = "cropped"
elif bank is None:
bank_name = str(i + 1)
else:
bank_name = bank
difa = output[i].DIFA
difc = output[i].DIFC
tzero = output[i].TZERO
self._generate_tof_fit_workspace(difa, difc, tzero, bank_name)
if bank is None and spectrum_numbers is None:
self._plot_tof_fit()
elif spectrum_numbers is None:
self._plot_tof_fit_single_bank_or_custom(bank)
else:
self._plot_tof_fit_single_bank_or_custom("cropped")
difa = [i.DIFC for i in output]
difc = [i.DIFC for i in output]
tzero = [i.TZERO for i in output]
params_table = []
for i in range(len(difc)):
params_table.append([i, difc[i], difa[i], tzero[i]])
self.update_calibration_params_table(params_table)
calib_dir = path.join(path_handling.get_output_path(), "Calibration", "")
self.create_output_files(calib_dir, difa, difc, tzero, sample_path, vanadium_path, instrument,
bank, spectrum_numbers)
if rb_num:
user_calib_dir = path.join(path_handling.get_output_path(), "User", rb_num,
"Calibration", "")
self.create_output_files(user_calib_dir, difa, difc, tzero, sample_path, vanadium_path,
instrument, bank, spectrum_numbers)
def get_setting(name, return_type=str):
return get_setting(path_handling.INTERFACES_SETTINGS_GROUP,
path_handling.ENGINEERING_PREFIX,
name,
return_type=return_type)
def focus_run(self, sample_paths: list, vanadium_path: str,
plot_output: bool, instrument: str, rb_num: str,
regions_dict: dict) -> None:
"""
Focus some data using the current calibration.
:param sample_paths: The paths to the data to be focused.
:param vanadium_path: Path to the vanadium file from the current calibration
:param plot_output: True if the output should be plotted.
:param instrument: The instrument that the data came from.
:param rb_num: Number to signify the user who is running this focus
:param regions_dict: dict region name -> grp_ws_name, defining region(s) of interest to focus over
"""
full_calib_path = get_setting(
output_settings.INTERFACES_SETTINGS_GROUP,
output_settings.ENGINEERING_PREFIX, "full_calibration")
if not Ads.doesExist("full_inst_calib"):
try:
full_calib_workspace = Load(full_calib_path,
OutputWorkspace="full_inst_calib")
except RuntimeError:
logger.error(
"Error loading Full instrument calibration - this is set in the interface settings."
)
return
else:
full_calib_workspace = Ads.retrieve("full_inst_calib")
van_integration_ws, van_processed_inst_ws = vanadium_corrections.fetch_correction_workspaces(
vanadium_path, instrument)
# check correct region calibration(s) and grouping workspace(s) exists
inst_ws = path_handling.load_workspace(sample_paths[0])
for region in regions_dict:
calib_exists = self._check_region_calib_ws_exists(region)
grouping_exists = self._check_region_grouping_ws_exists(
regions_dict[region], inst_ws)
if not (calib_exists and grouping_exists):
return
# loop over samples provided, focus each over region(s) specified in regions_dict
output_workspaces = [] # List of collated workspaces to plot.
self._last_focused_files = []
van_run_no = path_handling.get_run_number_from_path(
vanadium_path, instrument)
for sample_path in sample_paths:
sample_workspace = path_handling.load_workspace(sample_path)
run_no = path_handling.get_run_number_from_path(
sample_path, instrument)
# perform prefocus operations on whole instrument workspace
prefocus_success = self._whole_inst_prefocus(
sample_workspace, van_integration_ws, full_calib_workspace)
if not prefocus_success:
continue
sample_plots = [
] # if both banks focused, pass list with both so plotted on same figure
for region, grouping_kwarg in regions_dict.items():
tof_output_name = str(
run_no) + "_" + FOCUSED_OUTPUT_WORKSPACE_NAME + region
dspacing_output_name = tof_output_name + "_dSpacing"
region_calib_ws = self._get_region_calib_ws(region)
curves = self._get_van_curves_for_roi(region,
van_processed_inst_ws,
grouping_kwarg)
# perform focus over chosen region of interest
self._run_focus(sample_workspace, tof_output_name, curves,
grouping_kwarg, region_calib_ws)
sample_plots.append(tof_output_name)
self._save_output(instrument, run_no, van_run_no, region,
tof_output_name, rb_num)
self._save_output(instrument,
run_no,
van_run_no,
region,
dspacing_output_name,
rb_num,
unit="dSpacing")
self._output_sample_logs(instrument, run_no, van_run_no,
sample_workspace, rb_num)
output_workspaces.append(sample_plots)
DeleteWorkspace(sample_workspace)
# remove created grouping workspace if present
if Ads.doesExist("grp_ws"):
DeleteWorkspace("grp_ws")
# Plot the output
if plot_output:
for ws_names in output_workspaces:
self._plot_focused_workspaces(ws_names)
def get_setting(name, return_type=str):
return get_setting(output_settings.INTERFACES_SETTINGS_GROUP,
output_settings.ENGINEERING_PREFIX,
name,
return_type=return_type)
def test_get_setting_with_invalid(self):
self.assertEqual(get_setting(GROUP, PREFIX, "something"), "")
