def processData(self, filename, wsName): if filename != '': if self._SystemTest: Load(Filename=filename, OutputWorkspace=wsName, BankName = 'bank22') else: Load(Filename=filename, OutputWorkspace=wsName) FindDetectorsPar(InputWorkspace=wsName, ReturnLinearRanges=self._returnLinearRanges, ParFile=self._parFile, OutputParTable=self._outputParTable) FilterBadPulses(InputWorkspace=wsName, Outputworkspace=wsName, LowerCutoff=self._lowerCutoff) RemovePromptPulse(InputWorkspace=wsName, OutputWorkspace=wsName, Width=self._width, Frequency=self._frequency) LoadDiffCal(InputWorkspace=wsName, InstrumentName=self._instrumentName, InstrumentFilename=self._instrumentFilename, Filename=self._filename, MakeGroupingWorkspace=self._makeGroupingWorkspace, MakeCalWorkspace=self._makeCalWorkspace, MakeMaskWorkspace=self._makeMaskWorkspace, WorkspaceName=self._workspaceName, TofMin=self._tofMin, TofMax=self._tofMax, FixConversionIssues=self._fixConversionIssues) MaskDetectors(Workspace=wsName, SpectraList=self._spectraList, DetectorList=self._detectorList, WorkspaceIndexList=self._workspaceIndexList, MaskedWorkspace=self._maskedWorkspace, ForceInstrumentMasking=self._forceInstrumentMasking, StartWorkspaceIndex=self._startWorkspaceIndex, EndWorkspaceIndex=self._endWorkspaceIndex, ComponentList=self._componentList) AlignDetectors(InputWorkspace=wsName, OutputWorkspace=wsName, CalibrationFile=self._calibrationFile) ConvertUnits(InputWorkspace=wsName, OutputWorkspace=wsName, Target='Wavelength')
def __processFile(self, filename, wkspname, file_prog_start, determineCharacterizations): chunks = determineChunking(filename, self.chunkSize) self.log().information('Processing \'%s\' in %d chunks' % (filename, len(chunks))) prog_per_chunk_step = self.prog_per_file * 1./(6.*float(len(chunks))) # for better progress reporting - 6 steps per chunk # inner loop is over chunks for (j, chunk) in enumerate(chunks): prog_start = file_prog_start + float(j) * 5. * prog_per_chunk_step chunkname = "%s_c%d" % (wkspname, j) Load(Filename=filename, OutputWorkspace=chunkname, startProgress=prog_start, endProgress=prog_start+prog_per_chunk_step, **chunk) if determineCharacterizations: self.__determineCharacterizations(filename, chunkname, False) # updates instance variable determineCharacterizations = False prog_start += prog_per_chunk_step if self.filterBadPulses > 0.: FilterBadPulses(InputWorkspace=chunkname, OutputWorkspace=chunkname, LowerCutoff=self.filterBadPulses, startProgress=prog_start, endProgress=prog_start+prog_per_chunk_step) prog_start += prog_per_chunk_step # absorption correction workspace if self.absorption is not None and len(str(self.absorption)) > 0: ConvertUnits(InputWorkspace=chunkname, OutputWorkspace=chunkname, Target='Wavelength', EMode='Elastic') Divide(LHSWorkspace=chunkname, RHSWorkspace=self.absorption, OutputWorkspace=chunkname, startProgress=prog_start, endProgress=prog_start+prog_per_chunk_step) ConvertUnits(InputWorkspace=chunkname, OutputWorkspace=chunkname, Target='TOF', EMode='Elastic') prog_start += prog_per_chunk_step AlignAndFocusPowder(InputWorkspace=chunkname, OutputWorkspace=chunkname, startProgress=prog_start, endProgress=prog_start+2.*prog_per_chunk_step, **self.kwargs) prog_start += 2.*prog_per_chunk_step # AlignAndFocusPowder counts for two steps if j == 0: self.__updateAlignAndFocusArgs(chunkname) RenameWorkspace(InputWorkspace=chunkname, OutputWorkspace=wkspname) else: Plus(LHSWorkspace=wkspname, RHSWorkspace=chunkname, OutputWorkspace=wkspname, ClearRHSWorkspace=self.kwargs['PreserveEvents'], startProgress=prog_start, endProgress=prog_start+prog_per_chunk_step) DeleteWorkspace(Workspace=chunkname) if self.kwargs['PreserveEvents']: CompressEvents(InputWorkspace=wkspname, OutputWorkspace=wkspname)
def __processFile(self, filename, file_prog_start, determineCharacterizations, createUnfocused): # noqa: C902,C901 # create a unique name for the workspace wkspname = '__' + self.__wkspNameFromFile(filename) wkspname += '_f%d' % self._filenames.index( filename) # add file number to be unique unfocusname = '' if createUnfocused: unfocusname = wkspname + '_unfocused' # check for a cachefilename cachefile = self.__getCacheName(self.__wkspNameFromFile(filename)) self.log().information('looking for cachefile "{}"'.format(cachefile)) if (not createUnfocused ) and self.useCaching and os.path.exists(cachefile): try: if self.__loadCacheFile(cachefile, wkspname): return wkspname, '' except RuntimeError as e: # log as a warning and carry on as though the cache file didn't exist self.log().warning('Failed to load cache file "{}": {}'.format( cachefile, e)) else: self.log().information('not using cache') chunks = determineChunking(filename, self.chunkSize) numSteps = 6 # for better progress reporting - 6 steps per chunk if createUnfocused: numSteps = 7 # one more for accumulating the unfocused workspace self.log().information('Processing \'{}\' in {:d} chunks'.format( filename, len(chunks))) prog_per_chunk_step = self.prog_per_file * 1. / (numSteps * float(len(chunks))) unfocusname_chunk = '' canSkipLoadingLogs = False # inner loop is over chunks haveAccumulationForFile = False for (j, chunk) in enumerate(chunks): prog_start = file_prog_start + float(j) * float( numSteps - 1) * prog_per_chunk_step # if reading all at once, put the data into the final name directly if len(chunks) == 1: chunkname = wkspname unfocusname_chunk = unfocusname else: chunkname = '{}_c{:d}'.format(wkspname, j) if unfocusname: # only create unfocus chunk if needed unfocusname_chunk = '{}_c{:d}'.format(unfocusname, j) # load a chunk - this is a bit crazy long because we need to get an output property from `Load` when it # is run and the algorithm history doesn't exist until the parent algorithm (this) has finished loader = self.__createLoader( filename, chunkname, skipLoadingLogs=(len(chunks) > 1 and canSkipLoadingLogs and haveAccumulationForFile), progstart=prog_start, progstop=prog_start + prog_per_chunk_step, **chunk) loader.execute() if j == 0: self.__setupCalibration(chunkname) # copy the necessary logs onto the workspace if len(chunks ) > 1 and canSkipLoadingLogs and haveAccumulationForFile: CopyLogs(InputWorkspace=wkspname, OutputWorkspace=chunkname, MergeStrategy='WipeExisting') # re-load instrument so detector positions that depend on logs get initialized try: LoadIDFFromNexus(Workspace=chunkname, Filename=filename, InstrumentParentPath='/entry') except RuntimeError as e: self.log().warning( 'Reloading instrument using "LoadIDFFromNexus" failed: {}' .format(e)) # get the underlying loader name if we used the generic one if self.__loaderName == 'Load': self.__loaderName = loader.getPropertyValue('LoaderName') # only LoadEventNexus can turn off loading logs, but FilterBadPulses # requires them to be loaded from the file canSkipLoadingLogs = self.__loaderName == 'LoadEventNexus' and self.filterBadPulses <= 0. and haveAccumulationForFile if determineCharacterizations and j == 0: self.__determineCharacterizations( filename, chunkname) # updates instance variable determineCharacterizations = False if self.__loaderName == 'LoadEventNexus' and mtd[ chunkname].getNumberEvents() == 0: self.log().notice( 'Chunk {} of {} contained no events. Skipping to next chunk.' .format(j + 1, len(chunks))) continue prog_start += prog_per_chunk_step if self.filterBadPulses > 0.: FilterBadPulses(InputWorkspace=chunkname, OutputWorkspace=chunkname, LowerCutoff=self.filterBadPulses, startProgress=prog_start, endProgress=prog_start + prog_per_chunk_step) if mtd[chunkname].getNumberEvents() == 0: msg = 'FilterBadPulses removed all events from ' if len(chunks) == 1: raise RuntimeError(msg + filename) else: raise RuntimeError(msg + 'chunk {} of {} in {}'.format( j, len(chunks), filename)) prog_start += prog_per_chunk_step # absorption correction workspace if self.absorption is not None and len(str(self.absorption)) > 0: ConvertUnits(InputWorkspace=chunkname, OutputWorkspace=chunkname, Target='Wavelength', EMode='Elastic') # rebin the absorption correction to match the binning of the inputs if in histogram mode # EventWorkspace will compare the wavelength of each individual event absWksp = self.absorption if mtd[chunkname].id() != 'EventWorkspace': absWksp = '__absWkspRebinned' RebinToWorkspace(WorkspaceToRebin=self.absorption, WorkspaceToMatch=chunkname, OutputWorkspace=absWksp) Divide(LHSWorkspace=chunkname, RHSWorkspace=absWksp, OutputWorkspace=chunkname, startProgress=prog_start, endProgress=prog_start + prog_per_chunk_step) if absWksp != self.absorption: # clean up DeleteWorkspace(Workspace=absWksp) ConvertUnits(InputWorkspace=chunkname, OutputWorkspace=chunkname, Target='TOF', EMode='Elastic') prog_start += prog_per_chunk_step if self.kwargs is None: raise RuntimeError( 'Somehow arguments for "AlignAndFocusPowder" aren\'t set') AlignAndFocusPowder(InputWorkspace=chunkname, OutputWorkspace=chunkname, UnfocussedWorkspace=unfocusname_chunk, startProgress=prog_start, endProgress=prog_start + 2. * prog_per_chunk_step, **self.kwargs) prog_start += 2. * prog_per_chunk_step # AlignAndFocusPowder counts for two steps self.__accumulate(chunkname, wkspname, unfocusname_chunk, unfocusname, not haveAccumulationForFile, removelogs=canSkipLoadingLogs) haveAccumulationForFile = True # end of inner loop if not mtd.doesExist(wkspname): raise RuntimeError( 'Failed to process any data from file "{}"'.format(filename)) # copy the sample object from the absorption workspace if self.absorption is not None and len(str(self.absorption)) > 0: CopySample(InputWorkspace=self.absorption, OutputWorkspace=wkspname, CopyEnvironment=False) # write out the cachefile for the main reduced data independent of whether # the unfocussed workspace was requested if self.useCaching and not os.path.exists(cachefile): self.log().information( 'Saving data to cachefile "{}"'.format(cachefile)) SaveNexusProcessed(InputWorkspace=wkspname, Filename=cachefile) return wkspname, unfocusname
def __processFile(self, filename, wkspname, unfocusname, file_prog_start, determineCharacterizations): chunks = determineChunking(filename, self.chunkSize) numSteps = 6 # for better progress reporting - 6 steps per chunk if unfocusname != '': numSteps = 7 # one more for accumulating the unfocused workspace self.log().information('Processing \'{}\' in {:d} chunks'.format( filename, len(chunks))) prog_per_chunk_step = self.prog_per_file * 1. / (numSteps * float(len(chunks))) unfocusname_chunk = '' # inner loop is over chunks for (j, chunk) in enumerate(chunks): prog_start = file_prog_start + float(j) * float( numSteps - 1) * prog_per_chunk_step chunkname = '{}_c{:d}'.format(wkspname, j) if unfocusname != '': # only create unfocus chunk if needed unfocusname_chunk = '{}_c{:d}'.format(unfocusname, j) Load(Filename=filename, OutputWorkspace=chunkname, startProgress=prog_start, endProgress=prog_start + prog_per_chunk_step, **chunk) if determineCharacterizations: self.__determineCharacterizations( filename, chunkname, False) # updates instance variable determineCharacterizations = False prog_start += prog_per_chunk_step if self.filterBadPulses > 0.: FilterBadPulses(InputWorkspace=chunkname, OutputWorkspace=chunkname, LowerCutoff=self.filterBadPulses, startProgress=prog_start, endProgress=prog_start + prog_per_chunk_step) prog_start += prog_per_chunk_step # absorption correction workspace if self.absorption is not None and len(str(self.absorption)) > 0: ConvertUnits(InputWorkspace=chunkname, OutputWorkspace=chunkname, Target='Wavelength', EMode='Elastic') Divide(LHSWorkspace=chunkname, RHSWorkspace=self.absorption, OutputWorkspace=chunkname, startProgress=prog_start, endProgress=prog_start + prog_per_chunk_step) ConvertUnits(InputWorkspace=chunkname, OutputWorkspace=chunkname, Target='TOF', EMode='Elastic') prog_start += prog_per_chunk_step AlignAndFocusPowder(InputWorkspace=chunkname, OutputWorkspace=chunkname, UnfocussedWorkspace=unfocusname_chunk, startProgress=prog_start, endProgress=prog_start + 2. * prog_per_chunk_step, **self.kwargs) prog_start += 2. * prog_per_chunk_step # AlignAndFocusPowder counts for two steps if j == 0: self.__updateAlignAndFocusArgs(chunkname) RenameWorkspace(InputWorkspace=chunkname, OutputWorkspace=wkspname) if unfocusname != '': RenameWorkspace(InputWorkspace=unfocusname_chunk, OutputWorkspace=unfocusname) else: Plus(LHSWorkspace=wkspname, RHSWorkspace=chunkname, OutputWorkspace=wkspname, ClearRHSWorkspace=self.kwargs['PreserveEvents'], startProgress=prog_start, endProgress=prog_start + prog_per_chunk_step) DeleteWorkspace(Workspace=chunkname) if unfocusname != '': Plus(LHSWorkspace=unfocusname, RHSWorkspace=unfocusname_chunk, OutputWorkspace=unfocusname, ClearRHSWorkspace=self.kwargs['PreserveEvents'], startProgress=prog_start, endProgress=prog_start + prog_per_chunk_step) DeleteWorkspace(Workspace=unfocusname_chunk) if self.kwargs['PreserveEvents']: CompressEvents(InputWorkspace=wkspname, OutputWorkspace=wkspname)
def __processFile(self, filename, wkspname, unfocusname, file_prog_start, determineCharacterizations): chunks = determineChunking(filename, self.chunkSize) numSteps = 6 # for better progress reporting - 6 steps per chunk if unfocusname != '': numSteps = 7 # one more for accumulating the unfocused workspace self.log().information('Processing \'{}\' in {:d} chunks'.format( filename, len(chunks))) prog_per_chunk_step = self.prog_per_file * 1. / (numSteps * float(len(chunks))) unfocusname_chunk = '' canSkipLoadingLogs = False # inner loop is over chunks for (j, chunk) in enumerate(chunks): prog_start = file_prog_start + float(j) * float( numSteps - 1) * prog_per_chunk_step chunkname = '{}_c{:d}'.format(wkspname, j) if unfocusname != '': # only create unfocus chunk if needed unfocusname_chunk = '{}_c{:d}'.format(unfocusname, j) # load a chunk - this is a bit crazy long because we need to get an output property from `Load` when it # is run and the algorithm history doesn't exist until the parent algorithm (this) has finished loader = self.__createLoader(filename, chunkname, progstart=prog_start, progstop=prog_start + prog_per_chunk_step) if canSkipLoadingLogs: loader.setProperty('LoadLogs', False) for key, value in chunk.items(): if isinstance(value, str): loader.setPropertyValue(key, value) else: loader.setProperty(key, value) loader.execute() # copy the necessary logs onto the workspace if canSkipLoadingLogs: CopyLogs(InputWorkspace=wkspname, OutputWorkspace=chunkname, MergeStrategy='WipeExisting') # get the underlying loader name if we used the generic one if self.__loaderName == 'Load': self.__loaderName = loader.getPropertyValue('LoaderName') canSkipLoadingLogs = self.__loaderName == 'LoadEventNexus' if determineCharacterizations and j == 0: self.__determineCharacterizations( filename, chunkname) # updates instance variable determineCharacterizations = False prog_start += prog_per_chunk_step if self.filterBadPulses > 0.: FilterBadPulses(InputWorkspace=chunkname, OutputWorkspace=chunkname, LowerCutoff=self.filterBadPulses, startProgress=prog_start, endProgress=prog_start + prog_per_chunk_step) prog_start += prog_per_chunk_step # absorption correction workspace if self.absorption is not None and len(str(self.absorption)) > 0: ConvertUnits(InputWorkspace=chunkname, OutputWorkspace=chunkname, Target='Wavelength', EMode='Elastic') Divide(LHSWorkspace=chunkname, RHSWorkspace=self.absorption, OutputWorkspace=chunkname, startProgress=prog_start, endProgress=prog_start + prog_per_chunk_step) ConvertUnits(InputWorkspace=chunkname, OutputWorkspace=chunkname, Target='TOF', EMode='Elastic') prog_start += prog_per_chunk_step AlignAndFocusPowder(InputWorkspace=chunkname, OutputWorkspace=chunkname, UnfocussedWorkspace=unfocusname_chunk, startProgress=prog_start, endProgress=prog_start + 2. * prog_per_chunk_step, **self.kwargs) prog_start += 2. * prog_per_chunk_step # AlignAndFocusPowder counts for two steps if j == 0: self.__updateAlignAndFocusArgs(chunkname) RenameWorkspace(InputWorkspace=chunkname, OutputWorkspace=wkspname) if unfocusname != '': RenameWorkspace(InputWorkspace=unfocusname_chunk, OutputWorkspace=unfocusname) else: RemoveLogs( Workspace=chunkname) # accumulation has them already Plus(LHSWorkspace=wkspname, RHSWorkspace=chunkname, OutputWorkspace=wkspname, ClearRHSWorkspace=self.kwargs['PreserveEvents'], startProgress=prog_start, endProgress=prog_start + prog_per_chunk_step) DeleteWorkspace(Workspace=chunkname) if unfocusname != '': RemoveLogs(Workspace=unfocusname_chunk ) # accumulation has them already Plus(LHSWorkspace=unfocusname, RHSWorkspace=unfocusname_chunk, OutputWorkspace=unfocusname, ClearRHSWorkspace=self.kwargs['PreserveEvents'], startProgress=prog_start, endProgress=prog_start + prog_per_chunk_step) DeleteWorkspace(Workspace=unfocusname_chunk) if self.kwargs['PreserveEvents'] and self.kwargs[ 'CompressTolerance'] > 0.: CompressEvents(InputWorkspace=wkspname, OutputWorkspace=wkspname, WallClockTolerance=self. kwargs['CompressWallClockTolerance'], Tolerance=self.kwargs['CompressTolerance'], StartTime=self.kwargs['CompressStartTime'])