def runTest(self):
# Load processed vanadium for normalisation (bank 1)
van = LoadNexus(Filename="WISH19612_vana_bank1_SXProcessed.nxs")
# Load raw data (bank 1)
ws = load_data_and_normalise(
"WISH00038237.raw") # default so doesn't get overwrite van
# normalise to vanadium
RebinToWorkspace(WorkspaceToRebin=van,
WorkspaceToMatch=ws,
OutputWorkspace=van)
Divide(LHSWorkspace=ws, RHSWorkspace=van, OutputWorkspace=ws)
ReplaceSpecialValues(InputWorkspace=ws,
OutputWorkspace=ws,
NaNValue=0,
InfinityValue=0,
BigNumberThreshold=1e15,
SmallNumberThreshold=-1e15)
# Convert to Diffraction MD and Lorentz Correction
wsMD = ConvertToDiffractionMDWorkspace(InputWorkspace=ws,
LorentzCorrection=True,
OneEventPerBin=False)
# BinMD to 2D object and convert to histo so can compare saved workspace
wsMD_2Dcut = BinMD(InputWorkspace=wsMD,
AxisAligned=False,
BasisVector0='Q_lab_x,Angstrom^-1,1.0,0.0,0.0',
BasisVector1='Q_lab_y,Angstrom^-1,0.0,1.0,0.0',
BasisVector2='Q_lab_z,Angstrom^-1,0.0,0.0,1.0',
OutputExtents='0.2,0.8,-0.4,0.4,0.05,0.1',
OutputBins='50,50,1')
ConvertMDHistoToMatrixWorkspace(InputWorkspace=wsMD_2Dcut,
outputWorkspace="wsHisto_2Dcut")
def _whole_inst_prefocus(input_workspace, vanadium_integration_ws,
full_calib) -> bool:
"""This is used to perform the operations done on the whole instrument workspace, before the chosen region of
interest is focused using _run_focus
:param input_workspace: Raw sample run to process prior to focussing over a region of interest
:param vanadium_integration_ws: Integral of the supplied vanadium run
:param full_calib: Full instrument calibration workspace (table ws output from PDCalibration)
:return True if successful, False if aborted
"""
if input_workspace.getRun().getProtonCharge() > 0:
NormaliseByCurrent(InputWorkspace=input_workspace,
OutputWorkspace=input_workspace)
else:
logger.warning(
f"Skipping focus of run {input_workspace.name()} because it has invalid proton charge."
)
return False
input_workspace /= vanadium_integration_ws
# replace nans created in sensitivity correction
ReplaceSpecialValues(InputWorkspace=input_workspace,
OutputWorkspace=input_workspace,
NaNValue=0,
InfinityValue=0)
ApplyDiffCal(InstrumentWorkspace=input_workspace,
CalibrationWorkspace=full_calib)
ConvertUnits(InputWorkspace=input_workspace,
OutputWorkspace=input_workspace,
Target='dSpacing')
return True
def divide_workspace(dividend_workspace, divisor_workspace):
"""
Divides the specified dividend workspace by the specified divisor workspace.
Replaces Infinity and NaNValues with 0.
:param dividend_workspace: The workspace to be divided.
:param divisor_workspace: The workspace to divide by.
:return: The dividend workspace / the divisor workspace.
"""
dividend_ws, divisor_ws = rebin_to_smallest(dividend_workspace, divisor_workspace)
divided_ws = Divide(LHSWorkspace=dividend_ws, RHSWorkspace=divisor_ws,
OutputWorkspace="divided", StoreInADS=False, EnableLogging=False)
return ReplaceSpecialValues(InputWorkspace=divided_ws,
NaNValue=0.0, InfinityValue=0.0,
OutputWorkspace="removed_special",
StoreInADS=False, EnableLogging=False)
def runTest(self):
try:
BASISPowderDiffraction(RunNumbers='74799',
FluxNormalizationType='Monitor',
OutputWorkspace='powder_Mon',
MaskFile='BASIS_Mask_default_diff.xml')
BASISPowderDiffraction(RunNumbers='74799',
FluxNormalizationType='Proton Charge',
OutputWorkspace='powder_Pro',
MaskFile='BASIS_Mask_default_diff.xml')
Divide(LHSWorkspace='powder_Pro',
RHSWorkspace='powder_Mon',
OutputWorkspace='powder_ratio')
ReplaceSpecialValues(InputWorkspace='powder_ratio',
NANValue=1.0,
NANError=1.0,
OutputWorkspace='powder_ratio')
finally:
self.preptear()
def load_data_and_normalise(filename,
spectrumMin=1,
spectrumMax=19461,
outputWorkspace="sample"):
"""
Function to load in raw data, crop and normalise
:param filename: file path to .raw
:param spectrumMin: min spec to load (default incl. all monitors)
:param spectrumMax: max spec to load (default includes only bank 1)
:param outputWorkspace: name of output workspace (can be specified to stop workspaces being overwritten)
:return: normalised and cropped data with xunit wavelength (excl. monitors)
"""
sample, mon = LoadRaw(Filename=filename,
SpectrumMin=spectrumMin,
SpectrumMax=spectrumMax,
LoadMonitors="Separate",
OutputWorkspace=outputWorkspace)
for ws in [sample, mon]:
CropWorkspace(InputWorkspace=ws,
OutputWorkspace=ws,
XMin=6000,
XMax=99000)
NormaliseByCurrent(InputWorkspace=ws, OutputWorkspace=ws)
ConvertUnits(InputWorkspace=ws,
OutputWorkspace=ws,
Target='Wavelength')
NormaliseToMonitor(InputWorkspace=sample,
OutputWorkspace=sample,
MonitorWorkspaceIndex=3,
MonitorWorkspace=mon)
ReplaceSpecialValues(InputWorkspace=sample,
OutputWorkspace=sample,
NaNValue=0,
InfinityValue=0)
CropWorkspace(InputWorkspace=sample,
OutputWorkspace=sample,
XMin=0.8,
XMax=9.3)
return sample
def _calculate_vanadium_processed_instrument(van_ws, full_calib_ws,
integral_ws,
run_no): # -> Workspace
"""
Calculate the processed whole-instrument workspace
:param van_ws: Chosen vanadium run workspace
:param full_calib_ws: Table workspace from the full instrument calibration (output from PDCalibration)
:param integral_ws: Vanadium integral workspace
:return: Whole instrument processed workspace
"""
ws = NormaliseByCurrent(
InputWorkspace=van_ws,
OutputWorkspace=str(run_no) + "_" +
PROCESSED_WORKSPACE_NAME) # create new name ws here
ApplyDiffCal(InstrumentWorkspace=ws, CalibrationWorkspace=full_calib_ws)
ConvertUnits(InputWorkspace=ws, OutputWorkspace=ws, Target='dSpacing')
# van sensitivity correction
ws /= integral_ws
ReplaceSpecialValues(InputWorkspace=ws,
OutputWorkspace=ws,
NaNValue=0,
InfinityValue=0)
return ws
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
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)