def load_legacy_cross_Sections(self, file_path):
"""
For legacy MR data, we need to load each cross-section independently.
:param str file_path: data file path
"""
ws_base_name = os.path.basename(file_path)
cross_sections = list()
for entry in ['Off_Off', 'On_Off', 'Off_On', 'On_On']:
try:
ws_name = "%s_%s" % (ws_base_name, entry)
ws = api.LoadEventNexus(Filename=file_path,
NXentryName='entry-%s' % entry,
OutputWorkspace=ws_name)
api.AddSampleLog(Workspace=ws,
LogName='cross_section_id',
LogText=entry)
cross_sections.append(ws_name)
except:
api.logger.information(
"Could not load %s from legacy data file" % entry)
# Prepare output workspace group
output_wsg = self.getPropertyValue("CrossSectionWorkspaces")
api.GroupWorkspaces(InputWorkspaces=cross_sections,
OutputWorkspace=output_wsg)
self.setProperty("CrossSectionWorkspaces", output_wsg)
def filter_cross_sections(self, file_path):
"""
Filter events according to the polarization states
:param str file_path: data file path
"""
output_wsg = self.getPropertyValue("CrossSectionWorkspaces")
pol_state = self.getProperty("PolState").value
pol_veto = self.getProperty("PolVeto").value
ana_state = self.getProperty("AnaState").value
ana_veto = self.getProperty("AnaVeto").value
ws_event_data = self.getProperty("InputWorkspace").value
if ws_event_data is not None:
ws_raw_name = str(ws_event_data)
ws_raw = ws_event_data
else:
ws_raw_name = os.path.basename(file_path)
ws_raw = api.LoadEventNexus(Filename=file_path,
OutputWorkspace=ws_raw_name)
if self.getProperty("CheckDevices").value:
# Check whether we have a polarizer
polarizer = ws_raw.getRun().getProperty("Polarizer").value[0]
# Check whether we have an analyzer
analyzer = ws_raw.getRun().getProperty("Analyzer").value[0]
else:
polarizer = 1
analyzer = 1
change_list = []
if polarizer > 0:
# SF1 ON
splitws, _ = api.GenerateEventsFilter(
InputWorkspace=ws_raw_name,
LogName=pol_state,
MinimumLogValue=0.99,
MaximumLogValue=1.01,
TimeTolerance=0,
OutputWorkspace='filter',
InformationWorkspace='filter_info',
LogBoundary='Left',
UnitOfTime='Seconds')
time_dict = splitws.toDict()
change_list.extend(
extract_times(time_dict['start'], True, is_sf1=True))
change_list.extend(
extract_times(time_dict['stop'], False, is_sf1=True))
# SF1 OFF
splitws, _ = api.GenerateEventsFilter(
InputWorkspace=ws_raw_name,
LogName=pol_state,
MinimumLogValue=-0.01,
MaximumLogValue=0.01,
TimeTolerance=0,
OutputWorkspace='filter',
InformationWorkspace='filter_info',
LogBoundary='Left',
UnitOfTime='Seconds')
time_dict = splitws.toDict()
change_list.extend(
extract_times(time_dict['start'], False, is_sf1=True))
change_list.extend(
extract_times(time_dict['stop'], True, is_sf1=True))
# SF1 VETO
if not pol_veto == '':
splitws, _ = api.GenerateEventsFilter(
InputWorkspace=ws_raw_name,
LogName=pol_veto,
MinimumLogValue=0.99,
MaximumLogValue=1.01,
TimeTolerance=0,
OutputWorkspace='filter',
InformationWorkspace='filter_info',
LogBoundary='Left',
UnitOfTime='Seconds')
time_dict = splitws.toDict()
change_list.extend(
extract_times(time_dict['start'], True, is_veto1=True))
change_list.extend(
extract_times(time_dict['stop'], False, is_veto1=True))
if analyzer > 0:
# SF2 ON
splitws, _ = api.GenerateEventsFilter(
InputWorkspace=ws_raw_name,
LogName=ana_state,
MinimumLogValue=0.99,
MaximumLogValue=1.01,
TimeTolerance=0,
OutputWorkspace='filter',
InformationWorkspace='filter_info',
LogBoundary='Left',
UnitOfTime='Seconds')
time_dict = splitws.toDict()
change_list.extend(
extract_times(time_dict['start'], True, is_sf2=True))
change_list.extend(
extract_times(time_dict['stop'], False, is_sf2=True))
# SF2 OFF
splitws, _ = api.GenerateEventsFilter(
InputWorkspace=ws_raw_name,
LogName=ana_state,
MinimumLogValue=-0.01,
MaximumLogValue=0.01,
TimeTolerance=0,
OutputWorkspace='filter',
InformationWorkspace='filter_info',
LogBoundary='Left',
UnitOfTime='Seconds')
time_dict = splitws.toDict()
change_list.extend(
extract_times(time_dict['start'], False, is_sf2=True))
change_list.extend(
extract_times(time_dict['stop'], True, is_sf2=True))
# SF2 VETO
if not ana_veto == '':
splitws, _ = api.GenerateEventsFilter(
InputWorkspace=ws_raw_name,
LogName=ana_veto,
MinimumLogValue=0.99,
MaximumLogValue=1.01,
TimeTolerance=0,
OutputWorkspace='filter',
InformationWorkspace='filter_info',
LogBoundary='Left',
UnitOfTime='Seconds')
time_dict = splitws.toDict()
change_list.extend(
extract_times(time_dict['start'], True, is_veto2=True))
change_list.extend(
extract_times(time_dict['stop'], False, is_veto2=True))
start_time = ws_raw.run().startTime().totalNanoseconds()
change_list = sorted(change_list, key=itemgetter(0))
split_table_ws = self.create_table(change_list,
start_time,
has_polarizer=polarizer > 0,
has_analyzer=analyzer > 0)
# Filter events if we found enough information to do so
if split_table_ws.rowCount() > 0:
outputs = api.FilterEvents(InputWorkspace=ws_raw,
SplitterWorkspace=split_table_ws,
OutputWorkspaceBaseName=output_wsg,
GroupWorkspaces=True,
FilterByPulseTime=False,
OutputWorkspaceIndexedFrom1=False,
CorrectionToSample="None",
SpectrumWithoutDetector="Skip",
SplitSampleLogs=True,
RelativeTime=True,
ExcludeSpecifiedLogs=True,
OutputTOFCorrectionWorkspace='_tmp')
AnalysisDataService.remove('_tmp')
for ws in outputs[-1]:
pol_state = str(ws).replace(output_wsg + '_', '')
api.AddSampleLog(Workspace=ws,
LogName='cross_section_id',
LogText=pol_state)
if ws_event_data is None:
AnalysisDataService.remove(ws_raw_name)
self.setProperty("CrossSectionWorkspaces", output_wsg)
# If we don't have a splitter table, it might be because we don't have analyzer/polarizer
# information. In this case don't filter and return the raw workspace.
elif polarizer <= 0 and analyzer <= 0:
api.logger.warning("No polarizer/analyzer information available")
self.setProperty("CrossSectionWorkspaces",
api.GroupWorkspaces([ws_raw]))
else:
api.logger.error("No events remained after filtering")
if ws_event_data is None:
AnalysisDataService.remove(ws_raw_name)
