def set_retrieved_information(self, run_tup_list):
"""
Assumption: sort by time and date should have the exactly same result
:param run_tup_list: sorted run tuple list
:return:
"""
assert (isinstance(run_tup_list, list)) and len(run_tup_list) > 0
if len(run_tup_list) == 1:
GuiUtility.pop_dialog_information(self, 'Only 1 run is given!')
# set up run information
first_run = run_tup_list[0][0]
last_run = run_tup_list[-1][0]
self.ui.lineEdit_begin.setText(str(first_run))
self.ui.lineEdit_end.setText(str(last_run))
# Sort by date
first_run_time = run_tup_list[0][1]
last_run_time = run_tup_list[-1][1]
date_begin = GuiUtility.convert_to_qdate(first_run_time)
self.ui.dateEdit_begin.setDate(date_begin)
date_end = GuiUtility.convert_to_qdate(last_run_time)
self.ui.dateEdit_end.setDate(date_end)
self.ui.label_loadingStatus.setText('IPTS directory %s: Run %d - %d.'
'' % (self._iptsDir, first_run, last_run))
return
def do_set_target(self):
"""
set the target workspace/index to the slicers in case some of them will be merged
:return:
"""
# check whether any rows are selected
row_list = self.ui.tableWidget_segments.get_selected_rows(True)
if len(row_list) == 0:
GuiUtility.pop_dialog_information(
self, 'No row is selected to set target.')
return
# get the name of the target
# pop a dialog for the name of the slicer
target, status = QInputDialog.getText(
self, 'Input Target', 'Enter chopping target for selected rows:')
# return if rejected with
if status is False:
return
else:
target = str(target)
self.ui.tableWidget_segments.rename_chop_target(row_list, target)
return
def save_processing_result(self):
"""
Get saved file directory
:return:
"""
try:
message = self._myController.project.vanadium_processing_manager.save_vanadium_to_file(
)
GuiUtility.pop_dialog_information(self._parent, message)
except RuntimeError as run_err:
GuiUtility.pop_dialog_error(self._parent, '{}'.format(run_err))
return
def save_vanadium_process_parameters(self):
""" Save vanadium process parameters
:return:
"""
# TODO - TONIGHT 2 - Shall be moved to pyvdrive.core
setting_dir = '/SNS/VULCAN/shared/Calibrationfiles/Instrument/Standard/Vanadium'
if not os.path.exists(setting_dir) or not os.access(
setting_dir, os.W_OK):
GuiUtility.pop_dialog_information(
self._parent,
'User cannot write file to {}'.format(setting_dir))
setting_dir = os.path.expanduser('~')
setting_name = os.path.join(setting_dir, 'vanadium_setting.txt')
set_buffer = ''
for bank_id in range(1, 4):
try:
set_buffer += '[BANK {}]\n'.format(bank_id)
set_buffer += 'FWHM = {}\n'.format(
self._peak_fwhm_dict[bank_id])
set_buffer += 'Smooth n = {}\n'.format(
self._smooth_n_dict[bank_id])
set_buffer += 'Smooth order = {}\n'.format(
self._smooth_order_dict[bank_id])
except KeyError as key_err:
GuiUtility.pop_dialog_error(
self._parent, 'Bank {} has not been processed: {}'.format(
bank_id, key_err))
return
setting_file = open(setting_name, 'w')
setting_file.write(set_buffer)
setting_file.close()
GuiUtility.pop_dialog_information(
self._parent,
'Vanadium process setting is saved to {}'.format(setting_name))
return
def init_session(self, data_key):
"""
Init a vanadium processing session including
(1) laod meta data
:param data_key:
:return:
"""
print('[DB...BAT] Init vanadium session with data key (workspace) {}'.
format(data_key))
# generate a temporary gsas file name
gsas_dir = '/SNS/VULCAN/shared/Calibrationfiles/Instrument/Standard/Vanadium'
if not os.path.exists(gsas_dir) or not os.access(gsas_dir, os.W_OK):
GuiUtility.pop_dialog_information(
self._parent,
'User cannot write GSAS file to {}'.format(gsas_dir))
gsas_dir = os.path.expanduser('~')
temp_out_gda_name = os.path.join(gsas_dir,
'{}-s.gda'.format(self._run_number))
# load sample log workspace
# TODO - TODAY 9 - Load meta data can take up to 3 seconds. Make it on a separate thread
log_ws_name = self._myController.load_meta_data(
self._ipts_number, self._run_number, None)
# call
processor = self._myController.project.vanadium_processing_manager
try:
processor.init_session(workspace_name=data_key,
ipts_number=self._ipts_number,
van_run_number=self._run_number,
out_gsas_name=temp_out_gda_name,
sample_log_ws_name=log_ws_name)
except RuntimeError as run_err:
GuiUtility.pop_dialog_error(
self._parent,
'Unable to initialize a vanadium processing sesson due to {}'
''.format(run_err))
return
def do_add_line(self):
""" Add a line
:return:
"""
# get value
ipts_number = GuiUtility.parse_integer(self.ui.lineEdit_iptsNumber,
True)
run_number = GuiUtility.parse_integer(self.ui.lineEdit_runNumber, True)
chop_seq_index = GuiUtility.parse_integer(
self.ui.lineEdit_chopSeqIndex, True)
bank_id = GuiUtility.parse_integer(self.ui.lineEdit_bankNumber, True)
# check
if run_number is None or run_number < 1:
GuiUtility.pop_dialog_error(
self, 'Run number must be specified as a positive integer')
return
if bank_id is None or bank_id < 1:
GuiUtility.pop_dialog_error(
self, 'Bank ID must be specified as a positive integer')
return
# check
if chop_seq_index is None:
plot_key = run_number, bank_id
else:
plot_key = run_number, chop_seq_index, bank_id
# if exists, then give a notice
if plot_key in self._plot_id_dict:
GuiUtility.pop_dialog_information(
self, 'Run {} Chop-seq {} has been plotted'
''.format(run_number, chop_seq_index))
return
# get data
if not self._parent.has_data_loaded(run_number, chop_seq_index):
# load data explicitly
# check IPTS information
if ipts_number is None and run_number in self._run_ipts_map:
# loaded run but different chop sequence
ipts_number = self._run_ipts_map[run_number]
self.ui.lineEdit_iptsNumber.setText('{}'.format(ipts_number))
elif ipts_number is None:
# information not adequet
GuiUtility.pop_dialog_error(
self, 'Run {} has not been loaded; Specify IPTS'
''.format(run_number))
return
# END-IF-ELSE
# load data via parent window
try:
# need to convert chop-sequence-index to list
if chop_seq_index is not None:
chop_seq_index_list = [chop_seq_index]
else:
chop_seq_index_list = None
# load data
self._parent.load_reduced_data(ipts_number, run_number,
chop_seq_index_list)
self._run_ipts_map[run_number] = ipts_number
vdrive_constants.run_ipts_dict[run_number] = ipts_number
except RuntimeError as run_err:
if chop_seq_index is None:
chop_note = 'original GSAS'
else:
chop_note = 'chopped run {}'.format(chop_seq_index)
GuiUtility.pop_dialog_error(
self, 'Unable to load {} of IPTS {} Run {}: {}'
''.format(chop_note, ipts_number, run_number, run_err))
return
# END-TRY-Catch
elif ipts_number is None:
# set the IPTS even the data has been loaded
ipts_number = vdrive_constants.run_ipts_dict[run_number]
# END-IF-ELSE
try:
data_key = self._parent.get_data_key(run_number, chop_seq_index)
vec_x, vec_y = self._parent.retrieve_loaded_reduced_data(
data_key,
ipts_number,
run_number,
chop_seq_index,
bank_id,
unit='dSpacing',
pc_norm=self._norm_proton_charge,
van_run=self._van_number)
except (RuntimeError, KeyError) as run_err:
GuiUtility.pop_dialog_error(
self, 'Unable to retrieve data from Run {} Bank {} due to {}'
''.format(run_number, bank_id, run_err))
return
# plot
plot_information = PlotInformation(ipts_number, run_number,
chop_seq_index,
self._norm_proton_charge,
self._van_number)
self.plot_data(vec_x,
vec_y,
'data key',
unit=None,
bank_id=bank_id,
plot_info=plot_information)
return
def do_expand_slicers(self):
"""
expand the selected slicers as the second-level choppers
:return:
"""
# get the selected slicers
selected_rows = self.ui.tableWidget_segments.get_selected_rows(True)
if len(selected_rows) == 0:
GuiUtility.pop_dialog_information(
self, 'No splitter (row) in the table is selected to expand.')
return
# get the slicers
slicer_list = list()
for row_index in sorted(selected_rows):
slicer = self.ui.tableWidget_segments.get_splitter(row_index)
slicer_list.append((row_index, slicer))
# END-FOR
# sort the slicers in reverse order in order to replace in the table
slicer_list.sort(reverse=True)
# get the slicing setup
if self.ui.radioButton_timeStep.isChecked():
# split by constant time step
try:
time_step = float(str(self.ui.lineEdit_timeStep.text()))
log_step = None
except ValueError:
GuiUtility.pop_dialog_error(
self, 'Time step {0} cannot be converted to float.'
''.format(self.ui.lineEdit_timeStep.text()))
return
elif self.ui.radioButton_logValueStep.isChecked():
# split by constant log step
try:
time_step = None
log_step = float(
str(self.ui.lineEdit_logValueStepLevel2.text()))
except ValueError:
GuiUtility.pop_dialog_error(
self, 'Log step {0} cannot be converted to float.'
''.format(self.ui.lineEdit_logValueStepLevel2.text()))
return
else:
raise NotImplementedError(
'One of split by time step or split by log value step must be chosen.'
)
# TODO/ISSUE/FUTURE
if log_step is not None:
raise NotImplementedError(
'It has not been implemented yet to split further by log value.'
)
# expand
for row_index, splitter in slicer_list:
# get the splitter
if time_step is not None:
# split by log step
new_splitter_list = self.generate_time_splitters(
splitter, time_step)
else:
# log_step is not None:
raise RuntimeError('Where does the workspace come from????')
# new_splitter_list = self._myParent.get_controller().generate_log_splitters(workspace_name,
# splitter, log_step)
# END-IF-ELSE
# replace the selected splitter by the new splitters
self.ui.tableWidget_segments.replace_splitter(
row_index, new_splitter_list)
# END-FOR
return
