def add_directory_structure(dirs):
"""
create the nested WorkspaceGroup structure in the ADS specified by the
stored directory attribute.
dirs = ["dir1", "dir2"] eg. ['Muon Data', 'MUSR72105', 'MUSR72105 Raw Data']
"""
if not dirs:
return
if len(dirs) > len(set(dirs)):
raise ValueError("Group names must be unique")
for directory in dirs:
if not mtd.doesExist(directory):
workspace_group = api.WorkspaceGroup()
mtd.addOrReplace(directory, workspace_group)
elif not isinstance(mtd[directory], api.WorkspaceGroup):
mtd.remove(directory)
workspace_group = api.WorkspaceGroup()
mtd.addOrReplace(directory, workspace_group)
else:
# exists and is a workspace group
pass
# Create the nested group structure in the ADS
previous_dir = ""
for i, directory in enumerate(dirs):
if i == 0:
previous_dir = directory
continue
mtd[previous_dir].add(directory)
previous_dir = directory
def add_directory_structure(dirs):
"""
create the nested WorkspaceGroup structure in the ADS specified by the
stored directory attribute.
dirs = ["dir1", "dir2"] eg. ['Muon Data', 'MUSR72105', 'MUSR72105 Raw Data']
"""
if not dirs:
return
if len(dirs) > len(set(dirs)):
raise ValueError("Group names must be unique")
for directory in dirs:
if not mtd.doesExist(directory):
workspace_group = api.WorkspaceGroup()
mtd.addOrReplace(directory, workspace_group)
elif not isinstance(mtd[directory], api.WorkspaceGroup):
mtd.remove(directory)
workspace_group = api.WorkspaceGroup()
mtd.addOrReplace(directory, workspace_group)
else:
# exists and is a workspace group
pass
# Create the nested group structure in the ADS
previous_dir = ""
for i, directory in enumerate(dirs):
if i == 0:
previous_dir = directory
continue
if not mtd[previous_dir].__contains__(directory):
mtd[previous_dir].add(directory)
previous_dir = directory
def hide(self):
"""
Remove the workspace from the ADS and store it in the class instance
"""
if mtd.doesExist(self._workspace_name):
self._workspace = mtd[self._workspace_name]
mtd.remove(self._workspace_name)
self._is_in_ads = False
def workspace(self, value):
if not self.is_hidden:
if mtd.doesExist(self._workspace_name):
mtd.remove(self._workspace_name)
self._is_in_ads = False
if isinstance(value, Workspace):
self._workspace = value
else:
raise AttributeError("Attempting to set object of type {}, must be"
" a Mantid Workspace type".format(type(value)))
def hide(self):
"""
Remove the workspace from the ADS and store it in the class instance
"""
if mtd.doesExist(self._workspace_name):
self._workspace = mtd[self._workspace_name]
mtd.remove(self._workspace_name)
self._is_in_ads = False
self._workspace_name = ""
self._directory_structure = ""
else:
pass
def hide(self):
"""
Remove the workspace from the ADS and store it in the class instance
"""
if mtd.doesExist(self._workspace_name):
self._workspace = mtd[self._workspace_name]
mtd.remove(self._workspace_name)
self._is_in_ads = False
self._workspace_name = ""
self._directory_structure = ""
else:
raise RuntimeWarning(
"Cannot remove workspace from ADS with name : {}".format(self._workspace_name))
def hide(self):
"""
Remove the workspace from the ADS and store it in the class instance
"""
if mtd.doesExist(self._workspace_name):
self._workspace = mtd[self._workspace_name]
mtd.remove(self._workspace_name)
self._is_in_ads = False
self._workspace_name = ""
self._directory_structure = ""
else:
raise RuntimeWarning(
"Cannot remove workspace from ADS with name : {}".format(
self._workspace_name))
def tearDownClass(cls):
[
mtd.remove(ws) for ws in [
'ConvertWANDSCDtoQTest_data', 'ConvertWANDSCDtoQTest_dummy'
'ConvertWANDSCDtoQTest_norm', 'ConvertWANDSCDtoQTest_dummy2'
]
]
def PyExec(self):
# Retrieve all relevant notice
in_Runs = self.getProperty("RunNumbers").value
maskWSname = self._getMaskWSname()
# either type of file-based calibration is stored in the same variable
calib = self.getProperty("Calibration").value
if calib == "Calibration File":
cal_File = self.getProperty("CalibrationFilename").value
elif calib == 'DetCal File':
cal_File = self.getProperty('DetCalFilename').value
cal_File = ','.join(cal_File)
else:
cal_File = None
params = self.getProperty("Binning").value
norm = self.getProperty("Normalization").value
if norm == "From Processed Nexus":
norm_File = self.getProperty("NormalizationFilename").value
LoadNexusProcessed(Filename=norm_File, OutputWorkspace='normWS')
normWS = 'normWS'
elif norm == "From Workspace":
normWS = str(self.getProperty("NormalizationWorkspace").value)
else:
normWS = None
group_to_real = {
'Banks': 'Group',
'Modules': 'bank',
'2_4 Grouping': '2_4Grouping'
}
group = self.getProperty('GroupDetectorsBy').value
real_name = group_to_real.get(group, group)
if not mtd.doesExist(group):
if group == '2_4 Grouping':
group = '2_4_Grouping'
CreateGroupingWorkspace(InstrumentName='SNAP',
GroupDetectorsBy=real_name,
OutputWorkspace=group)
Process_Mode = self.getProperty("ProcessingMode").value
prefix = self.getProperty("OptionalPrefix").value
# --------------------------- REDUCE DATA -----------------------------
Tag = 'SNAP'
for r in in_Runs:
self.log().notice("processing run %s" % r)
self.log().information(str(self.get_IPTS_Local(r)))
if self.getProperty("LiveData").value:
Tag = 'Live'
LoadPreNexusLive(Instrument='SNAP', OutputWorkspace='WS')
else:
Load(Filename='SNAP' + str(r), OutputWorkspace='WS')
NormaliseByCurrent(InputWorkspace='WS', OutputWorkspace='WS')
CompressEvents(InputWorkspace='WS', OutputWorkspace='WS')
CropWorkspace(InputWorkspace='WS',
OutputWorkspace='WS',
XMax=50000)
RemovePromptPulse(InputWorkspace='WS',
OutputWorkspace='WS',
Width='1600',
Frequency='60.4')
if maskWSname is not None:
MaskDetectors(Workspace='WS', MaskedWorkspace=maskWSname)
self._alignAndFocus(params, calib, cal_File, group)
normWS = self._generateNormalization('WS_red', norm, normWS)
WS_nor = None
if normWS is not None:
WS_nor = 'WS_nor'
Divide(LHSWorkspace='WS_red',
RHSWorkspace=normWS,
OutputWorkspace='WS_nor')
ReplaceSpecialValues(Inputworkspace='WS_nor',
OutputWorkspace='WS_nor',
NaNValue='0',
NaNError='0',
InfinityValue='0',
InfinityError='0')
new_Tag = Tag
if len(prefix) > 0:
new_Tag += '_' + prefix
# Edit instrument geomety to make final workspace smaller on disk
det_table = PreprocessDetectorsToMD(
Inputworkspace='WS_red', OutputWorkspace='__SNAP_det_table')
polar = np.degrees(det_table.column('TwoTheta'))
azi = np.degrees(det_table.column('Azimuthal'))
EditInstrumentGeometry(Workspace='WS_red',
L2=det_table.column('L2'),
Polar=polar,
Azimuthal=azi)
if WS_nor is not None:
EditInstrumentGeometry(Workspace='WS_nor',
L2=det_table.column('L2'),
Polar=polar,
Azimuthal=azi)
mtd.remove('__SNAP_det_table')
# Save requested formats
basename = '%s_%s_%s' % (new_Tag, r, group)
self._save(r, basename, norm)
# temporary workspace no longer needed
DeleteWorkspace(Workspace='WS')
# rename everything as appropriate and determine output workspace name
RenameWorkspace(Inputworkspace='WS_d',
OutputWorkspace='%s_%s_d' % (new_Tag, r))
RenameWorkspace(Inputworkspace='WS_red',
OutputWorkspace=basename + '_red')
if norm == 'None':
outputWksp = basename + '_red'
else:
outputWksp = basename + '_nor'
RenameWorkspace(Inputworkspace='WS_nor',
OutputWorkspace=basename + '_nor')
if norm == "Extracted from Data":
RenameWorkspace(Inputworkspace='peak_clip_WS',
OutputWorkspace='%s_%s_normalizer' %
(new_Tag, r))
# delte some things in production
if Process_Mode == "Production":
DeleteWorkspace(Workspace='%s_%s_d' %
(new_Tag, r)) # was 'WS_d'
if norm != "None":
DeleteWorkspace(Workspace=basename +
'_red') # was 'WS_red'
if norm == "Extracted from Data":
DeleteWorkspace(Workspace='%s_%s_normalizer' %
(new_Tag, r)) # was 'peak_clip_WS'
propertyName = 'OutputWorkspace_' + str(outputWksp)
self.declareProperty(
WorkspaceProperty(propertyName, outputWksp, Direction.Output))
self.setProperty(propertyName, outputWksp)
def PyExec(self):
in_Runs = self.getProperty("RunNumbers").value
maskWSname = self._getMaskWSname()
progress = Progress(self, 0., .25, 3)
# default arguments for AlignAndFocusPowder
alignAndFocusArgs = {'TMax': 50000,
'RemovePromptPulseWidth': 1600,
'PreserveEvents': False,
'Dspacing': True, # binning parameters in d-space
'Params': self.getProperty("Binning").value}
# workspace for loading metadata only to be used in LoadDiffCal and
# CreateGroupingWorkspace
metaWS = None
# either type of file-based calibration is stored in the same variable
calib = self.getProperty("Calibration").value
detcalFile = None
if calib == "Calibration File":
metaWS = self._loadMetaWS(in_Runs[0])
LoadDiffCal(Filename=self.getPropertyValue("CalibrationFilename"),
WorkspaceName='SNAP',
InputWorkspace=metaWS,
MakeGroupingWorkspace=False, MakeMaskWorkspace=False)
alignAndFocusArgs['CalibrationWorkspace'] = 'SNAP_cal'
elif calib == 'DetCal File':
detcalFile = ','.join(self.getProperty('DetCalFilename').value)
progress.report('loaded calibration')
norm = self.getProperty("Normalization").value
if norm == "From Processed Nexus":
norm_File = self.getProperty("NormalizationFilename").value
normalizationWS = 'normWS'
LoadNexusProcessed(Filename=norm_File, OutputWorkspace=normalizationWS)
progress.report('loaded normalization')
elif norm == "From Workspace":
normalizationWS = str(self.getProperty("NormalizationWorkspace").value)
progress.report('')
else:
normalizationWS = None
progress.report('')
group = self._generateGrouping(in_Runs[0], metaWS, progress)
if metaWS is not None:
DeleteWorkspace(Workspace=metaWS)
Process_Mode = self.getProperty("ProcessingMode").value
prefix = self.getProperty("OptionalPrefix").value
# --------------------------- REDUCE DATA -----------------------------
Tag = 'SNAP'
if self.getProperty("LiveData").value:
Tag = 'Live'
progStart = .25
progDelta = (1.-progStart)/len(in_Runs)
for i, runnumber in enumerate(in_Runs):
self.log().notice("processing run %s" % runnumber)
self.log().information(str(self.get_IPTS_Local(runnumber)))
# put together output names
new_Tag = Tag
if len(prefix) > 0:
new_Tag += '_' + prefix
basename = '%s_%s_%s' % (new_Tag, runnumber, group)
if self.getProperty("LiveData").value:
raise RuntimeError('Live data is not currently supported')
else:
Load(Filename='SNAP' + str(runnumber), OutputWorkspace=basename + '_red', startProgress=progStart,
endProgress=progStart + .25 * progDelta)
progStart += .25 * progDelta
redWS = basename + '_red'
# overwrite geometry with detcal files
if calib == 'DetCal File':
LoadIsawDetCal(InputWorkspace=redWS, Filename=detcalFile)
# create unfocussed data if in set-up mode
if Process_Mode == "Set-Up":
unfocussedWksp = '{}_{}_d'.format(new_Tag, runnumber)
else:
unfocussedWksp = ''
AlignAndFocusPowder(InputWorkspace=redWS, OutputWorkspace=redWS,
MaskWorkspace=maskWSname, # can be empty string
GroupingWorkspace=group,
UnfocussedWorkspace=unfocussedWksp, # can be empty string
startProgress=progStart,
endProgress=progStart + .5 * progDelta,
**alignAndFocusArgs)
progStart += .5 * progDelta
# the rest takes up .25 percent of the run processing
progress = Progress(self, progStart, progStart+.25*progDelta, 2)
# AlignAndFocusPowder leaves the data in time-of-flight
ConvertUnits(InputWorkspace=redWS, OutputWorkspace=redWS, Target='dSpacing', EMode='Elastic')
# Edit instrument geometry to make final workspace smaller on disk
det_table = PreprocessDetectorsToMD(Inputworkspace=redWS,
OutputWorkspace='__SNAP_det_table')
polar = np.degrees(det_table.column('TwoTheta'))
azi = np.degrees(det_table.column('Azimuthal'))
EditInstrumentGeometry(Workspace=redWS, L2=det_table.column('L2'),
Polar=polar, Azimuthal=azi)
mtd.remove('__SNAP_det_table')
progress.report('simplify geometry')
# AlignAndFocus doesn't necessarily rebin the data correctly
if Process_Mode == "Set-Up":
Rebin(InputWorkspace=unfocussedWksp, Params=alignAndFocusArgs['Params'],
Outputworkspace=unfocussedWksp)
NormaliseByCurrent(InputWorkspace=redWS, OutputWorkspace=redWS)
# normalize the data as requested
normalizationWS = self._generateNormalization(redWS, norm, normalizationWS)
normalizedWS = None
if normalizationWS is not None:
normalizedWS = basename + '_nor'
Divide(LHSWorkspace=redWS, RHSWorkspace=normalizationWS,
OutputWorkspace=normalizedWS)
ReplaceSpecialValues(Inputworkspace=normalizedWS,
OutputWorkspace=normalizedWS,
NaNValue='0', NaNError='0',
InfinityValue='0', InfinityError='0')
progress.report('normalized')
else:
progress.report()
# rename everything as appropriate and determine output workspace name
if normalizedWS is None:
outputWksp = redWS
else:
outputWksp = normalizedWS
if norm == "Extracted from Data" and Process_Mode == "Production":
DeleteWorkspace(Workspace=redWS)
DeleteWorkspace(Workspace=normalizationWS)
# Save requested formats
saveDir = self.getPropertyValue("OutputDirectory").strip()
if len(saveDir) <= 0:
self.log().notice('Using default save location')
saveDir = os.path.join(self.get_IPTS_Local(runnumber), 'shared', 'data')
self._save(saveDir, basename, outputWksp)
# set workspace as an output so it gets history
propertyName = 'OutputWorkspace_'+str(outputWksp)
self.declareProperty(WorkspaceProperty(
propertyName, outputWksp, Direction.Output))
self.setProperty(propertyName, outputWksp)
# declare some things as extra outputs in set-up
if Process_Mode != "Production":
prefix = 'OuputWorkspace_{:d}_'.format(i)
propNames = [prefix + it for it in ['d', 'norm', 'normalizer']]
wkspNames = ['%s_%s_d' % (new_Tag, runnumber),
basename + '_red',
'%s_%s_normalizer' % (new_Tag, runnumber)]
for (propName, wkspName) in zip(propNames, wkspNames):
if mtd.doesExist(wkspName):
self.declareProperty(WorkspaceProperty(propName,
wkspName,
Direction.Output))
self.setProperty(propName, wkspName)
def PyExec(self):
in_Runs = self.getProperty("RunNumbers").value
progress = Progress(self, 0., .25, 3)
finalUnits = self.getPropertyValue("FinalUnits")
# default arguments for AlignAndFocusPowder
self.alignAndFocusArgs = {'TMax': 50000,
'RemovePromptPulseWidth': 1600,
'PreserveEvents': False,
'Dspacing': True, # binning parameters in d-space
'Params': self.getProperty("Binning").value,
}
# workspace for loading metadata only to be used in LoadDiffCal and
# CreateGroupingWorkspace
metaWS = None
# either type of file-based calibration is stored in the same variable
calib = self.getProperty("Calibration").value
detcalFile = None
if calib == "Calibration File":
metaWS = self._loadMetaWS(in_Runs[0])
LoadDiffCal(Filename=self.getPropertyValue("CalibrationFilename"),
WorkspaceName='SNAP',
InputWorkspace=metaWS,
MakeGroupingWorkspace=False, MakeMaskWorkspace=False)
self.alignAndFocusArgs['CalibrationWorkspace'] = 'SNAP_cal'
elif calib == 'DetCal File':
detcalFile = ','.join(self.getProperty('DetCalFilename').value)
progress.report('loaded calibration')
norm = self.getProperty("Normalization").value
if norm == "From Processed Nexus":
norm_File = self.getProperty("NormalizationFilename").value
normalizationWS = 'normWS'
LoadNexusProcessed(Filename=norm_File, OutputWorkspace=normalizationWS)
progress.report('loaded normalization')
elif norm == "From Workspace":
normalizationWS = str(self.getProperty("NormalizationWorkspace").value)
progress.report('')
else:
normalizationWS = None
progress.report('')
self.alignAndFocusArgs['GroupingWorkspace'] = self._generateGrouping(in_Runs[0], metaWS, progress)
self.alignAndFocusArgs['MaskWorkspace'] = self._getMaskWSname(in_Runs[0], metaWS) # can be empty string
if metaWS is not None:
DeleteWorkspace(Workspace=metaWS)
Process_Mode = self.getProperty("ProcessingMode").value
prefix = self.getProperty("OptionalPrefix").value
Tag = 'SNAP'
progStart = .25
progDelta = (1.-progStart)/len(in_Runs)
# --------------------------- PROCESS BACKGROUND ----------------------
if not self.getProperty('Background').isDefault:
progDelta = (1. - progStart) / (len(in_Runs) + 1) # redefine to account for background
background = 'SNAP_{}'.format(self.getProperty('Background').value)
self.log().notice("processing run background {}".format(background))
background, unfocussedBkgd = self._alignAndFocus(background,
background+'_bkgd_red',
detCalFilename=detcalFile,
withUnfocussed=(Process_Mode == 'Set-Up'),
progStart=progStart, progDelta=progDelta)
else:
background = None
unfocussedBkgd = ''
# --------------------------- REDUCE DATA -----------------------------
for i, runnumber in enumerate(in_Runs):
self.log().notice("processing run %s" % runnumber)
self.log().information(str(self.get_IPTS_Local(runnumber)))
# put together output names
new_Tag = Tag
if len(prefix) > 0:
new_Tag = prefix + '_' + new_Tag
basename = '%s_%s_%s' % (new_Tag, runnumber, self.alignAndFocusArgs['GroupingWorkspace'])
self.log().warning('{}:{}:{}'.format(i, new_Tag, basename))
redWS, unfocussedWksp = self._alignAndFocus('SNAP_{}'.format(runnumber),
basename + '_red',
detCalFilename=detcalFile,
withUnfocussed=(Process_Mode == 'Set-Up'),
progStart=progStart, progDelta=progDelta*.5)
progStart += .5 * progDelta
# subtract the background if it was supplied
if background:
self.log().information('subtracting {} from {}'.format(background, redWS))
Minus(LHSWorkspace=redWS, RHSWorkspace=background, OutputWorkspace=redWS)
# intentionally don't subtract the unfocussed workspace since it hasn't been normalized by counting time
# the rest takes up .25 percent of the run processing
progress = Progress(self, progStart, progStart+.25*progDelta, 2)
# AlignAndFocusPowder leaves the data in time-of-flight
ConvertUnits(InputWorkspace=redWS, OutputWorkspace=redWS, Target='dSpacing', EMode='Elastic')
# Edit instrument geometry to make final workspace smaller on disk
det_table = PreprocessDetectorsToMD(Inputworkspace=redWS,
OutputWorkspace='__SNAP_det_table')
polar = np.degrees(det_table.column('TwoTheta'))
azi = np.degrees(det_table.column('Azimuthal'))
EditInstrumentGeometry(Workspace=redWS, L2=det_table.column('L2'),
Polar=polar, Azimuthal=azi)
mtd.remove('__SNAP_det_table')
progress.report('simplify geometry')
# AlignAndFocus doesn't necessarily rebin the data correctly
if Process_Mode == "Set-Up":
Rebin(InputWorkspace=unfocussedWksp, Params=self.alignAndFocusArgs['Params'],
Outputworkspace=unfocussedWksp)
if background:
Rebin(InputWorkspace=unfocussedBkgd, Params=self.alignAndFocusArgs['Params'],
Outputworkspace=unfocussedBkgd)
# normalize the data as requested
normalizationWS = self._generateNormalization(redWS, norm, normalizationWS)
normalizedWS = None
if normalizationWS is not None:
normalizedWS = basename + '_nor'
Divide(LHSWorkspace=redWS, RHSWorkspace=normalizationWS,
OutputWorkspace=normalizedWS)
ReplaceSpecialValues(Inputworkspace=normalizedWS,
OutputWorkspace=normalizedWS,
NaNValue='0', NaNError='0',
InfinityValue='0', InfinityError='0')
progress.report('normalized')
else:
progress.report()
# rename everything as appropriate and determine output workspace name
if normalizedWS is None:
outputWksp = redWS
else:
outputWksp = normalizedWS
if norm == "Extracted from Data" and Process_Mode == "Production":
DeleteWorkspace(Workspace=redWS)
DeleteWorkspace(Workspace=normalizationWS)
# Save requested formats
saveDir = self.getPropertyValue("OutputDirectory").strip()
if len(saveDir) <= 0:
self.log().notice('Using default save location')
saveDir = os.path.join(self.get_IPTS_Local(runnumber), 'shared', 'data')
self._save(saveDir, basename, outputWksp)
# set workspace as an output so it gets history
ConvertUnits(InputWorkspace=str(outputWksp), OutputWorkspace=str(outputWksp), Target=finalUnits,
EMode='Elastic')
self._exportWorkspace('OutputWorkspace_' + str(outputWksp), outputWksp)
# declare some things as extra outputs in set-up
if Process_Mode != "Production":
propprefix = 'OutputWorkspace_{:d}_'.format(i)
propNames = [propprefix + it for it in ['d', 'norm', 'normalizer']]
wkspNames = ['%s_%s_d' % (new_Tag, runnumber),
basename + '_red',
'%s_%s_normalizer' % (new_Tag, runnumber)]
for (propName, wkspName) in zip(propNames, wkspNames):
self._exportWorkspace(propName, wkspName)
if background:
ConvertUnits(InputWorkspace=str(background), OutputWorkspace=str(background), Target=finalUnits,
EMode='Elastic')
prefix = 'OutputWorkspace_{}'.format(len(in_Runs))
propNames = [prefix + it for it in ['', '_d']]
wkspNames = [background, unfocussedBkgd]
for (propName, wkspName) in zip(propNames, wkspNames):
self._exportWorkspace(propName, wkspName)
def PyExec(self):
in_Runs = self.getProperty("RunNumbers").value
progress = Progress(self, 0., .25, 3)
finalUnits = self.getPropertyValue("FinalUnits")
self.chunkSize = self.getProperty('MaxChunkSize').value
# default arguments for AlignAndFocusPowder
self.alignAndFocusArgs = {'Tmin': 0,
'TMax': 50000,
'RemovePromptPulseWidth': 1600,
'PreserveEvents': False,
'Dspacing': True, # binning parameters in d-space
'Params': self.getProperty("Binning").value,
}
# workspace for loading metadata only to be used in LoadDiffCal and
# CreateGroupingWorkspace
metaWS = None
# either type of file-based calibration is stored in the same variable
calib = self.getProperty("Calibration").value
detcalFile = None
if calib == "Calibration File":
metaWS = self._loadMetaWS(in_Runs[0])
LoadDiffCal(Filename=self.getPropertyValue("CalibrationFilename"),
WorkspaceName='SNAP',
InputWorkspace=metaWS,
MakeGroupingWorkspace=False, MakeMaskWorkspace=False)
self.alignAndFocusArgs['CalibrationWorkspace'] = 'SNAP_cal'
elif calib == 'DetCal File':
detcalFile = ','.join(self.getProperty('DetCalFilename').value)
progress.report('loaded calibration')
norm = self.getProperty("Normalization").value
if norm == "From Processed Nexus":
norm_File = self.getProperty("NormalizationFilename").value
normalizationWS = 'normWS'
LoadNexusProcessed(Filename=norm_File, OutputWorkspace=normalizationWS)
progress.report('loaded normalization')
elif norm == "From Workspace":
normalizationWS = str(self.getProperty("NormalizationWorkspace").value)
progress.report('')
else:
normalizationWS = None
progress.report('')
self.alignAndFocusArgs['GroupingWorkspace'] = self._generateGrouping(in_Runs[0], metaWS, progress)
self.alignAndFocusArgs['MaskWorkspace'] = self._getMaskWSname(in_Runs[0], metaWS) # can be empty string
if metaWS is not None:
DeleteWorkspace(Workspace=metaWS)
Process_Mode = self.getProperty("ProcessingMode").value
prefix = self.getProperty("OptionalPrefix").value
Tag = 'SNAP'
progStart = .25
progDelta = (1.-progStart)/len(in_Runs)
# --------------------------- PROCESS BACKGROUND ----------------------
if not self.getProperty('Background').isDefault:
progDelta = (1. - progStart) / (len(in_Runs) + 1) # redefine to account for background
background = 'SNAP_{}'.format(self.getProperty('Background').value)
self.log().notice("processing run background {}".format(background))
background, unfocussedBkgd = self._alignAndFocus(background,
background+'_bkgd_red',
detCalFilename=detcalFile,
withUnfocussed=(Process_Mode == 'Set-Up'),
progStart=progStart, progDelta=progDelta)
else:
background = None
unfocussedBkgd = ''
# --------------------------- REDUCE DATA -----------------------------
for i, runnumber in enumerate(in_Runs):
self.log().notice("processing run %s" % runnumber)
# put together output names
new_Tag = Tag
if len(prefix) > 0:
new_Tag = prefix + '_' + new_Tag
basename = '%s_%s_%s' % (new_Tag, runnumber, self.alignAndFocusArgs['GroupingWorkspace'])
self.log().warning('{}:{}:{}'.format(i, new_Tag, basename))
redWS, unfocussedWksp = self._alignAndFocus('SNAP_{}'.format(runnumber),
basename + '_red',
detCalFilename=detcalFile,
withUnfocussed=(Process_Mode == 'Set-Up'),
progStart=progStart, progDelta=progDelta*.5)
progStart += .5 * progDelta
# subtract the background if it was supplied
if background:
self.log().information('subtracting {} from {}'.format(background, redWS))
Minus(LHSWorkspace=redWS, RHSWorkspace=background, OutputWorkspace=redWS)
# intentionally don't subtract the unfocussed workspace since it hasn't been normalized by counting time
# the rest takes up .25 percent of the run processing
progress = Progress(self, progStart, progStart+.25*progDelta, 2)
# AlignAndFocusPowder leaves the data in time-of-flight
ConvertUnits(InputWorkspace=redWS, OutputWorkspace=redWS, Target='dSpacing', EMode='Elastic')
# Edit instrument geometry to make final workspace smaller on disk
det_table = PreprocessDetectorsToMD(Inputworkspace=redWS,
OutputWorkspace='__SNAP_det_table')
polar = np.degrees(det_table.column('TwoTheta'))
azi = np.degrees(det_table.column('Azimuthal'))
EditInstrumentGeometry(Workspace=redWS, L2=det_table.column('L2'),
Polar=polar, Azimuthal=azi)
mtd.remove('__SNAP_det_table')
progress.report('simplify geometry')
# AlignAndFocus doesn't necessarily rebin the data correctly
if Process_Mode == "Set-Up":
Rebin(InputWorkspace=unfocussedWksp, Params=self.alignAndFocusArgs['Params'],
Outputworkspace=unfocussedWksp)
if background:
Rebin(InputWorkspace=unfocussedBkgd, Params=self.alignAndFocusArgs['Params'],
Outputworkspace=unfocussedBkgd)
# normalize the data as requested
normalizationWS = self._generateNormalization(redWS, norm, normalizationWS)
normalizedWS = None
if normalizationWS is not None:
normalizedWS = basename + '_nor'
Divide(LHSWorkspace=redWS, RHSWorkspace=normalizationWS,
OutputWorkspace=normalizedWS)
ReplaceSpecialValues(Inputworkspace=normalizedWS,
OutputWorkspace=normalizedWS,
NaNValue='0', NaNError='0',
InfinityValue='0', InfinityError='0')
progress.report('normalized')
else:
progress.report()
# rename everything as appropriate and determine output workspace name
if normalizedWS is None:
outputWksp = redWS
else:
outputWksp = normalizedWS
if norm == "Extracted from Data" and Process_Mode == "Production":
DeleteWorkspace(Workspace=redWS)
DeleteWorkspace(Workspace=normalizationWS)
# Save requested formats - function checks that saving is requested
self._save(runnumber, basename, outputWksp)
# set workspace as an output so it gets history
ConvertUnits(InputWorkspace=str(outputWksp), OutputWorkspace=str(outputWksp), Target=finalUnits,
EMode='Elastic')
self._exportWorkspace('OutputWorkspace_' + str(outputWksp), outputWksp)
# declare some things as extra outputs in set-up
if Process_Mode != "Production":
propprefix = 'OutputWorkspace_{:d}_'.format(i)
propNames = [propprefix + it for it in ['d', 'norm', 'normalizer']]
wkspNames = ['%s_%s_d' % (new_Tag, runnumber),
basename + '_red',
'%s_%s_normalizer' % (new_Tag, runnumber)]
for (propName, wkspName) in zip(propNames, wkspNames):
self._exportWorkspace(propName, wkspName)
if background:
ConvertUnits(InputWorkspace=str(background), OutputWorkspace=str(background), Target=finalUnits,
EMode='Elastic')
prefix = 'OutputWorkspace_{}'.format(len(in_Runs))
propNames = [prefix + it for it in ['', '_d']]
wkspNames = [background, unfocussedBkgd]
for (propName, wkspName) in zip(propNames, wkspNames):
self._exportWorkspace(propName, wkspName)
def PyExec(self):
in_Runs = self.getProperty("RunNumbers").value
maskWSname = self._getMaskWSname()
progress = Progress(self, 0., .25, 3)
# default arguments for AlignAndFocusPowder
alignAndFocusArgs = {
'TMax': 50000,
'RemovePromptPulseWidth': 1600,
'PreserveEvents': False,
'Dspacing': True, # binning parameters in d-space
'Params': self.getProperty("Binning").value
}
# workspace for loading metadata only to be used in LoadDiffCal and
# CreateGroupingWorkspace
metaWS = None
# either type of file-based calibration is stored in the same variable
calib = self.getProperty("Calibration").value
detcalFile = None
if calib == "Calibration File":
metaWS = self._loadMetaWS(in_Runs[0])
LoadDiffCal(Filename=self.getPropertyValue("CalibrationFilename"),
WorkspaceName='SNAP',
InputWorkspace=metaWS,
MakeGroupingWorkspace=False,
MakeMaskWorkspace=False)
alignAndFocusArgs['CalibrationWorkspace'] = 'SNAP_cal'
elif calib == 'DetCal File':
detcalFile = ','.join(self.getProperty('DetCalFilename').value)
progress.report('loaded calibration')
norm = self.getProperty("Normalization").value
if norm == "From Processed Nexus":
norm_File = self.getProperty("NormalizationFilename").value
normalizationWS = 'normWS'
LoadNexusProcessed(Filename=norm_File,
OutputWorkspace=normalizationWS)
progress.report('loaded normalization')
elif norm == "From Workspace":
normalizationWS = str(
self.getProperty("NormalizationWorkspace").value)
progress.report('')
else:
normalizationWS = None
progress.report('')
group = self._generateGrouping(in_Runs[0], metaWS, progress)
if metaWS is not None:
DeleteWorkspace(Workspace=metaWS)
Process_Mode = self.getProperty("ProcessingMode").value
prefix = self.getProperty("OptionalPrefix").value
# --------------------------- REDUCE DATA -----------------------------
Tag = 'SNAP'
if self.getProperty("LiveData").value:
Tag = 'Live'
progStart = .25
progDelta = (1. - progStart) / len(in_Runs)
for i, runnumber in enumerate(in_Runs):
self.log().notice("processing run %s" % runnumber)
self.log().information(str(self.get_IPTS_Local(runnumber)))
# put together output names
new_Tag = Tag
if len(prefix) > 0:
new_Tag += '_' + prefix
basename = '%s_%s_%s' % (new_Tag, runnumber, group)
if self.getProperty("LiveData").value:
raise RuntimeError('Live data is not currently supported')
else:
Load(Filename='SNAP' + str(runnumber),
OutputWorkspace=basename + '_red',
startProgress=progStart,
endProgress=progStart + .25 * progDelta)
progStart += .25 * progDelta
redWS = basename + '_red'
# overwrite geometry with detcal files
if calib == 'DetCal File':
LoadIsawDetCal(InputWorkspace=redWS, Filename=detcalFile)
# create unfocussed data if in set-up mode
if Process_Mode == "Set-Up":
unfocussedWksp = '{}_{}_d'.format(new_Tag, runnumber)
else:
unfocussedWksp = ''
AlignAndFocusPowder(
InputWorkspace=redWS,
OutputWorkspace=redWS,
MaskWorkspace=maskWSname, # can be empty string
GroupingWorkspace=group,
UnfocussedWorkspace=unfocussedWksp, # can be empty string
startProgress=progStart,
endProgress=progStart + .5 * progDelta,
**alignAndFocusArgs)
progStart += .5 * progDelta
# the rest takes up .25 percent of the run processing
progress = Progress(self, progStart, progStart + .25 * progDelta,
2)
# AlignAndFocusPowder leaves the data in time-of-flight
ConvertUnits(InputWorkspace=redWS,
OutputWorkspace=redWS,
Target='dSpacing',
EMode='Elastic')
# Edit instrument geometry to make final workspace smaller on disk
det_table = PreprocessDetectorsToMD(
Inputworkspace=redWS, OutputWorkspace='__SNAP_det_table')
polar = np.degrees(det_table.column('TwoTheta'))
azi = np.degrees(det_table.column('Azimuthal'))
EditInstrumentGeometry(Workspace=redWS,
L2=det_table.column('L2'),
Polar=polar,
Azimuthal=azi)
mtd.remove('__SNAP_det_table')
progress.report('simplify geometry')
# AlignAndFocus doesn't necessarily rebin the data correctly
if Process_Mode == "Set-Up":
Rebin(InputWorkspace=unfocussedWksp,
Params=alignAndFocusArgs['Params'],
Outputworkspace=unfocussedWksp)
NormaliseByCurrent(InputWorkspace=redWS, OutputWorkspace=redWS)
# normalize the data as requested
normalizationWS = self._generateNormalization(
redWS, norm, normalizationWS)
normalizedWS = None
if normalizationWS is not None:
normalizedWS = basename + '_nor'
Divide(LHSWorkspace=redWS,
RHSWorkspace=normalizationWS,
OutputWorkspace=normalizedWS)
ReplaceSpecialValues(Inputworkspace=normalizedWS,
OutputWorkspace=normalizedWS,
NaNValue='0',
NaNError='0',
InfinityValue='0',
InfinityError='0')
progress.report('normalized')
else:
progress.report()
# rename everything as appropriate and determine output workspace name
if normalizedWS is None:
outputWksp = redWS
else:
outputWksp = normalizedWS
if norm == "Extracted from Data" and Process_Mode == "Production":
DeleteWorkspace(Workspace=redWS)
DeleteWorkspace(Workspace=normalizationWS)
# Save requested formats
saveDir = self.getPropertyValue("OutputDirectory").strip()
if len(saveDir) <= 0:
self.log().notice('Using default save location')
saveDir = os.path.join(self.get_IPTS_Local(runnumber),
'shared', 'data')
self._save(saveDir, basename, outputWksp)
# set workspace as an output so it gets history
propertyName = 'OutputWorkspace_' + str(outputWksp)
self.declareProperty(
WorkspaceProperty(propertyName, outputWksp, Direction.Output))
self.setProperty(propertyName, outputWksp)
# declare some things as extra outputs in set-up
if Process_Mode != "Production":
prefix = 'OuputWorkspace_{:d}_'.format(i)
propNames = [prefix + it for it in ['d', 'norm', 'normalizer']]
wkspNames = [
'%s_%s_d' % (new_Tag, runnumber), basename + '_red',
'%s_%s_normalizer' % (new_Tag, runnumber)
]
for (propName, wkspName) in zip(propNames, wkspNames):
if mtd.doesExist(wkspName):
self.declareProperty(
WorkspaceProperty(propName, wkspName,
Direction.Output))
self.setProperty(propName, wkspName)
def PyExec(self):
# Retrieve all relevant notice
in_Runs = self.getProperty("RunNumbers").value
maskWSname = self._getMaskWSname()
calib = self.getProperty("Calibration").value
if calib == "Calibration File":
cal_File = self.getProperty("CalibrationFilename").value
params = self.getProperty("Binning").value
norm = self.getProperty("Normalization").value
if norm == "From Processed Nexus":
norm_File = self.getProperty("Normalization filename").value
normWS = LoadNexusProcessed(Filename=norm_File)
elif norm == "From Workspace":
normWS = self.getProperty("NormalizationWorkspace").value
else:
normWS = None
group_to_real = {'Banks':'Group', 'Modules':'bank', '2_4 Grouping':'2_4_Grouping'}
group = self.getProperty("GroupDetectorsBy").value
real_name = group_to_real.get(group, group)
if not mtd.doesExist(group):
if group == "2_4 Grouping":
group = real_name
LoadDetectorsGroupingFile(InputFile=r'/SNS/SNAP/shared/libs/SNAP_group_2_4.xml',
OutputWorkspace=group)
else:
CreateGroupingWorkspace(InstrumentName='SNAP', GroupDetectorsBy=real_name,
OutputWorkspace=group)
Process_Mode = self.getProperty("ProcessingMode").value
prefix = self.getProperty("OptionalPrefix").value
# --------------------------- REDUCE DATA -----------------------------
Tag = 'SNAP'
for r in in_Runs:
self.log().notice("processing run %s" % r)
self.log().information(str(self.get_IPTS_Local(r)))
if self.getProperty("LiveData").value:
Tag = 'Live'
WS = LoadPreNexusLive(Instrument='SNAP')
else:
WS = Load(Filename='SNAP' + str(r), Outputworkspace='WS')
WS = NormaliseByCurrent(InputWorkspace=WS,
Outputworkspace='WS')
WS = CompressEvents(InputWorkspace=WS, Outputworkspace='WS')
WS = CropWorkspace(InputWorkspace='WS',
OutputWorkspace='WS', XMax=50000)
WS = RemovePromptPulse(InputWorkspace=WS, OutputWorkspace='WS',
Width='1600', Frequency='60.4')
if maskWSname is not None:
WS = MaskDetectors(Workspace=WS, MaskedWorkspace=maskWSname)
if calib == "Convert Units":
WS_d = ConvertUnits(InputWorkspace='WS',
Target='dSpacing', Outputworkspace='WS_d')
else:
self.log().notice("\n calibration file : %s" % cal_File)
WS_d = AlignDetectors(
InputWorkspace='WS', CalibrationFile=cal_File, Outputworkspace='WS_d')
WS_d = Rebin(InputWorkspace=WS_d, Params=params,
Outputworkspace='WS_d')
WS_red = DiffractionFocussing(InputWorkspace=WS_d, GroupingWorkspace=group,
PreserveEvents=False)
normWS = self._generateNormalization(WS_red, norm, normWS)
WS_nor = None
if normWS is not None:
WS_nor = Divide(LHSWorkspace=WS_red, RHSWorkspace=normWS)
WS_nor = ReplaceSpecialValues(Inputworkspace=WS_nor,
NaNValue='0', NaNError='0',
InfinityValue='0', InfinityError='0')
new_Tag = Tag
if len(prefix) > 0:
new_Tag += '_' + prefix
# Edit instrument geomety to make final workspace smaller on disk
det_table = PreprocessDetectorsToMD(Inputworkspace='WS_red',
OutputWorkspace='__SNAP_det_table')
polar = np.degrees(det_table.column('TwoTheta'))
azi = np.degrees(det_table.column('Azimuthal'))
EditInstrumentGeometry(Workspace="WS_red", L2=det_table.column('L2'),
Polar=polar, Azimuthal=azi)
if WS_nor is not None:
EditInstrumentGeometry(Workspace="WS_nor", L2=det_table.column('L2'),
Polar=polar, Azimuthal=azi)
mtd.remove('__SNAP_det_table')
# Save requested formats
basename = '%s_%s_%s' % (new_Tag, r, group)
self._save(r, basename, norm)
# temporary workspace no longer needed
DeleteWorkspace(Workspace='WS')
# rename everything as appropriate and determine output workspace name
RenameWorkspace(Inputworkspace='WS_d',
OutputWorkspace='%s_%s_d' % (new_Tag, r))
RenameWorkspace(Inputworkspace='WS_red',
OutputWorkspace=basename + '_red')
if norm == 'None':
outputWksp = basename + '_red'
else:
outputWksp = basename + '_nor'
RenameWorkspace(Inputworkspace='WS_nor',
OutputWorkspace=basename + '_nor')
if norm == "Extracted from Data":
RenameWorkspace(Inputworkspace='peak_clip_WS',
OutputWorkspace='%s_%s_normalizer' % (new_Tag, r))
# delte some things in production
if Process_Mode == "Production":
DeleteWorkspace(Workspace='%s_%s_d' % (new_Tag, r)) # was 'WS_d'
if norm != "None":
DeleteWorkspace(Workspace=basename + '_red') # was 'WS_red'
if norm == "Extracted from Data":
DeleteWorkspace(Workspace='%s_%s_normalizer' % (new_Tag, r)) # was 'peak_clip_WS'
propertyName = 'OutputWorkspace'
self.declareProperty(WorkspaceProperty(
propertyName, outputWksp, Direction.Output))
self.setProperty(propertyName, outputWksp)
def calc_absorption_corr_using_wksp(
donor_wksp,
abs_method,
element_size=1,
prefix_name="",
cache_dirs=[],
ms_method="",
):
# warn about caching
log = Logger('CalcAbsorptionCorrUsingWksp')
if cache_dirs:
log.warning("Empty cache dir found.")
# 1. calculate first order absorption correction
abs_s, abs_c = calc_1st_absorption_corr_using_wksp(donor_wksp, abs_method,
element_size,
prefix_name)
# 2. calculate 2nd order absorption correction
if ms_method in ["", None, "None"]:
log.information("Skip multiple scattering correction as instructed.")
else:
MultipleScatteringCorrection(
InputWorkspace=donor_wksp,
ElementSize=element_size,
method=ms_method,
OutputWorkspace="ms_tmp",
)
if ms_method == "SampleOnly":
ms_sampleOnly = mtd["ms_tmp_sampleOnly"]
ms_sampleOnly = 1 - ms_sampleOnly
# abs_s now point to the effective absorption correction
# A = A / (1 - ms_s)
Divide(
LHSWorkspace=abs_s, # str
RHSWorkspace=ms_sampleOnly, # workspace
OutputWorkspace=abs_s, # str
)
# nothing need to be done for container
# cleanup
mtd.remove("ms_tmp_sampleOnly")
elif ms_method == "SampleAndContainer":
ms_sampleAndContainer = mtd["ms_tmp_sampleAndContainer"]
ms_sampleAndContainer = 1 - ms_sampleAndContainer
Divide(
LHSWorkspace=abs_s, # str
RHSWorkspace=ms_sampleAndContainer, # workspace
OutputWorkspace=abs_s, # str
)
mtd.remove("ms_tmp_sampleAndContainer")
ms_containerOnly = mtd["ms_tmp_containerOnly"]
ms_containerOnly = 1 - ms_containerOnly
Divide(
LHSWorkspace=abs_c, # str
RHSWorkspace=ms_containerOnly, # workspace
OutputWorkspace=abs_c, # str
)
mtd.remove("ms_tmp_containerOnly")
else:
log.warning(
f"Multiple scattering method {ms_method} not supported, skipping."
)
return abs_s, abs_c
def tearDownClass(cls):
[mtd.remove(ws) for ws in ['ConvertWANDSCDtoQTest_data',
'ConvertWANDSCDtoQTest_dummy'
'ConvertWANDSCDtoQTest_norm',
'ConvertWANDSCDtoQTest_dummy2']]
