def retrieveLambdaRequestedForThisRow(cls):
lambda_requested = ""
bigTable = cls.main_gui.bigTableData
# try to retrieve from bigTable[i,0]
data_obj = bigTable[cls.row, 0]
if data_obj is not None:
_active_data = data_obj.active_data
return str(_active_data.lambda_requested)
# try to retrieve from bigTable[i,2] -> data_lambda_requested
config_obj = bigTable[cls.row, 2]
if (config_obj.data_lambda_requested != -1) and (config_obj.data_lambda_requested != ""):
return str(config_obj.data_lambda_requested)
# try to retrieve from bigTable[i,1]
norm_obj = bigTable[cls.row, 1]
if norm_obj is not None:
_active_norm = norm_obj.active_data
return str(_active_norm.lambda_requested)
# try to retrieve from bigTable[i,2] -> norm_lambda_requested
if (config_obj.norm_lambda_requested != -1) and (config_obj.data_lambda_requested != ""):
return str(config_obj.norm_lambda_requested)
# try from data_run, if not None -> load and retrieve
data_run = cls.main_gui.ui.reductionTable.item(cls.row, 0).text()
if data_run != "":
try:
_filename = nexus_utilities.findNeXusFullPath(data_run)
cls.list_filename.append(_filename)
randomString = utilities.generate_random_workspace_name()
_nxs = LoadEventNexus(Filename=_filename, OutputWorkspace=randomString, MetaDataOnly=True)
return str(_nxs.getRun().getProperty("LambdaRequest").value[0])
except:
pass
# try from norm_run, if not None -> load and retrieve
norm_run = cls.main_gui.ui.reductionTable.item(cls.row, 6).text()
if norm_run != "":
try:
_filename = nexus_utilities.findNeXusFullPath(norm_run)
cls.list_filename.append(_filename)
randomString = utilities.generate_random_workspace_name()
_nxs = LoadEventNexus(Filename=_filename, OutputWorkspace=randomString, MetanormOnly=True)
return str(_nxs.getRun().getProperty("LambdaRequest").value[0])
except:
pass
# give up and return 'N/A'
return "N/A"
def dataLineEditValidate(cls):
run_sequence = cls.ui.dataLineEdit.text()
oListRuns = RunSequenceBreaker(run_sequence)
_list_runs = oListRuns.getFinalList()
cls.list_runs = _list_runs
cls.ui.dataLineEdit.setText("")
cls.list_filename = []
cls.list_nxs = []
if _list_runs[0] == -1:
return
for _runs in _list_runs:
try:
_filename = nexus_utilities.findNeXusFullPath(_runs)
except:
pass
else:
cls.list_filename.append(_filename)
randomString = utilities.generate_random_workspace_name()
_nxs = LoadEventNexus(Filename=_filename, OutputWorkspace=randomString, MetaDataOnly=True)
cls.list_nxs.append(_nxs)
cls.str_list_runs.append(str(_runs))
cls.updateDataTable()
cls.updateInsertValidRunsButton()
def __init__(cls, self, cell=None, replaced_data=False):
cls.self = self
cls.replaced_data = replaced_data
run_found = []
run_not_found = []
cls.run_number_found = []
if cell is None:
run_number_field = self.ui.numberSearchEntry.text()
else:
run_number_field = cell.text()
run_number_field = run_number_field.strip()
if run_number_field == "":
return
# list of runs
list_run_number = filter(None, run_number_field.split(","))
for run_number in list_run_number:
try:
full_file_name = nexus_utilities.findNeXusFullPath(int(run_number))
run_found.append(full_file_name)
cls.run_number_found.append(run_number)
except:
run_not_found.append(run_number)
if run_not_found != []:
info("Could not locate run(s) %s !" % (",".join(run_not_found)))
if run_found != []:
cls.open_file(run_found)
self.ui.numberSearchEntry.setText("")
def populate_data_object(self, main_gui, oConfig, type):
'''
will retrieve all the info from the oConfig table and will populate the oData object
type is either 'data' or 'norm'
'''
is_data = True
# check first if we have a full file name already
if oConfig is not None:
if type == 'data':
full_file_name = oConfig.data_full_file_name
if full_file_name == u'' or full_file_name == [''] :
_run_number = oConfig.data_sets
# full_file_name = FileFinder.findRuns("REF_L%d" %int(_run_number))[0]
full_file_name = nexus_utilities.findNeXusFullPath(int(_run_number))
else:
is_data = False
if oConfig.norm_flag:
full_file_name = oConfig.norm_full_file_name
if full_file_name == u'' or full_file_name == ['']:
_run_number = oConfig.norm_sets
# full_file_name = FileFinder.findRuns("REF_L%d" %int(_run_number))[0]
full_file_name = nexus_utilities.findNeXusFullPath(int(_run_number))
event_split_bins = None
event_split_index = 0
bin_type = 0
oData = NXSData(full_file_name,
bin_type = bin_type,
bins = main_gui.ui.eventTofBins.value(),
callback = None,
event_split_bins = event_split_bins,
event_split_index = event_split_index,
metadata_config_object = oConfig,
is_data = is_data)
return oData
return None
def __init__(self, runs_string = None):
if list_runs == None:
return ''
oListRuns = RunSequenceBreaker(list_runs)
list_run_number = oListRuns.getFinalList()
for run_number in list_run_number:
try:
full_file_name = nexus_utilities.findNeXusFullPath(int(run_number))
self.nexus_found.append(full_file_name)
except:
run_number_found.append(run_number)
def normLineEditValidate(cls):
_run = cls.ui.normLineEdit.text()
cls.ui.normLineEdit.setText("")
if _run == "":
return
cls.list_runs = [_run]
try:
_filename = nexus_utilities.findNeXusFullPath(_run)
except:
pass
else:
cls.list_filename.append(_filename)
randomString = utilities.generate_random_workspace_name()
_nxs = LoadEventNexus(Filename=_filename, OutputWorkspace=randomString, MetaDataOnly=True)
cls.list_nxs = [_nxs]
cls.str_list_runs.append(str(_run))
cls.updateNormTable()
cls.updateInsertValidRunsButton()
def findFullFileName(run_number):
try:
full_file_name = nexus_utilities.findNeXusFullPath(run_number)
except:
full_file_name = ''
return full_file_name
def __init__(cls, parent=None, filename=''):
self = parent
try:
dom = minidom.parse(filename)
except:
info('No configuration file loaded!')
return
RefLData = dom.getElementsByTagName('RefLData')
nbrRowBigTable = len(RefLData)
# reset bigTable
self.ui.reductionTable.clearContents()
_first_file_name = ''
# load the first data and display it
self.bigTableData = empty((20,3), dtype=object)
# start parsing xml file
_row = 0
for node in RefLData:
self.ui.reductionTable.insertRow(_row)
# incident angle
try:
_incident_angle = self.getNodeValue(node,'incident_angle')
except:
_incident_angle = 'N/A'
self.addItemToBigTable(_incident_angle, _row, 1)
# lambda range
try:
_from_l = self.getNodeValue(node, 'from_lambda_range')
except:
_from_l = 'N/A'
self.addItemToBigTable(_from_l, _row, 2)
try:
_to_l = self.getNodeValue(node, 'to_lambda_range')
except:
_to_l = 'N/A'
self.addItemToBigTable(_to_l, _row, 3)
# q range
try:
_from_q = self.getNodeValue(node,'from_q_range')
except:
_from_q = 'N/A'
self.addItemToBigTable(_from_q, _row, 4)
try:
_to_q = self.getNodeValue(node,'to_q_range')
except:
_to_q = 'N/A'
self.addItemToBigTable(_to_q, _row, 5)
# only for first row
if _row == 0:
_first_file_name = self.getNodeValue(node, 'data_full_file_name')
if _first_file_name == '': # no full_file_name defined
_data_sets = self.getNodeValue(node, 'data_sets')
_first_file_name = nexus_utilities.findNeXusFullPath(int(_data_sets)) #FIXME
else:
_first_file_name = _first_file_name.split(',')
# load general settings for first row only
scaling_factor_file = self.getNodeValue(node, 'scaling_factor_file')
self.ui.scalingFactorFile.setText(scaling_factor_file)
scaling_factor_flag = self.getNodeValue(node, 'scaling_factor_flag')
self.ui.scalingFactorFlag.setChecked(strtobool(scaling_factor_flag))
self.useScalingFactorConfigCheckBox(strtobool(scaling_factor_flag))
slits_width_flag = self.getNodeValue(node, 'slits_width_flag')
self.ui.scalingFactorSlitsWidthFlag.setChecked(strtobool(slits_width_flag))
incident_medium_list = self.getNodeValue(node, 'incident_medium_list')
im_list = incident_medium_list.split(',')
self.ui.selectIncidentMediumList.clear()
self.ui.selectIncidentMediumList.addItems(im_list)
incident_medium_index_selected = self.getNodeValue(node, 'incident_medium_index_selected')
self.ui.selectIncidentMediumList.setCurrentIndex(int(incident_medium_index_selected))
try:
useAutoPeakBackSelectionFlag = strtobool(self.getNodeValue(node,'auto_peak_back_selection_flag'))
autoBackSelectionWidth = int(self.getNodeValue(node, 'auto_peak_back_selection_width'))
useAutoTofRangeFinderFlag = strtobool(self.getNodeValue(node,'auto_tof_range_flag'))
except:
useAutoPeakBackSelectionFlag = True
autoBackSelectionWidth = 4
useAutoTofRangeFinderFlag = True
self.ui.actionAutomaticPeakFinder.setChecked(useAutoPeakBackSelectionFlag)
self.useAutoPeakBackSelectionCheckBox(useAutoPeakBackSelectionFlag)
self.ui.autoBackSelectionWidth.setValue(autoBackSelectionWidth)
self.ui.autoTofFlag.setChecked(useAutoTofRangeFinderFlag)
_exportStitchingAsciiSettings = self.exportStitchingAsciiSettings
fourth_column_flag = self.getNodeValue(node, 'fourth_column_flag')
_exportStitchingAsciiSettings.fourth_column_flag = fourth_column_flag
fourth_column_dq0 = self.getNodeValue(node, 'fourth_column_dq0')
_exportStitchingAsciiSettings.fourth_column_dq0 = fourth_column_dq0
fourth_column_dq_over_q = self.getNodeValue(node, 'fourth_column_dq_over_q')
_exportStitchingAsciiSettings.fourth_column_dq_over_q = fourth_column_dq_over_q
self.exportStitchingAsciiSettings = _exportStitchingAsciiSettings
_useGeometryCorrection = self.getNodeValue(node,'geometry_correction_switch')
self.useGeometryCorrectionCheckBox(strtobool(_useGeometryCorrection))
self.ui.geometryCorrectionFlag.setChecked(strtobool(_useGeometryCorrection))
_angle_offset = self.getNodeValue(node,'angle_offset')
self.ui.angleOffsetValue.setText(_angle_offset)
_angle_offset_error = self.getNodeValue(node,'angle_offset_error')
self.ui.angleOffsetError.setText(_angle_offset_error)
try:
_data_full_file_name = self.getNodeValue(node, 'data_full_file_name')
_data_full_file_name = _data_full_file_name.split(',')
except:
_data_full_file_name = ''
try:
_norm_full_file_name = self.getNodeValue(node, 'norm_full_file_name')
_norm_full_file_name = _norm_full_file_name.split(',')
except:
_norm_full_file_name = ''
_metadataObject = self.getMetadataObject(node)
_metadataObject.data_full_file_name = _data_full_file_name
_metadataObject.norm_full_file_name = _norm_full_file_name
self.bigTableData[_row,2] = _metadataObject
# data
_data_sets = self.getNodeValue(node,'data_sets')
_isOk = self.isPeakBackSelectionOkFromConfig(_metadataObject, type='data')
self.addItemToBigTable(_data_sets, _row, 0, isCheckOk=True, isOk=_isOk)
# norm
_norm_sets = self.getNodeValue(node,'norm_dataset')
_isOk = self.isPeakBackSelectionOkFromConfig(_metadataObject, type='norm')
self.addItemToBigTable(_norm_sets, _row, 6, isCheckOk=True, isOk=_isOk)
_row += 1
QtGui.QApplication.processEvents()
# select first data file
self.ui.dataNormTabWidget.setCurrentIndex(0)
self.ui.reductionTable.setRangeSelected(QtGui.QTableWidgetSelectionRange(0,0,0,0),True)
# load first data file
event_split_bins = None
event_split_index = 0
bin_type = 0
_configDataset = self.bigTableData[0,2]
data = NXSData(_first_file_name,
bin_type = bin_type,
bins = self.ui.eventTofBins.value(),
callback = self.updateEventReadout,
event_split_bins = event_split_bins,
event_split_index = event_split_index,
metadata_config_object = _configDataset,
angle_offset = self.ui.angleOffsetValue.text())
# make sure that incident_angle, q_range and/or lambda_range have values
item = self.ui.reductionTable.item(0,1)
if item is None:
_item = QtGui.QTableWidgetItem(str(data.active_data.incident_angle))
_item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
self.ui.reductionTable.setItem(0, 1, _item)
else:
incident_angle = item.text()
if incident_angle == 'N/A' or incident_angle == '':
_item = QtGui.QTableWidgetItem(str(data.active_data.incident_angle))
_item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
self.ui.reductionTable.setItem(0, 1, _item)
item = self.ui.reductionTable.item(0,4)
if item is None:
[_from_q, _to_q] = data.active_data.q_range
_item = QtGui.QTableWidgetItem(str(_from_q))
_item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
self.ui.reductionTable.setItem(0,4, _item)
_item = QtGui.QTableWidgetItem(str(_to_q))
_item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
self.ui.reductionTable.setItem(0,5, _item)
else:
from_q = item.text()
if from_q == '':
[_from_q, _to_q] = data.active_data.q_range
_item = QtGui.QTableWidgetItem(str(_from_q))
_item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
self.ui.reductionTable.setItem(0,4, _item)
_item = QtGui.QTableWidgetItem(str(_to_q))
_item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
self.ui.reductionTable.setItem(0,5, _item)
item = self.ui.reductionTable.item(0,2)
if item is None:
[_from_l, _to_l] = data.active_data.lambda_range
_item = QtGui.QTableWidgetItem(str(_from_l))
_item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
self.ui.reductionTable.setItem(0,2, _item)
_item = QtGui.QTableWidgetItem(str(_to_l))
_item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
self.ui.reductionTable.setItem(0,3, _item)
else:
from_lambda = item.text()
if from_lambda == '':
[_from_l, _to_l] = data.active_data.lambda_range
_item = QtGui.QTableWidgetItem(str(_from_l))
_item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
self.ui.reductionTable.setItem(0,2, _item)
_item = QtGui.QTableWidgetItem(str(_to_l))
_item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
self.ui.reductionTable.setItem(0,3, _item)
r=0
c=0
self.bigTableData[r,c] = data
self._prev_row_selected = r
self._prev_col_selected = c
self._fileOpenDoneREFL(data=data,
filename=_first_file_name,
do_plot=True,
update_table=False)
