def display_plots(self, row=0):
o_gui_utility = GuiUtility(parent = self.parent)
is_data = o_gui_utility.is_data_tab_selected()
DisplayPlots(parent = self.parent,
row = row,
is_data = is_data)
def __init__(self, parent=None, mouse_x=0, mouse_y=0):
QMainWindow.__init__(self, parent=parent)
self.setWindowModality(False)
self.ui = UiMainWindowXaxis()
self.ui.setupUi(self)
self.parent = parent
o_gui_utility = GuiUtility(parent=self.parent)
self.yaxis_type = o_gui_utility.get_reduced_yaxis_type()
big_table_data = self.parent.big_table_data
self._lrdata = big_table_data[0, 0]
width = self.width()
height = self.height()
self.setFixedSize(width, height)
pos_main_gui = self.parent.pos()
plot_gui_pos = self.parent.ui.data_stitching_plot.pos()
plot_gui_height = self.parent.ui.data_stitching_plot.frameGeometry(
).height()
self.move(mouse_x + plot_gui_pos.x(),
plot_gui_pos.y() + plot_gui_height + mouse_y - 50)
self.init_widgets()
def __init__(self, parent, data_type='data', plot_type='yi',
is_pan_or_zoom_activated=False,
is_manual_zoom_requested=False,
is_x_axis_manual_zoom_requested=False,
mouse_x=0, mouse_y=0):
self.parent = parent
if plot_type == 'stitching':
if is_manual_zoom_requested:
self.right_click_stitching_plot(is_x_axis_manual_zoom_requested,
mouse_x, mouse_y)
return
o_gui_utility = GuiUtility(parent = self.parent)
row = o_gui_utility.get_current_table_reduction_check_box_checked()
if row == -1:
return
self.row = row
col = o_gui_utility.get_data_norm_tab_selected()
self.data = parent.big_table_data[row, col]
if plot_type in ['ix', 'it']:
return
if plot_type == 'yi':
self.single_yi_plot_click(data_type=data_type)
if plot_type == 'yt':
self.single_yt_plot_click(data_type=data_type)
def __init__(self, parent):
self.parent = parent
self.set_gui_title()
self.set_gui_size()
self.set_statusbar()
self.set_main_table()
self.set_stiching_table()
self.set_reduced_table()
self.set_export_stitching_settings()
self.set_default_path()
self.init_error_label_widgets()
parent.allPlotAxis = AllPlotAxis()
#enabled all widgets
o_update_plot = UpdatePlotWidgetStatus(parent=parent)
o_update_plot.disable_all()
parent.ui.reductionTable.setCurrentCell(0,1)
parent.ui.data_sequence_lineEdit.setFocus()
self.init_autopopulate_widgets()
o_gui = GuiUtility(parent = self.parent)
o_gui.init_widgets_value()
def data_clocking_widgets(self, status = False):
o_gui_utility = GuiUtility(parent = self.parent)
if o_gui_utility.is_row_with_highest_q():
status_clocking = True
else:
status_clocking = False
if status_clocking:
status_visible = True
if status is False:
status_enable = False
else:
status_enable = True
else:
status_visible = True #always visible
status_enable = False
self.parent.ui.dataPrimFromLabel.setVisible(status_visible)
self.parent.ui.dataPrimFromLabel.setEnabled(status_enable)
self.parent.ui.dataPrimFromValue.setVisible(status_visible)
self.parent.ui.dataPrimFromValue.setEnabled(status_enable)
self.parent.ui.dataPrimToLabel.setVisible(status_visible)
self.parent.ui.dataPrimToLabel.setEnabled(status_enable)
self.parent.ui.dataPrimToValue.setVisible(status_visible)
self.parent.ui.dataPrimToValue.setEnabled(status_enable)
def calculate(self):
o_gui_utility = GuiUtility(parent=self.parent)
self.axis_type = o_gui_utility.get_reduced_yaxis_type()
input_q_axis = self.input_q_axis
input_y_axis = self.input_y_axis
input_e_axis = self.input_e_axis
# R vs Q selected
if self.axis_type == 'RvsQ':
self.output_y_axis = input_y_axis
self.output_e_axis = input_e_axis
return
# RQ4 vs Q selected
if self.axis_type == 'RQ4vsQ':
_q_axis_4 = input_q_axis ** 4
self.output_y_axis = input_y_axis * _q_axis_4
self.output_e_axis = input_e_axis * _q_axis_4
return
# Log(R) vs Q
# make sure there is no <= 0 values of _y_axis
input_y_axis[input_y_axis <=0] = np.nan
self.output_y_axis = np.log(input_y_axis)
self.output_e_axis = input_e_axis ## FIXME
def write_n_ascii(self):
o_gui_utility = GuiUtility(parent=self.parent)
nbr_row = o_gui_utility.reductionTable_nbr_row()
self.is_with_4th_column_flag = self.ui.output4thColumnFlag.isChecked()
dq_over_q = self.ui.dQoverQvalue.text()
self.dq_over_q = float(dq_over_q)
for _row in range(nbr_row):
self.filename = self.format_n_filename(row=_row)
text = self.retrieve_individual_metadata(row=_row)
if self.is_with_4th_column_flag:
dq0 = self.ui.dq0Value.text()
self.dq0 = float(dq0)
line1 = '# dQ0[1/Angstroms]= ' + dq0
line2 = '# dQ1/Q= ' + dq_over_q
line3 = '# Q[1/Angstroms] R delta_R Precision'
text.append(line1)
text.append(line2)
text.append("#")
text.append(line3)
else:
text.append('# Q[1/Angstroms] R delta_R')
self.text_data = text
self.produce_data_without_common_q_axis(row=_row)
self.format_data()
self.create_file()
def radio_button_handler(self):
if self.row == -1:
return
o_gui_utility = GuiUtility(parent = self.parent)
is_auto_tof_selected = o_gui_utility.is_auto_tof_range_radio_button_selected()
big_table_data = self.parent.big_table_data
for _row in self.all_rows:
_data = big_table_data[_row, 0]
# _data = big_table_data[_row, self.col]
if _data is None:
return
if is_auto_tof_selected:
self.new_tof_range = _data.tof_range_auto
_data.tof_range_auto_flag = True
#self.save_manual_tof_range()
else:
self.new_tof_range = _data.tof_range_manual
_data.tof_range_auto_flag = False
#self.save_auto_tof_range()
_data.tof_auto_flag = is_auto_tof_selected
# big_table_data[_row, self.col] = _data
big_table_data[_row, 0] = _data
self.parent.big_table_data = big_table_data
self.replace_tof_range_displayed()
if _row == self.row:
self.refresh_plot()
self.recalculate_reduction_table_metadata()
def create_output_file(self):
o_gui_utility = GuiUtility(parent=self.parent)
nbr_row = o_gui_utility.reductionTable_nbr_row()
_dataObject = self.parent.o_stitching_ascii_widget.loaded_ascii_array[
0]
_big_table_data = _dataObject.big_table_data
#q min, q max
[_q_min, _q_max] = self.get_q_range()
#q bin
_q_bin = -1. * float(self.parent.ui.qStep.text())
_q_range = [_q_min, _q_bin, _q_max]
# collect list of workspaces
_list_wks = self.collect_list_wks()
_list_wks = self.apply_sf(_list_wks)
_text_data = self.format_metadata()
print("Creating output file")
print("====================")
print("OutputBinning: %r" % _q_range)
print("DQConstant: %r" % (float(self.ui.dq0Value.text())))
print("DQSlope: %r" % (float(self.ui.dQoverQvalue.text())))
LRReflectivityOutput(ReducedWorkspaces=_list_wks,
OutputBinning=_q_range,
DQConstant=float(self.ui.dq0Value.text()),
DQSlope=float(self.ui.dQoverQvalue.text()),
OutputFilename=self.filename,
ScaleToUnity=False,
Metadata=_text_data)
def __init__(self, parent, data_type = 'data', plot_type = 'yi', is_pan_or_zoom_activated = False): self.parent = parent o_gui_utility = GuiUtility(parent = self.parent) row = o_gui_utility.get_current_table_reduction_check_box_checked() if row == -1: return self.row = row col = o_gui_utility.get_data_norm_tab_selected() self.data = parent.big_table_data[row, col] if plot_type == 'ix': return if plot_type == 'it': return if plot_type == 'stitching': return if plot_type == 'yi': self.single_yi_plot_click(data_type = data_type) if plot_type == 'yt': self.single_yt_plot_click(data_type = data_type)
def get_data_clocking_range(self):
big_table_data = self.big_table_data
o_gui_utility = GuiUtility(parent=self.parent)
_last_row = o_gui_utility.get_row_with_highest_q()
_data = big_table_data[_last_row, 0]
clock1 = int(_data.clocking[0])
clock2 = int(_data.clocking[1])
return [clock1, clock2]
def get_data_clocking_range(self):
big_table_data = self.big_table_data
o_gui_utility = GuiUtility(parent = self.parent)
_last_row = o_gui_utility.get_row_with_highest_q()
_data = big_table_data[_last_row, 0]
clock1 = int(_data.clocking[0])
clock2 = int(_data.clocking[1])
return [clock1, clock2]
def retrieve_lradata(self): o_gui_utility = GuiUtility(parent = self.parent) col_selected = o_gui_utility.get_current_table_reduction_column_selected() row_selected = o_gui_utility.get_current_table_reduction_row_selected() self.col = col_selected self.row = row_selected big_table_data = self.parent.big_table_data self.lrdata = big_table_data[row_selected, col_selected - 1]
def retrieve_lradata(self):
o_gui_utility = GuiUtility(parent=self.parent)
col_selected = o_gui_utility.get_current_table_reduction_column_selected(
)
row_selected = o_gui_utility.get_current_table_reduction_row_selected()
self.col = col_selected
self.row = row_selected
big_table_data = self.parent.big_table_data
self.lrdata = big_table_data[row_selected, col_selected - 1]
def generate_selected_sf(self, lconfig=None):
o_gui = GuiUtility(parent=self.parent)
stitching_type = o_gui.getStitchingType()
if stitching_type is "absolute":
return lconfig.sf_abs_normalization
elif stitching_type is "auto":
return lconfig.sf_auto
else:
return lconfig.sf_manual
def __is_row_displayed_in_range_selected(self):
_range_selected = range(self.from_row, self.to_row + 1)
o_gui_utility = GuiUtility(parent = self.parent)
_row_displayed = o_gui_utility.get_current_table_reduction_check_box_checked()
if _row_displayed == -1:
return False
if _row_displayed in _range_selected:
return True
return False
def retrieve_sf(self, lconfigdataset):
o_gui = GuiUtility(parent=self.parent)
stitching_type = o_gui.getStitchingType()
if stitching_type == 'absolute':
return lconfigdataset.sf_abs_normalization
elif stitching_type == 'auto':
return lconfigdataset.sf_auto
else:
return lconfigdataset.sf_manual
def leave_all_figure_plot(self, plot_type, row=-1, column=-1):
parent = self.parent
if column == -1 and row == -1:
o_gui_utility = GuiUtility(parent=self.parent)
row = o_gui_utility.get_current_table_reduction_check_box_checked()
column = 0 if o_gui_utility.is_data_tab_selected() else 1
if row == -1:
return
big_table_data = parent.big_table_data
data = big_table_data[row, column]
if data is None:
return
if plot_type == 'yi':
if c == 0:
plot_ui = parent.ui.data_yi_plot
else:
plot_ui = parent.ui.norm_yi_plot
elif plot_type == 'yt':
if c == 0:
plot_ui = parent.ui.data_yt_plot
else:
plot_ui = parent.ui.norm_yt_plot
elif plot_type == 'it':
if c == 0:
plot_ui = parent.ui.data_it_plot
else:
plot_ui = parent.ui.norm_it_plot
elif plot_type == 'ix':
if c == 0:
plot_ui = parent.ui.data_ix_plot
else:
plot_ui = parent.ui.norm_ix_plot
[xmin, xmax] = plot_ui.canvas.ax.xaxis.get_view_interval()
[ymin, ymax] = plot_ui.canvas.ax.yaxis.get_view_interval()
plot_ui.canvas.ax.xaxis.set_data_interval(xmin, xmax)
plot_ui.canvas.ax.yaxis.set_data_interval(ymin, ymax)
plot_ui.draw()
if plot_type == 'yi':
data.all_plot_axis.yi_view_interval = [xmin, xmax, ymin, ymax]
parent.global_yi_view_interval = [xmin, xmax, ymin, ymax]
elif plot_type == 'yt':
data.all_plot_axis.yt_view_interval = [xmin, xmax, ymin, ymax]
parent.global_yt_view_interval = [xmin, xmax, ymin, ymax]
elif plot_type == 'it':
data.all_plot_axis.it_view_interval = [xmin, xmax, ymin, ymax]
parent.global_it_view_interval = [xmin, xmax, ymin, ymax]
elif plot_type == 'ix':
data.all_plot_axis.ix_view_interval = [xmin, xmax, ymin, ymax]
parent.global_ix_view_interval = [xmin, xmax, ymin, ymax]
def leave_all_figure_plot(self, plot_type, row=-1, column=-1): parent = self.parent if column == -1 and row == -1: o_gui_utility = GuiUtility(parent = self.parent) row = o_gui_utility.get_current_table_reduction_check_box_checked() column = 0 if o_gui_utility.is_data_tab_selected() else 1 if row == -1: return big_table_data = parent.big_table_data data = big_table_data[row, column] if data is None: return if plot_type == 'yi': if c==0: plot_ui = parent.ui.data_yi_plot else: plot_ui = parent.ui.norm_yi_plot elif plot_type == 'yt': if c==0: plot_ui = parent.ui.data_yt_plot else: plot_ui = parent.ui.norm_yt_plot elif plot_type =='it': if c==0: plot_ui = parent.ui.data_it_plot else: plot_ui = parent.ui.norm_it_plot elif plot_type =='ix': if c==0: plot_ui = parent.ui.data_ix_plot else: plot_ui = parent.ui.norm_ix_plot [xmin, xmax] = plot_ui.canvas.ax.xaxis.get_view_interval() [ymin, ymax] = plot_ui.canvas.ax.yaxis.get_view_interval() plot_ui.canvas.ax.xaxis.set_data_interval(xmin, xmax) plot_ui.canvas.ax.yaxis.set_data_interval(ymin,ymax) plot_ui.draw() if plot_type == 'yi': data.all_plot_axis.yi_view_interval = [xmin,xmax,ymin,ymax] parent.global_yi_view_interval = [xmin,xmax,ymin,ymax] elif plot_type == 'yt': data.all_plot_axis.yt_view_interval = [xmin,xmax,ymin,ymax] parent.global_yt_view_interval = [xmin,xmax,ymin,ymax] elif plot_type =='it': data.all_plot_axis.it_view_interval = [xmin,xmax,ymin,ymax] parent.global_it_view_interval = [xmin,xmax,ymin,ymax] elif plot_type =='ix': data.all_plot_axis.ix_view_interval = [xmin,xmax,ymin,ymax] parent.global_ix_view_interval = [xmin,xmax,ymin,ymax]
def collect_list_wks(self):
o_gui_utility = GuiUtility(parent=self.parent)
nbr_row = o_gui_utility.reductionTable_nbr_row()
_dataObject = self.parent.o_stitching_ascii_widget.loaded_ascii_array[
0]
_big_table_data = _dataObject.big_table_data
_list_wks = []
for _row in range(nbr_row):
_data = _big_table_data[_row, 2]
_list_wks.append(_data.wks)
return _list_wks
def run(self):
'''
main part of the program that will calculate the various SF
'''
o_gui = GuiUtility(parent=self.parent)
stitching_type = o_gui.getStitchingType()
if stitching_type is 'absolute':
self.absolute_normalization_calculation(row_index=self.row_index)
elif stitching_type is 'auto':
self.auto_stitching_calculation(row_index=self.row_index)
else:
self.manual_stitching_calculation(row_index=self.row_index)
def __init__(self,
parent=None,
status='log',
plot_type=None,
is_y_log=True):
status = str(status)
if status == 'log':
isLog = True
else:
isLog = False
if plot_type == 'stitching':
[row, column] = [0, 0]
else:
o_gui_utility = GuiUtility(parent=parent)
row = o_gui_utility.get_current_table_reduction_check_box_checked()
column = 0 if o_gui_utility.is_data_tab_selected() else 1
data = parent.big_table_data[row, column]
if data is None:
return
if plot_type == 'stitching':
if is_y_log:
data.all_plot_axis.is_reduced_plot_stitching_tab_ylog = isLog
else:
data.all_plot_axis.is_reduced_plot_stitching_tab_xlog = isLog
elif plot_type == 'yi':
if is_y_log:
data.all_plot_axis.is_yi_ylog = isLog
else:
data.all_plot_axis.is_yi_xlog = isLog
elif plot_type == 'yt':
if is_y_log:
data.all_plot_axis.is_yt_ylog = isLog
else:
data.all_plot_axis.is_yt_xlog = isLog
elif plot_type == 'it':
if is_y_log:
data.all_plot_axis.is_it_ylog = isLog
else:
data.all_plot_axis.is_it_xlog = isLog
elif plot_type == 'ix':
if is_y_log:
data.all_plot_axis.is_ix_ylog = isLog
else:
data.all_plot_axis.is_ix_xlog = isLog
parent.big_table_data[row, column] = data
def globalize_clocking_parameters(self): ''' the clocking settings of all the data should only use the ones calculated for the last data file loaded ''' o_gui_utility = GuiUtility(parent = self.parent) last_data_row = o_gui_utility.get_row_with_highest_q() big_table_data = self.parent.big_table_data _lconfig = big_table_data[last_data_row, 2] data_clocking = _lconfig.data_clocking for i in range(last_data_row): _lconfig = big_table_data[i, 2] _lconfig.data_clocking = data_clocking big_table_data[i, 2] = _lconfig self.parent.big_table_data = big_table_data
def apply_scaling_factor(self):
o_gui_utility = GuiUtility(parent=self.parent)
nbr_row = o_gui_utility.reductionTable_nbr_row()
_dataObject = self.parent.o_stitching_ascii_widget.loaded_ascii_array[
0]
_big_table_data = _dataObject.big_table_data
for _row in range(nbr_row):
_data = _big_table_data[_row, 2]
_wks = _data.wks
_sf = self.retrieve_sf(_data)
_wks_scaled = Scale(_wks, _sf, 'Multiply')
_data.wks_scaled = _wks_scaled
_big_table_data[_row, 2]
_dataObject.big_table_data = _big_table_data
def retrieve_metadata(self):
reduction_table = self.parent.ui.reductionTable
text = []
o_gui_utility = GuiUtility(parent = self.parent)
_date = time.strftime("# Date: %d_%m_%Y")
_reduction_method = '# Reduction method: manual'
_reduction_engine = '# Reduction engine: RefRed'
_reduction_date = '# %s' %_date
_ipts = o_gui_utility.get_ipts(row = 0)
for _entry in [_date, _reduction_method, _reduction_engine, _reduction_date]:
text.append(_entry)
text.append("#")
nbr_row = o_gui_utility.reductionTable_nbr_row()
_legend = "# DataRun\tNormRun\t2theta(degrees)\tLambdaMin(A)\tLambdaMax(A)\tQmin(1/A)\tQmax(1/A)\tScalingFactor"
text.append(_legend)
for _row in range(nbr_row):
_data_run = str(reduction_table.item(_row, 1).text())
_norm_run = str(reduction_table.item(_row, 2).text())
_2_theta = str(reduction_table.item(_row, 3).text())
_lambda_min = str(reduction_table.item(_row, 4).text())
_lambda_max = str(reduction_table.item(_row, 5).text())
_q_min = str(reduction_table.item(_row, 6).text())
_q_max = str(reduction_table.item(_row, 7).text())
_scaling_factor = self.retrieve_scaling_factor(row = _row)
_value = "# %s\t%s\t%s\t\t%s\t\t%s\t\t%s\t\t%s\t\t%s" %(_data_run,
_norm_run,
_2_theta,
_lambda_min,
_lambda_max,
_q_min,
_q_max,
_scaling_factor)
text.append(_value)
# clocking settings
text.append('#')
text.append('# Clocking Correction used')
o_gui_utility = GuiUtility(parent = self.parent)
last_row = o_gui_utility.get_row_with_highest_q()
big_table_data = self.parent.big_table_data
clocking = big_table_data[last_row, 0].clocking
text.append('# clock1: %s' %clocking[0])
text.append('# clock2: %s' %clocking[1])
return text
def __init__(self, parent=None, status='log', plot_type=None, is_y_log=True): if status == 'log': isLog = True else: isLog = False if plot_type=='stitching': [row, column] = [0,0] else: o_gui_utility = GuiUtility(parent = parent) row = o_gui_utility.get_current_table_reduction_check_box_checked() column = 0 if o_gui_utility.is_data_tab_selected() else 1 data = parent.big_table_data[row, column] if data is None: return if plot_type=='stitching': if is_y_log: data.all_plot_axis.is_reduced_plot_stitching_tab_ylog = isLog else: data.all_plot_axis.is_reduced_plot_stitching_tab_xlog = isLog elif plot_type=='yi': if is_y_log: data.all_plot_axis.is_yi_ylog = isLog else: data.all_plot_axis.is_yi_xlog = isLog elif plot_type=='yt': if is_y_log: data.all_plot_axis.is_yt_ylog = isLog else: data.all_plot_axis.is_yt_xlog = isLog elif plot_type=='it': if is_y_log: data.all_plot_axis.is_it_ylog = isLog else: data.all_plot_axis.is_it_xlog = isLog elif plot_type=='ix': if is_y_log: data.all_plot_axis.is_ix_ylog = isLog else: data.all_plot_axis.is_ix_xlog = isLog parent.big_table_data[row, column] = data
def prepare_big_table_data(self): ''' all data files used last data clocking values ''' big_table_data = self.parent.big_table_data o_gui_utility = GuiUtility(parent = self.parent) row_highest_q = o_gui_utility.get_row_with_highest_q() _ref_lrdata = big_table_data[row_highest_q, 0] _ref_clocking = _ref_lrdata.clocking for row in range(row_highest_q): _lrdata = big_table_data[row, 0] _lrdata.clocking = _ref_clocking big_table_data[row, 0] = _lrdata self.parent.big_table_data = big_table_data
def prepare_big_table_data(self):
'''
all data files used last data clocking values
'''
big_table_data = self.parent.big_table_data
o_gui_utility = GuiUtility(parent=self.parent)
row_highest_q = o_gui_utility.get_row_with_highest_q()
_ref_lrdata = big_table_data[row_highest_q, 0]
_ref_clocking = _ref_lrdata.clocking
for row in range(row_highest_q):
_lrdata = big_table_data[row, 0]
_lrdata.clocking = _ref_clocking
big_table_data[row, 0] = _lrdata
self.parent.big_table_data = big_table_data
def save_xy_axis(self):
o_gui_utility = GuiUtility(parent = self.parent)
yaxis_type = o_gui_utility.get_reduced_yaxis_type()
big_table_data = self.parent.big_table_data
_data = big_table_data[0, 0]
if yaxis_type == 'RvsQ':
if _data.all_plot_axis.reduced_plot_RQuserView_y is None:
self.parent.ui.data_stitching_plot.canvas.draw()
[xmin, xmax] = self.parent.ui.data_stitching_plot.canvas.ax.xaxis.get_view_interval()
[ymin, ymax] = self.parent.ui.data_stitching_plot.canvas.ax.yaxis.get_view_interval()
_data.all_plot_axis.reduced_plot_RQuserView_y = [ymin, ymax]
_data.all_plot_axis.reduced_plot_RQautoView_y = [ymin, ymax]
_data.all_plot_axis.reduced_plot_RQQ4userView_x = [xmin, xmax]
_data.all_plot_axis.reduced_plot_RQQ4autoView_x = [xmin, xmax]
else:
[xmin, xmax] = _data.all_plot_axis.reduced_plot_RQQ4userView_x
[ymin, ymax] = _data.all_plot_axis.reduced_plot_RQuserView_y
self.parent.ui.data_stitching_plot.canvas.ax.set_xlim([xmin, xmax])
self.parent.ui.data_stitching_plot.canvas.ax.set_ylim([ymin, ymax])
self.parent.ui.data_stitching_plot.canvas.draw()
else:
if _data.all_plot_axis.reduced_plot_RQ4QuserView_y is None:
self.parent.ui.data_stitching_plot.canvas.draw()
[xmin, xmax] = self.parent.ui.data_stitching_plot.canvas.ax.xaxis.get_view_interval()
[ymin, ymax] = self.parent.ui.data_stitching_plot.canvas.ax.yaxis.get_view_interval()
_data.all_plot_axis.reduced_plot_RQ4userView_y = [ymin, ymax]
_data.all_plot_axis.reduced_plot_RQ4autoView_y = [ymin, ymax]
_data.all_plot_axis.reduced_plot_RQQ4userView_x = [xmin, xmax]
_data.all_plot.axis.reduced_plot_RQQ4autoView_x = [xmin, xmax]
else:
[xmin, xmax] = _data.all_plot_axis.reduced_plot_RQQ4userView_x
[ymin, ymax] = _data.all_plot_axis.reduced_plot_RQ4userView_y
self.parent.ui.data_stitching_plot.canvas.ax.set_xlim([xmin, xmax])
self.parent.ui.data_stitching_plot.canvas.ax.set_ylim([ymin, ymax])
self.parent.ui.data_stitching_plot.canvas.draw()
big_table_data[0, 0] = _data
self.parent.big_table_data = big_table_data
def closeEvent(self, event=None):
# saving back all the settings
nbr_row = self.ui.tableWidget.rowCount()
_gui_metadata = {}
for _row in range(nbr_row):
_label = str(self.ui.tableWidget.verticalHeaderItem(_row).text())
if _label == 'clocking_pixel':
_value = str(self.ui.tableWidget.item(_row, 0).text())
[_pixel1, _pixel2] = _value.split(",")
_value = [int(_pixel1), int(_pixel2)]
else:
_value = float(self.ui.tableWidget.item(_row, 0).text())
_gui_metadata[_label] = _value
self.parent.gui_metadata = _gui_metadata
print(self.parent.gui_metadata)
#update GUI widgets
o_gui = GuiUtility(parent=self.parent)
o_gui.init_widgets_value()
def init_widgets(self):
o_gui_utility = GuiUtility(parent=self.parent)
axis_type = o_gui_utility.get_reduced_yaxis_type()
if axis_type == 'RvsQ':
[_x_min, _x_max, _y_min,
_y_max] = self._lrdata.all_plot_axis.get_user_reduced_RQ_view()
else:
[_x_min, _x_max, _y_min,
_y_max] = self._lrdata.all_plot_axis.get_user_reduced_RQ4Q_view()
self.y_min = _y_min
self.y_max = _y_max
_y_min_str = "%.8f" % _y_min
_y_max_str = "%.8f" % _y_max
self.ui.y_min_value.setText(_y_min_str)
self.ui.y_max_value.setText(_y_max_str)
def fillRow(self, row_index=0):
self._row_index = row_index
self._lconfig = self.big_table_data[self._row_index, 2]
if self._lconfig is None:
return
o_gui = GuiUtility(parent=self.parent)
stitching_type = o_gui.getStitchingType()
self.fillTableRunNumber()
if stitching_type is 'absolute':
self.fillTableForAbsoluteNormalization()
elif stitching_type is 'auto':
self.fillTableForAutoStitching()
else:
self.fillTableForManualStitching()
self.fillTableForClocking()
def run(self):
if self.filename == '':
_path = self.parent.path_config
self.filename = str(QtGui.QFileDialog.getSaveFileName(self.parent,
'Save Configuration File',
_path))
if self.filename == '':
return
self.parent.path_config = os.path.dirname(self.filename)
self.filename = makeSureFileHasExtension(self.filename)
o_export = ExportXMLConfig(parent = self.parent,
filename = self.filename)
StatusMessageHandler(parent = self.parent,
message = 'Done!',
is_threaded = True)
o_gui_utility = GuiUtility(parent = self.parent)
o_gui_utility.gui_not_modified()
def run(self):
if self.filename == '':
_path = self.parent.path_config
_filter = ("XML (*.xml);; All Files (*.*)")
self.filename = str(QtGui.QFileDialog.getSaveFileName(self.parent,
'Save Configuration File',
_path,
_filter))
if self.filename == '':
return
self.parent.path_config = os.path.dirname(self.filename)
self.filename = makeSureFileHasExtension(self.filename)
o_export = ExportXMLConfig(parent = self.parent,
filename = self.filename)
StatusMessageHandler(parent = self.parent,
message = 'Done!',
is_threaded = True)
o_gui_utility = GuiUtility(parent = self.parent)
o_gui_utility.new_config_file_loaded(config_file_name = self.filename)
o_gui_utility.gui_not_modified()
def norm_tab_widgets(self, status=False):
parent = self.parent
parent.ui.dataNormTabWidget.setEnabled(status)
parent.ui.norm_yt_plot.setEnabled(status)
parent.ui.normNameOfFile.setEnabled(status)
parent.ui.norm_yi_plot.setEnabled(status)
parent.ui.norm_it_plot.setEnabled(status)
parent.ui.norm_ix_plot.setEnabled(status)
parent.ui.normLowResFlag.setEnabled(status)
parent.ui.normLowResFromLabel.setEnabled(status)
parent.ui.normLowResFromValue.setEnabled(status)
parent.ui.normLowResToLabel.setEnabled(status)
parent.ui.normLowResToValue.setEnabled(status)
parent.ui.normBackToValue.setEnabled(status)
parent.ui.normBackFromValue.setEnabled(status)
parent.ui.normPeakToValue.setEnabled(status)
parent.ui.normPeakFromValue.setEnabled(status)
parent.ui.normBackgroundFlag.setEnabled(status)
self.parent.ui.dataTOFmanualLabel.setEnabled(status)
self.parent.ui.dataTOFautoMode.setEnabled(status)
self.parent.ui.dataTOFmanualMode.setEnabled(status)
o_gui_utility = GuiUtility(parent = self.parent)
if status:
is_auto_tof_selected = o_gui_utility.is_auto_tof_range_radio_button_selected()
o_gui_utility.set_auto_tof_range_widgets(status = is_auto_tof_selected)
else:
o_gui_utility.set_auto_tof_range_widgets(status = True)
def globalize_clocking_parameters(self):
'''
the clocking settings of all the data should only use the
ones calculated for the last data file loaded
'''
o_gui_utility = GuiUtility(parent=self.parent)
last_data_row = o_gui_utility.get_row_with_highest_q()
big_table_data = self.parent.big_table_data
lrdata = big_table_data[last_data_row, 0]
if lrdata is None:
return
clocking = lrdata.clocking
for i in range(last_data_row + 1):
if i == last_data_row:
continue
_lrdata = big_table_data[i, 0]
if _lrdata is None:
break
_lrdata.clocking = clocking
big_table_data[i, 0] = _lrdata
self.parent.big_table_data = big_table_data
def radio_button_handler(self):
if self.row == -1:
return
o_gui_utility = GuiUtility(parent=self.parent)
is_auto_tof_selected = o_gui_utility.is_auto_tof_range_radio_button_selected(
)
big_table_data = self.parent.big_table_data
for _row in self.all_rows:
_data = big_table_data[_row, 0]
_norm = big_table_data[_row, 1]
_lconfig = big_table_data[_row, 2]
if _data is None:
return
if is_auto_tof_selected:
self.new_tof_range = _data.tof_range_auto
_lconfig.tof_auto_flag = True
_data.tof_range_auto_flag = True
if _norm is not None:
_norm.tof_range_auto_flag = True
else:
self.new_tof_range = _data.tof_range_manual
_data.tof_range_auto_flag = False
_lconfig.tof_auto_flag = False
if _norm is not None:
_norm.tof_range_auto_flag = False
_data.tof_auto_flag = is_auto_tof_selected
big_table_data[_row, 1] = _norm
big_table_data[_row, 0] = _data
self.parent.big_table_data = big_table_data
self.replace_tof_range_displayed()
if _row == self.row:
self.refresh_plot()
self.recalculate_reduction_table_metadata(row=_row)
def setup(self):
o_gui_utility = GuiUtility(parent=self.parent)
is_auto_tof_selected = o_gui_utility.is_auto_tof_range_radio_button_selected(
)
o_gui_utility.set_auto_tof_range_widgets(status=is_auto_tof_selected)
self.row = o_gui_utility.get_current_table_reduction_check_box_checked(
)
if self.row == -1:
return
self.all_rows = o_gui_utility.get_other_row_with_same_run_number_as_row(
row=self.row, auto_mode=is_auto_tof_selected)
self.col = o_gui_utility.get_data_norm_tab_selected()
self.is_data = True if self.col == 0 else False
def setup(self):
o_gui_utility = GuiUtility(parent = self.parent)
is_auto_tof_selected = o_gui_utility.is_auto_tof_range_radio_button_selected()
o_gui_utility.set_auto_tof_range_widgets(status = is_auto_tof_selected)
self.row = o_gui_utility.get_current_table_reduction_check_box_checked()
if self.row == -1:
return
self.all_rows = o_gui_utility.get_other_row_with_same_run_number_as_row(row = self.row)
self.col = o_gui_utility.get_data_norm_tab_selected()
self.is_data = True if self.col == 0 else False
def get_q_range(self):
o_gui_utility = GuiUtility(parent=self.parent)
nbr_row = o_gui_utility.reductionTable_nbr_row()
_auto_qmin_flag = self.ui.auto_qmin_button.isChecked()
if _auto_qmin_flag:
minQ = 100
else:
minQ = float(self.ui.manual_qmin_value.text())
maxQ = 0
_dataObject = self.parent.o_stitching_ascii_widget.loaded_ascii_array[
0]
_big_table_data = _dataObject.big_table_data
for i in range(nbr_row):
_data = _big_table_data[i, 2]
_q_axis = _data.reduce_q_axis
if _auto_qmin_flag:
minQ = min([_q_axis[0], minQ])
maxQ = max([_q_axis[-1], maxQ])
return [minQ, maxQ]
def retrieve_metadata(self):
reduction_table = self.parent.ui.reductionTable
text = []
o_gui_utility = GuiUtility(parent=self.parent)
_date = time.strftime("# Date: %d_%m_%Y")
_reduction_method = '# Reduction method: manual'
_reduction_engine = '# Reduction engine: RefRed'
_reduction_date = '# %s' % _date
_ipts = o_gui_utility.get_ipts(row=0)
for _entry in [
_date, _reduction_method, _reduction_engine, _reduction_date
]:
text.append(_entry)
text.append("#")
nbr_row = o_gui_utility.reductionTable_nbr_row()
_legend = "# DataRun\tNormRun\t2theta(degrees)\tLambdaMin(A)\tLambdaMax(A)\tQmin(1/A)\tQmax(1/A)\tScalingFactor\tTotal Counts\tpcCharge(mC)"
text.append(_legend)
for _row in range(nbr_row):
_data_run = str(reduction_table.item(_row, 1).text())
_norm_run = str(reduction_table.item(_row, 2).text())
_2_theta = str(reduction_table.item(_row, 3).text())
_lambda_min = str(reduction_table.item(_row, 4).text())
_lambda_max = str(reduction_table.item(_row, 5).text())
_q_min = str(reduction_table.item(_row, 6).text())
_q_max = str(reduction_table.item(_row, 7).text())
_scaling_factor = self.retrieve_scaling_factor(row=_row)
_total_counts = self.retrieve_total_counts(_row)
_pcCharge = self.retrieve_pcCharge(_row)
_value = "# %s\t%s\t%s\t\t%s\t\t%s\t\t%s\t\t%s\t\t%s\t\t%f\t\t%f" % (
_data_run, _norm_run, _2_theta, _lambda_min, _lambda_max,
_q_min, _q_max, _scaling_factor, _total_counts, _pcCharge)
text.append(_value)
# clocking settings
text.append('#')
text.append('# Clocking Correction used')
o_gui_utility = GuiUtility(parent=self.parent)
last_row = o_gui_utility.get_row_with_highest_q()
big_table_data = self.parent.big_table_data
clocking = big_table_data[last_row, 0].clocking
text.append('# clock1: %s' % clocking[0])
text.append('# clock2: %s' % clocking[1])
return text
def is_row_with_higest_q(self): o_gui_utility = GuiUtility(parent = self.parent) return o_gui_utility.is_row_with_highest_q()
def get_selected_reduced_output(self):
o_gui_utility = GuiUtility(parent = self.parent)
return o_gui_utility.get_reduced_yaxis_type()
def reset_gui_modified_status(self): o_gui_utility = GuiUtility(parent = self.parent) o_gui_utility.gui_not_modified()
def display_name_config_file(self):
o_gui = GuiUtility(parent=self.parent)
o_gui.new_config_file_loaded(config_file_name=self.filename)
def reset_gui_modified_status(self):
o_gui_utility = GuiUtility(parent=self.parent)
o_gui_utility.gui_not_modified()
def display_name_config_file(self): o_gui = GuiUtility(parent = self.parent) o_gui.new_config_file_loaded(config_file_name = self.filename)
def produce_data_with_common_q_axis(self): o_gui_utility = GuiUtility(parent = self.parent) nbr_row = o_gui_utility.reductionTable_nbr_row() _dataObject = self.parent.o_stitching_ascii_widget.loaded_ascii_array[0] _big_table_data = _dataObject.big_table_data minQ = 100 maxQ = 0 for i in range(nbr_row): _data = _big_table_data[i,2] tmp_wks_name = 'wks_' + str(i) _q_axis = _data.reduce_q_axis _y_axis = _data.reduce_y_axis[:-1] _e_axis = _data.reduce_e_axis[:-1] [_y_axis, _e_axis] = self.applySF(_data, _y_axis, _e_axis) minQ = min([_q_axis[0], minQ]) maxQ = max([_q_axis[-1], maxQ]) tmp_wks_name = CreateWorkspace(DataX = _q_axis, DataY = _y_axis, DataE = _e_axis, Nspec = 1, UnitX = "Wavelength", OutputWorkspace = tmp_wks_name) tmp_wks_name.setDistribution(True) # rebin everyting using the same Q binning parameters binQ = self.dq_over_q bin_parameters = str(minQ) + ',-' + str(binQ) + ',' + str(maxQ) for i in range(nbr_row): tmp_wks_name = 'wks_' + str(i) ConvertToHistogram(InputWorkspace = tmp_wks_name, OutputWorkspace = tmp_wks_name) Rebin(InputWorkspace = tmp_wks_name, Params = bin_parameters, OutputWorkspace = tmp_wks_name) # we use the first histo as output reference data_y = mtd['wks_0'].dataY(0).copy() data_e = mtd['wks_0'].dataE(0).copy() skip_index = 0 point_to_skip = 2 for k in range(1, nbr_row): skip_point = True can_skip_last_point = False data_y_k = mtd['wks_' + str(k)].dataY(0) data_e_k = mtd['wks_' + str(k)].dataE(0) for j in range(len(data_y_k)-1): if data_y_k[j] > 0: can_skip_last_point = True if skip_point: skip_index += 1 if skip_index == point_to_skip: skip_point = False skip_index = 0 else: continue if can_skip_last_point and (data_y_k[j+1] == 0): break if data_y[j] > 0 and data_y_k[j] > 0: if self.use_lowest_error_value_flag: if (data_e[j] > data_e_k[j]): data_y[j] = data_y_k[j] data_e[j] = data_e_k[j] else: [data_y[j], data_e[j]] = RefRed.utilities.weighted_mean([data_y[j], data_y_k[j]], [data_e[j], data_e_k[j]]) elif (data_y[j] == 0) and (data_y_k[j]>0): data_y[j] = data_y_k[j] data_e[j] = data_e_k[j] data_x = mtd['wks_1'].dataX(0) self.q_axis = data_x self.y_axis = data_y self.e_axis = data_e
def get_selected_scale_type(self):
o_gui_utility = GuiUtility(parent = self.parent)
self.axis_type = o_gui_utility.get_reduced_yaxis_type()
def plot_live_reduced_data(self):
self.parent.ui.data_stitching_plot.clear()
self.parent.ui.data_stitching_plot.draw()
big_table_data = self.big_table_data
_data = big_table_data[0, 0]
for index_row, _lconfig in enumerate(big_table_data[:,2]):
if _lconfig is None:
break
_q_axis = _lconfig.q_axis_for_display
_y_axis = _lconfig.y_axis_for_display
_e_axis = _lconfig.e_axis_for_display
sf = self.generate_selected_sf(lconfig=_lconfig)
_y_axis = np.array(_y_axis, dtype=np.float)
_e_axis = np.array(_e_axis, dtype=np.float)
_y_axis = _y_axis * sf
_e_axis = _e_axis * sf
o_produce_output = ProducedSelectedOutputScaled(parent=self.parent,
q_axis=_q_axis,
y_axis=_y_axis,
e_axis=_e_axis)
o_produce_output.calculate()
y_axis = o_produce_output.output_y_axis
e_axis = o_produce_output.output_e_axis
self.parent.ui.data_stitching_plot.errorbar(_q_axis, y_axis, yerr = e_axis,
color = self.get_current_color_plot(index_row))
if _data.all_plot_axis.is_reduced_plot_stitching_tab_ylog:
self.parent.ui.data_stitching_plot.set_yscale('log')
if _data.all_plot_axis.is_reduced_plot_stitching_tab_xlog:
self.parent.ui.data_stitching_plot.set_xscale('log')
self.parent.ui.data_stitching_plot.draw()
o_gui_utility = GuiUtility(parent = self.parent)
yaxis_type = o_gui_utility.get_reduced_yaxis_type()
if yaxis_type == 'RvsQ':
if _data.all_plot_axis.reduced_plot_RQuserView_y is None:
self.parent.ui.data_stitching_plot.canvas.draw()
[xmin,xmax] = self.parent.ui.data_stitching_plot.canvas.ax.xaxis.get_view_interval()
[ymin,ymax] = self.parent.ui.data_stitching_plot.canvas.ax.yaxis.get_view_interval()
_data.all_plot_axis.reduced_plot_RQQ4userView_x = [xmin, xmax]
_data.all_plot_axis.reduced_plot_RQuserView_y = [ymin, ymax]
_data.all_plot_axis.reduced_plot_RQQ4autoView_x = [xmin, xmax]
_data.all_plot_axis.reduced_plot_RQautoView_y = [ymin, ymax]
else:
[xmin, xmax] = _data.all_plot_axis.reduced_plot_RQQ4userView_x
[ymin, ymax] = _data.all_plot_axis.reduced_plot_RQuserView_y
self.parent.ui.data_stitching_plot.canvas.ax.set_xlim([xmin,xmax])
self.parent.ui.data_stitching_plot.canvas.ax.set_ylim([ymin,ymax])
self.parent.ui.data_stitching_plot.canvas.draw()
else:
if _data.all_plot_axis.reduced_plot_RQ4userView_y is None:
self.parent.ui.data_stitching_plot.canvas.draw()
[xmin,xmax] = self.parent.ui.data_stitching_plot.canvas.ax.xaxis.get_view_interval()
[ymin,ymax] = self.parent.ui.data_stitching_plot.canvas.ax.yaxis.get_view_interval()
_data.all_plot_axis.reduced_plot_RQQ4userView_x = [xmin, xmax]
_data.all_plot_axis.reduced_plot_RQ4userView_y = [ymin, ymax]
_data.all_plot_axis.reduced_plot_RQQ4autoView_x= [xmin, xmax]
_data.all_plot_axis.reduced_plot_RQ4autoView_y = [ymin, ymax]
else:
[xmin, xmax] = _data.all_plot_axis.reduced_plot_RQQ4userView_x
[ymin, ymax] = _data.all_plot_axis.reduced_plot_RQ4userView_y
self.parent.ui.data_stitching_plot.canvas.ax.set_xlim([xmin,xmax])
self.parent.ui.data_stitching_plot.canvas.ax.set_ylim([ymin,ymax])
self.parent.ui.data_stitching_plot.canvas.draw()
big_table_data[0, 0] = _data
self.parent.big_table_data = big_table_data
def clear_stiching_table(self):
if self.row_index == 0:
o_gui_utility = GuiUtility(parent = self.parent)
o_gui_utility.clear_table(self.parent.ui.dataStitchingTable)
def __init__(self, parent=None,
is_data=True,
entry_type='peak',
value_min=-1,
value_max=-1,
flag=True):
self.parent = parent
big_table_data = parent.big_table_data
gui_utility = GuiUtility(self.parent)
row = gui_utility.get_current_table_reduction_check_box_checked()
if row == -1:
return
if entry_type == 'clocking':
all_rows = gui_utility.get_all_rows()
else:
all_rows = gui_utility.get_other_row_with_same_run_number_as_row(row = row,
is_data = is_data)
for _row in all_rows:
if is_data:
index = 0
else:
index = 1
data = big_table_data[_row, index]
val1 = value_min
val2 = value_max
if (val1 > val2):
val_min = val2
val_max = val1
else:
val_min = val1
val_max = val2
is_plot_yt = True
is_plot_yi = True
is_plot_it = False
is_plot_ix = False
if entry_type == 'peak':
data.peak = [str(val_min), str(val_max)]
elif entry_type == 'back':
data.back = [str(val_min), str(val_max)]
data.back_flag = flag
elif entry_type == 'low_res':
is_plot_yt = False
is_plot_yi = False
is_plot_ix = True
data.low_res = [str(val_min), str(val_max)]
data.low_res_flag = flag
else:
data.clocking = [str(val_min), str(val_max)]
big_table_data[_row, index] = data
self.parent.big_table_data = big_table_data
if row == _row:
DisplayPlots(parent = self.parent,
row = row,
is_data = is_data,
plot_yt = is_plot_yt,
plot_yi = is_plot_yi,
plot_it = is_plot_it,
plot_ix = is_plot_ix,
refresh_reduction_table = False)
def closeEvent(self, event = None):
[lowres1, lowres2, lowresFlag] = self.retrieveLowRes()
[tof1, tof2, peak1, peak2, back1, back2, backFlag]= self.retrieveTofPeakBack()
tof_auto_switch = self.ui.tof_auto_flag.isChecked()
big_table_data = self.parent.big_table_data
_data = big_table_data[self.row, self.col]
_data.peak = [str(peak1), str(peak2)]
_data.back = [str(back1), str(back2)]
_data.back_flag = backFlag
_data.tof_range_auto = [self.auto_min_tof * 1000, self.auto_max_tof * 1000]
_data.tof_range = [self.manual_min_tof * 1000, self.manual_max_tof * 1000]
_data.tof_range_manual = _data.tof_range
_data.tof_range_auto_flag = tof_auto_switch
_data.tof_auto_flag = tof_auto_switch
_data.low_res = [str(lowres1), str(lowres2)]
_data.low_res_flag = lowresFlag
big_table_data[self.row, self.col] = _data
if self.is_row_with_highest_q:
_clock1 = self.ui.clock1.value()
_clock2 = self.ui.clock2.value()
_clocking = [str(_clock1), str(_clock2)]
_data = big_table_data[0, 0]
index = 0
while (_data is not None):
_data.clocking = _clocking
big_table_data[index, 0] = _data
_data = big_table_data[index+1, 0]
index += 1
self.parent.ui.dataPrimFromValue.setValue(_clock1)
self.parent.ui.dataPrimToValue.setValue(_clock2)
self.parent.big_table_data = big_table_data
# tof
o_gui_utility = GuiUtility(parent = self.parent)
o_gui_utility.set_auto_tof_range_radio_button(status = tof_auto_switch)
self.parent.ui.TOFmanualFromValue.setText("%.2f" %tof1)
self.parent.ui.TOFmanualToValue.setText("%.2f" %tof2)
if self.data_type == 'data':
self.parent.ui.dataPeakFromValue.setValue(peak1)
self.parent.ui.dataPeakToValue.setValue(peak2)
self.parent.ui.dataBackFromValue.setValue(back1)
self.parent.ui.dataBackToValue.setValue(back2)
self.parent.ui.dataBackgroundFlag.setChecked(backFlag)
#self.parent.data_peak_and_back_validation(False)
self.parent.ui.dataBackFromLabel.setEnabled(backFlag)
self.parent.ui.dataBackFromValue.setEnabled(backFlag)
self.parent.ui.dataBackToLabel.setEnabled(backFlag)
self.parent.ui.dataBackToValue.setEnabled(backFlag)
self.parent.ui.dataLowResFromValue.setValue(lowres1)
self.parent.ui.dataLowResToValue.setValue(lowres2)
self.parent.ui.dataLowResFromLabel.setEnabled(lowresFlag)
self.parent.ui.dataLowResFromValue.setEnabled(lowresFlag)
self.parent.ui.dataLowResToLabel.setEnabled(lowresFlag)
self.parent.ui.dataLowResToValue.setEnabled(lowresFlag)
else:
self.parent.ui.normPeakFromValue.setValue(peak1)
self.parent.ui.normPeakToValue.setValue(peak2)
self.parent.ui.normBackFromValue.setValue(back1)
self.parent.ui.normBackToValue.setValue(back2)
self.parent.ui.normBackgroundFlag.setChecked(backFlag)
#self.parent.norm_peak_and_back_validation(False)
self.parent.ui.normBackFromLabel.setEnabled(backFlag)
self.parent.ui.normBackFromValue.setEnabled(backFlag)
self.parent.ui.normBackToLabel.setEnabled(backFlag)
self.parent.ui.normBackToValue.setEnabled(backFlag)
self.parent.ui.normLowResFromValue.setValue(lowres1)
self.parent.ui.normLowResToValue.setValue(lowres2)
self.parent.ui.normLowResFromLabel.setEnabled(lowresFlag)
self.parent.ui.normLowResFromValue.setEnabled(lowresFlag)
self.parent.ui.normLowResToLabel.setEnabled(lowresFlag)
self.parent.ui.normLowResToValue.setEnabled(lowresFlag)
DisplayPlots(parent = self.parent,
row = self.row,
is_data = self.is_data,
plot_yt = True,
plot_yi = True,
plot_it = True,
plot_ix = True,
refresh_reduction_table = False)
if not tof_auto_switch:
o_auto_tof_range = AutoTofRangeRadioButtonHandler(parent = self.parent)
o_auto_tof_range.setup()
o_auto_tof_range.line_edit_validation()
def is_row_with_higest_q(self):
o_gui_utility = GuiUtility(parent = self.parent)
return o_gui_utility.is_row_with_highest_q()
def data_norm_tab_changed(self, index):
o_gui_utility = GuiUtility(parent = self)
_current_table_reduction_row_selected = o_gui_utility.get_current_table_reduction_check_box_checked()
ReductionTableCheckBox(parent = self,
row_selected = _current_table_reduction_row_selected)