def _save(self, runnumber, basename, norm): if not self.getProperty("SaveData").value: return saveDir = self.getProperty("OutputDirectory").value.strip() if len(saveDir) <= 0: self.log().notice('Using default save location') saveDir = os.path.join( self.get_IPTS_Local(runnumber), 'shared', 'data') self.log().notice('Writing to \'' + saveDir + '\'') if norm == 'None': SaveNexusProcessed(InputWorkspace='WS_red', Filename=os.path.join(saveDir, 'nexus', basename + '.nxs')) SaveAscii(InputWorkspace='WS_red', Filename=os.path.join(saveDir, 'd_spacing', basename + '.dat')) ConvertUnits(InputWorkspace='WS_red', OutputWorkspace='WS_tof', Target="TOF", AlignBins=False) else: SaveNexusProcessed(InputWorkspace='WS_nor', Filename=os.path.join(saveDir, 'nexus', basename + '.nxs')) SaveAscii(InputWorkspace='WS_nor', Filename=os.path.join(saveDir, 'd_spacing', basename + '.dat')) ConvertUnits(InputWorkspace='WS_nor', OutputWorkspace='WS_tof', Target="TOF", AlignBins=False) SaveGSS(InputWorkspace='WS_tof', Filename=os.path.join(saveDir, 'gsas', basename + '.gsa'), Format='SLOG', SplitFiles=False, Append=False, ExtendedHeader=True) SaveFocusedXYE(InputWorkspace='WS_tof', Filename=os.path.join( saveDir, 'fullprof', basename + '.dat'), SplitFiles=True, Append=False) DeleteWorkspace(Workspace='WS_tof')
def runTest(self): water = '3659, 3663, 3667' sample = "3674, 3677, 3680" transmission_sample = '3671' beam = '3587' transmission_water = '3655' transmission_water_cell = '3592' transmission_beam = '3587' absorber = '3598, 3604, 3654' empty_cell_water = '3618, 3623, 3646' cell_background = '3676, 3679, 3682' transmission_empty_cell = '3673' # first process the water SANSILLAutoProcess( SampleRuns=water, BeamRuns=beam, DefaultMaskFile="side_mask.nxs", MaskFiles="beam_mask.nxs, side_mask.nxs, side_mask.nxs", TransmissionBeamRuns=transmission_beam, SampleTransmissionRuns=transmission_water, ContainerTransmissionRuns=transmission_water_cell, OutputWorkspace='water', TransmissionBeamRadius=1, BeamRadius=1, ContainerRuns=empty_cell_water, ThetaDependent=False, WaterCrossSection=0.87, SampleThickness=0.2, AbsorberRuns=absorber, ClearCorrected2DWorkspace=False) tmp_dir = gettempdir() water_dir = [ os.path.join(tmp_dir, 'water_reference_g' + str(i) + '.nxs') for i in range(3) ] SaveNexusProcessed('003659_Sample', water_dir[0]) SaveNexusProcessed('003663_Sample', water_dir[1]) SaveNexusProcessed('003667_Sample', water_dir[2]) # then process the sample SANSILLAutoProcess(SampleRuns=sample, BeamRuns=beam, DefaultMaskFile="side_mask", MaskFiles="beam_mask, side_mask, side_mask", TransmissionBeamRuns=transmission_beam, OutputWorkspace='iq', ContainerTransmissionRuns=transmission_empty_cell, SampleTransmissionRuns=transmission_sample, ContainerRuns=cell_background, AbsorberRuns=absorber, ThetaDependent=False, WaterCrossSection=0.87, SampleThickness=0.2, TransmissionBeamRadius=1, BeamRadius=1, ReferenceFiles=",".join(water_dir), StitchReferenceIndex=0)
def runTest(self): beams = '947,1088' containers = '973,1003' container_tr = '988' beam_tr = '1119' samples = '975,1005' sample_tr = '990' solvents = '1106,1091' solvent_tr = '1121' thick = 0.1 # this also tests that already loaded workspace can be passed instead of a file LoadNexusProcessed(Filename='sens-lamp.nxs', OutputWorkspace='sens-lamp') # first, process the solvent SANSILLAutoProcess(SampleRuns=solvents, BeamRuns=beams, DefaultMaskFile='edge_masks', MaskFiles='mask_8m_4_6A,mask_1m_4_6A', SensitivityMaps='sens-lamp', SampleTransmissionRuns=solvent_tr, ContainerTransmissionRuns=container_tr, TransmissionBeamRuns=beam_tr, SampleThickness=thick, CalculateResolution='MildnerCarpenter', OutputWorkspace='solvents', BeamRadius='0.05', TransmissionBeamRadius=0.05, ClearCorrected2DWorkspace=False, StitchReferenceIndex=0) tmp_dir = gettempdir() solvent_dir = [ os.path.join(tmp_dir, 'solvent_' + str(i) + '.nxs') for i in range(2) ] SaveNexusProcessed('001106_Sample', solvent_dir[0]) SaveNexusProcessed('001091_Sample', solvent_dir[1]) # reduce samples SANSILLAutoProcess(SampleRuns=samples, BeamRuns=beams, ContainerRuns=containers, DefaultMaskFile='edge_masks', MaskFiles='mask_8m_4_6A,mask_1m_4_6A', SensitivityMaps='sens-lamp', SampleTransmissionRuns=sample_tr, ContainerTransmissionRuns=container_tr, TransmissionBeamRuns=beam_tr, SolventFiles=",".join(solvent_dir), SampleThickness=thick, CalculateResolution='MildnerCarpenter', OutputWorkspace='iq_mult_solvent', BeamRadius='0.05', TransmissionBeamRadius=0.05, StitchReferenceIndex=0)
def _save(self, saveDir, basename, outputWksp): if not self.getProperty("SaveData").value: return self.log().notice('Writing to \'' + saveDir + '\'') SaveNexusProcessed(InputWorkspace=outputWksp, Filename=os.path.join(saveDir, 'nexus', basename + '.nxs')) SaveAscii(InputWorkspace=outputWksp, Filename=os.path.join(saveDir, 'd_spacing', basename + '.dat')) ConvertUnits(InputWorkspace=outputWksp, OutputWorkspace='WS_tof', Target="TOF", AlignBins=False) # GSAS and FullProf require data in time-of-flight SaveGSS(InputWorkspace='WS_tof', Filename=os.path.join(saveDir, 'gsas', basename + '.gsa'), Format='SLOG', SplitFiles=False, Append=False, ExtendedHeader=True) SaveFocusedXYE(InputWorkspace='WS_tof', Filename=os.path.join(saveDir, 'fullprof', basename + '.dat'), SplitFiles=True, Append=False) DeleteWorkspace(Workspace='WS_tof')
def save_workspaces(self, workspaces_to_save=None): """ Use the private method _get_workspaces_to_save to get a list of workspaces that are present in the ADS to save to the directory that was passed at object creation time, it will also add each of them to the output_list private instance variable on the WorkspaceSaver class. :param workspaces_to_save: List of Strings; The workspaces that are to be saved to the project. """ # Handle getting here and nothing has been given passed if workspaces_to_save is None: return for workspace_name in workspaces_to_save: # Get the workspace from the ADS workspace = ADS.retrieve(workspace_name) place_to_save_workspace = os.path.join(self.directory, workspace_name) from mantid.simpleapi import SaveMD, SaveNexusProcessed try: if isinstance(workspace, MDHistoWorkspace) or isinstance(workspace, IMDEventWorkspace): # Save normally using SaveMD SaveMD(InputWorkspace=workspace_name, Filename=place_to_save_workspace + ".nxs") else: # Save normally using SaveNexusProcessed SaveNexusProcessed(InputWorkspace=workspace_name, Filename=place_to_save_workspace + ".nxs") except Exception: logger.warning("Couldn't save workspace in project: " + workspace) self.output_list.append(workspace_name)
def save_mantid_nexus(workspace_name, file_name, title=''): """ save workspace to NeXus for Mantid to import :param workspace_name: :param file_name: :param title: :return: """ # check input checkdatatypes.check_file_name(file_name, check_exist=False, check_writable=True, is_dir=False) checkdatatypes.check_string_variable('Workspace title', title) # check workspace checkdatatypes.check_string_variable('Workspace name', workspace_name) if mtd.doesExist(workspace_name): SaveNexusProcessed(InputWorkspace=workspace_name, Filename=file_name, Title=title) else: raise RuntimeError( 'Workspace {0} does not exist in Analysis data service. Available ' 'workspaces are {1}.' ''.format(workspace_name, mtd.getObjectNames()))
def sumToShim(rnum, output_dir=None): """ Combine both spin states into a single workspace Parameters ---------- rnum : int The run number to be shimmed output_dir : string If given, the folder where the workspace should be saved """ try: wtemp = Load(BASE.format(rnum), LoadMonitors=True) RebinToWorkspace('wtemp_1', 'wtemp_monitors_1', PreserveEvents=False, OutputWorkspace='wtemp_1') RebinToWorkspace('wtemp_2', 'wtemp_monitors_1', PreserveEvents=False, OutputWorkspace='wtemp_2') wtemp_1 = ConjoinWorkspaces('wtemp_monitors_1', 'wtemp_1') wtemp_2 = ConjoinWorkspaces('wtemp_monitors_2', 'wtemp_2') except: wtemp_monitors = Load(BASE.format(rnum)) wtempShim = mtd['wtemp_monitors_1'] + mtd['wtemp_monitors_2'] RenameWorkspace(wtempShim, 'LARMOR{:08d}'.format(rnum)) if output_dir: SaveNexusProcessed( 'LARMOR{:08d}'.format(rnum), os.path.join(output_dir, "LARMOR{:08d}-add.nxs".format(rnum))) RenameWorkspace('LARMOR{:08d}'.format(rnum), 'LARMOR{:08d}-add'.format(rnum))
def _save(self, runnumber, basename, outputWksp): if not self.getProperty("SaveData").value: return # determine where to save the data 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.log().notice('Writing to \'' + saveDir + '\'') SaveNexusProcessed(InputWorkspace=outputWksp, Filename=os.path.join(saveDir, 'nexus', basename + '.nxs')) SaveAscii(InputWorkspace=outputWksp, Filename=os.path.join(saveDir, 'd_spacing', basename + '.dat')) ConvertUnits(InputWorkspace=outputWksp, OutputWorkspace='WS_tof', Target="TOF", AlignBins=False) # GSAS and FullProf require data in time-of-flight SaveGSS(InputWorkspace='WS_tof', Filename=os.path.join(saveDir, 'gsas', basename + '.gsa'), Format='SLOG', SplitFiles=False, Append=False, ExtendedHeader=True) SaveFocusedXYE(InputWorkspace='WS_tof', Filename=os.path.join( saveDir, 'fullprof', basename + '.dat'), SplitFiles=True, Append=False) DeleteWorkspace(Workspace='WS_tof')
def _save_output(self): from mantid.simpleapi import SaveNexusProcessed workdir = config['defaultsave.directory'] el_eq1_path = os.path.join(workdir, self._scan_ws + '_el_eq1.nxs') logger.information('Creating file : %s' % el_eq1_path) SaveNexusProcessed(InputWorkspace=self._scan_ws + '_el_eq1', Filename=el_eq1_path) el_eq2_path = os.path.join(workdir, self._scan_ws + '_el_eq2.nxs') logger.information('Creating file : %s' % el_eq2_path) SaveNexusProcessed(InputWorkspace=self._scan_ws + '_el_eq2', Filename=el_eq2_path) inel_eq1_path = os.path.join(workdir, self._scan_ws + '_inel_eq1.nxs') logger.information('Creating file : %s' % inel_eq1_path) SaveNexusProcessed(InputWorkspace=self._scan_ws + '_inel_eq1', Filename=inel_eq1_path) inel_eq2_path = os.path.join(workdir, self._scan_ws + '_inel_eq2.nxs') logger.information('Creating file : %s' % inel_eq2_path) SaveNexusProcessed(InputWorkspace=self._scan_ws + '_inel_eq2', Filename=inel_eq2_path) eisf_path = os.path.join(workdir, self._scan_ws + '_eisf.nxs') logger.information('Creating file : %s' % eisf_path) SaveNexusProcessed(InputWorkspace=self._scan_ws + '_eisf', Filename=eisf_path) if self._msdfit: msd_path = os.path.join(workdir, self._scan_ws + '_msd.nxs') logger.information('Creating file : %s' % msd_path) SaveNexusProcessed(InputWorkspace=self._scan_ws + '_msd', Filename=msd_path) msd_fit_path = os.path.join(workdir, self._scan_ws + '_msd_fit.nxs') logger.information('Creating file : %s' % msd_fit_path) SaveNexusProcessed(InputWorkspace=self._scan_ws + '_msd_fit', Filename=msd_fit_path)
def save_reduction(worksspace_names, formats, x_units='DeltaE'): """ Saves the workspaces to the default save directory. @param worksspace_names List of workspace names to save @param formats List of formats to save in @param Output X units """ from mantid.simpleapi import (SaveSPE, SaveNexusProcessed, SaveNXSPE, SaveAscii, Rebin, DeleteWorkspace, ConvertSpectrumAxis, SaveDaveGrp) for workspace_name in worksspace_names: if 'spe' in formats: SaveSPE(InputWorkspace=workspace_name, Filename=workspace_name + '.spe') if 'nxs' in formats: SaveNexusProcessed(InputWorkspace=workspace_name, Filename=workspace_name + '.nxs') if 'nxspe' in formats: SaveNXSPE(InputWorkspace=workspace_name, Filename=workspace_name + '.nxspe') if 'ascii' in formats: # Version 1 of SaveAscii produces output that works better with excel/origin # For some reason this has to be done with an algorithm object, using the function # wrapper with Version did not change the version that was run saveAsciiAlg = AlgorithmManager.createUnmanaged('SaveAscii', 1) saveAsciiAlg.initialize() saveAsciiAlg.setProperty('InputWorkspace', workspace_name) saveAsciiAlg.setProperty('Filename', workspace_name + '.dat') saveAsciiAlg.execute() if 'aclimax' in formats: if x_units == 'DeltaE_inWavenumber': bins = '24, -0.005, 4000' #cm-1 else: bins = '3, -0.005, 500' #meV Rebin(InputWorkspace=workspace_name, OutputWorkspace=workspace_name + '_aclimax_save_temp', Params=bins) SaveAscii(InputWorkspace=workspace_name + '_aclimax_save_temp', Filename=workspace_name + '_aclimax.dat', Separator='Tab') DeleteWorkspace(Workspace=workspace_name + '_aclimax_save_temp') if 'davegrp' in formats: ConvertSpectrumAxis(InputWorkspace=workspace_name, OutputWorkspace=workspace_name + '_davegrp_save_temp', Target='ElasticQ', EMode='Indirect') SaveDaveGrp(InputWorkspace=workspace_name + '_davegrp_save_temp', Filename=workspace_name + '.grp') DeleteWorkspace(Workspace=workspace_name + '_davegrp_save_temp')
def save_reduction(workspace_names, formats, x_units='DeltaE'): """ Saves the workspaces to the default save directory. @param workspace_names List of workspace names to save @param formats List of formats to save in @param x_units X units """ from mantid.simpleapi import (SaveSPE, SaveNexusProcessed, SaveNXSPE, SaveAscii, Rebin, DeleteWorkspace, ConvertSpectrumAxis, SaveDaveGrp) for workspace_name in workspace_names: if 'spe' in formats: SaveSPE(InputWorkspace=workspace_name, Filename=workspace_name + '.spe') if 'nxs' in formats: SaveNexusProcessed(InputWorkspace=workspace_name, Filename=workspace_name + '.nxs') if 'nxspe' in formats: SaveNXSPE(InputWorkspace=workspace_name, Filename=workspace_name + '.nxspe') if 'ascii' in formats: # Changed to version 2 to enable re-loading of files into mantid saveAsciiAlg = AlgorithmManager.createUnmanaged('SaveAscii', 2) saveAsciiAlg.initialize() saveAsciiAlg.setProperty('InputWorkspace', workspace_name) saveAsciiAlg.setProperty('Filename', workspace_name + '.dat') saveAsciiAlg.execute() if 'aclimax' in formats: if x_units == 'DeltaE_inWavenumber': bins = '24, -0.005, 4000' #cm-1 else: bins = '3, -0.005, 500' #meV Rebin(InputWorkspace=workspace_name, OutputWorkspace=workspace_name + '_aclimax_save_temp', Params=bins) SaveAscii(InputWorkspace=workspace_name + '_aclimax_save_temp', Filename=workspace_name + '_aclimax.dat', Separator='Tab') DeleteWorkspace(Workspace=workspace_name + '_aclimax_save_temp') if 'davegrp' in formats: ConvertSpectrumAxis(InputWorkspace=workspace_name, OutputWorkspace=workspace_name + '_davegrp_save_temp', Target='ElasticQ', EMode='Indirect') SaveDaveGrp(InputWorkspace=workspace_name + '_davegrp_save_temp', Filename=workspace_name + '.grp') DeleteWorkspace(Workspace=workspace_name + '_davegrp_save_temp')
def runTest(self): PowderILLEfficiency(CalibrationRun='967076.nxs', OutputWorkspace='calib') SaveNexusProcessed(InputWorkspace='calib', Filename=self._m_tmp_file) PowderILLEfficiency(CalibrationRun='967076.nxs', CalibrationFile=self._m_tmp_file, OutputWorkspace='calib-2nd') for i in range(mtd['calib-2nd'].getNumberHistograms()): self.assertDelta(mtd['calib-2nd'].readY(i), 1., 1E-3)
def _save_output(self): """ Save the output workspace to the user's default working directory """ from IndirectCommon import getDefaultWorkingDirectory workdir = getDefaultWorkingDirectory() file_path = os.path.join(workdir, self._output_workspace + '.nxs') SaveNexusProcessed(InputWorkspace=self._output_workspace, Filename=file_path) if self._verbose: logger.notice('Output file : ' + file_path)
def save_reduction(workspace_names, formats, x_units='DeltaE'): """ Saves the workspaces to the default save directory. @param workspace_names List of workspace names to save @param formats List of formats to save in @param x_units X units """ from mantid.simpleapi import (SaveSPE, SaveNexusProcessed, SaveNXSPE, SaveAscii, Rebin, DeleteWorkspace, ConvertSpectrumAxis, SaveDaveGrp) for workspace_name in workspace_names: if 'spe' in formats: SaveSPE(InputWorkspace=workspace_name, Filename=workspace_name + '.spe') if 'nxs' in formats: SaveNexusProcessed(InputWorkspace=workspace_name, Filename=workspace_name + '.nxs') if 'nxspe' in formats: SaveNXSPE(InputWorkspace=workspace_name, Filename=workspace_name + '.nxspe') if 'ascii' in formats: _save_ascii(workspace_name, workspace_name + ".dat") if 'aclimax' in formats: if x_units == 'DeltaE_inWavenumber': bins = '24, -0.005, 4000' # cm-1 else: bins = '3, -0.005, 500' # meV Rebin(InputWorkspace=workspace_name, OutputWorkspace=workspace_name + '_aclimax_save_temp', Params=bins) SaveAscii(InputWorkspace=workspace_name + '_aclimax_save_temp', Filename=workspace_name + '_aclimax.dat', Separator='Tab') DeleteWorkspace(Workspace=workspace_name + '_aclimax_save_temp') if 'davegrp' in formats: ConvertSpectrumAxis(InputWorkspace=workspace_name, OutputWorkspace=workspace_name + '_davegrp_save_temp', Target='ElasticQ', EMode='Indirect') SaveDaveGrp(InputWorkspace=workspace_name + '_davegrp_save_temp', Filename=workspace_name + '.grp') DeleteWorkspace(Workspace=workspace_name + '_davegrp_save_temp')
def save_bank_table(data: Workspace, bank_id: int, database_path: str, date: str, table_type: str = 'calibration') -> None: """ Function that saves a bank calibrated TableWorkspace into a single HDF5 file using corelli format and using current date: database_path/bank0ID/type_corelli_bank0ID_YYYYMMDD.nxs.h5 :param data input Workspace (TableWorkspace) data for calibrated pixels :param bank_id bank number that is calibrated :param date format YYYYMMDD :param database_path location of the corelli database (absolute or relative) Example: database/corelli/ for database/corelli/bank001/ database/corelli/bank002/ :param table_type 'calibration', 'mask' or 'fit' """ verify_date_format('save_bank_table', date) filename: str = filename_bank_table(bank_id, database_path, date, table_type) SaveNexusProcessed(data, filename)
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 PyExec(self): filenames = self._getLinearizedFilenames('Filename') self.filterBadPulses = self.getProperty('FilterBadPulses').value self.chunkSize = self.getProperty('MaxChunkSize').value self.absorption = self.getProperty('AbsorptionWorkspace').value self.charac = self.getProperty('Characterizations').value finalname = self.getProperty('OutputWorkspace').valueAsStr self.prog_per_file = 1. / float( len(filenames)) # for better progress reporting # these are also passed into the child-algorithms self.kwargs = self.__getAlignAndFocusArgs() # outer loop creates chunks to load for (i, filename) in enumerate(filenames): # default name is based off of filename wkspname = os.path.split(filename)[-1].split('.')[0] self.__determineCharacterizations( filename, wkspname) # updates instance variable cachefile = self.__getCacheName(wkspname) wkspname += '_f%d' % i # add file number to be unique if cachefile is not None and os.path.exists(cachefile): LoadNexusProcessed(Filename=cachefile, OutputWorkspace=wkspname) # TODO LoadNexusProcessed has a bug. When it finds the # instrument name without xml it reads in from an IDF # in the instrument directory. editinstrargs = {} for name in PROPS_FOR_INSTR: prop = self.getProperty(name) if not prop.isDefault: editinstrargs[name] = prop.value if editinstrargs: EditInstrumentGeometry(Workspace=wkspname, **editinstrargs) else: self.__processFile(filename, wkspname, self.prog_per_file * float(i)) if cachefile is not None: SaveNexusProcessed(InputWorkspace=wkspname, Filename=cachefile) # accumulate runs if i == 0: if wkspname != finalname: RenameWorkspace(InputWorkspace=wkspname, OutputWorkspace=finalname) else: Plus(LHSWorkspace=finalname, RHSWorkspace=wkspname, OutputWorkspace=finalname, ClearRHSWorkspace=self.kwargs['PreserveEvents']) DeleteWorkspace(Workspace=wkspname) if self.kwargs['PreserveEvents']: CompressEvents(InputWorkspace=finalname, OutputWorkspace=finalname) # with more than one chunk or file the integrated proton charge is # generically wrong mtd[finalname].run().integrateProtonCharge() # set the output workspace self.setProperty('OutputWorkspace', mtd[finalname])
def validate(self): self.disableChecking.append('Instrument') from mantid.simpleapi import SaveNexusProcessed SaveNexusProcessed("992_rear_1DPhi-45.0_45.0", '/tmp/bad.nxs') return "992_rear_1DPhi-45.0_45.0", "SANS_TOML_Wav_Loops_ref.nxs"
def reduce_to_2theta(hb2b_builder, pixel_matrix, hb2b_data_ws_name, counts_array, mask_vec, mask_ws_name, num_bins=1000): """ Reduce to 2theta with Masks :param hb2b_builder: :param pixel_matrix: :param hb2b_data_ws_name: :param counts_array: :param mask_vec: :param num_bins: :return: """ # reduce by PyRS if False: pyrs_raw_ws = mtd[pyrs_raw_name] vec_counts = pyrs_raw_ws.readY(0) else: vec_counts = counts_array.astype('float64') # mask if mask_vec is not None: print(mask_vec.dtype) vec_counts.astype('float64') mask_vec.astype('float64') vec_counts *= mask_vec # reduce bin_edgets, histogram = hb2b_builder.reduce_to_2theta_histogram( pixel_matrix, vec_counts, num_bins) # create workspace pyrs_reduced_name = '{}_pyrs_reduced'.format(hb2b_data_ws_name) CreateWorkspace(DataX=bin_edgets, DataY=histogram, NSpec=1, OutputWorkspace=pyrs_reduced_name) SaveNexusProcessed(InputWorkspace=pyrs_reduced_name, Filename='{}.nxs'.format(pyrs_reduced_name), Title='PyRS reduced: {}'.format(hb2b_data_ws_name)) if True: # Mantid # transfer to 2theta for data two_theta_ws_name = '{}_2theta'.format(hb2b_data_ws_name) # Mask if mask_ws_name: # Multiply by masking workspace masked_ws_name = '{}_masked'.format(hb2b_data_ws_name) Multiply(LHSWorkspace=hb2b_data_ws_name, RHSWorkspace=mask_ws_name, OutputWorkspace=masked_ws_name, ClearRHSWorkspace=False) hb2b_data_ws_name = masked_ws_name SaveNexusProcessed(InputWorkspace=hb2b_data_ws_name, Filename='{}_raw.nxs'.format(hb2b_data_ws_name)) # END-IF # # this is for test only! # ConvertSpectrumAxis(InputWorkspace=hb2b_data_ws_name, OutputWorkspace=two_theta_ws_name, Target='Theta', # OrderAxis=False) # Transpose(InputWorkspace=two_theta_ws_name, OutputWorkspace=two_theta_ws_name) # two_theta_ws = mtd[two_theta_ws_name] # for i in range(10): # print ('{}: x = {}, y = {}'.format(i, two_theta_ws.readX(0)[i], two_theta_ws.readY(0)[i])) # for i in range(10010, 10020): # print ('{}: x = {}, y = {}'.format(i, two_theta_ws.readX(0)[i], two_theta_ws.readY(0)[i])) ConvertSpectrumAxis(InputWorkspace=hb2b_data_ws_name, OutputWorkspace=two_theta_ws_name, Target='Theta') Transpose(InputWorkspace=two_theta_ws_name, OutputWorkspace=two_theta_ws_name) # final: mantid_reduced_name = '{}_mtd_reduced'.format(hb2b_data_ws_name) ResampleX(InputWorkspace=two_theta_ws_name, OutputWorkspace=mantid_reduced_name, NumberBins=num_bins, PreserveEvents=False) mantid_ws = mtd[mantid_reduced_name] SaveNexusProcessed( InputWorkspace=mantid_reduced_name, Filename='{}.nxs'.format(mantid_reduced_name), Title='Mantid reduced: {}'.format(hb2b_data_ws_name)) plt.plot(mantid_ws.readX(0), mantid_ws.readY(0), color='blue', mark='o') # END-IF plt.plot(bin_edgets[:-1], histogram, color='red') plt.show() return
def save_banks(InputWorkspace, Filename, Title, OutputDir, Binning=None, GroupingWorkspace=None): """ Saves input workspace to processed NeXus file in specified output directory with optional rebinning and grouping (to coarsen) the output in a bank-by-bank manner. Mainly wraps Mantid `SaveNexusProcessed` algorithm. :param InputWorkspace: Mantid workspace to save out :type InputWorkspace: MatrixWorkspace :param Filename: Filename to save output :type Filename: str :param Title: A title to describe the saved workspace :type Title: str :param OutputDir: Output directory to save the processed NeXus file :type OutputDir: path str :param Binning: Optional rebinning of event workspace. See `Rebin` in Mantid for options :type Binning: dbl list :param GroupingWorkspace: A workspace with grouping information for the output spectra :type GroupWorkspace: GroupWorkspace """ # Make a local clone CloneWorkspace(InputWorkspace=InputWorkspace, OutputWorkspace="__tmp") tmp_wksp = mtd["__tmp"] # Rebin if requested if Binning: tmp_wksp = Rebin(InputWorkspace=tmp_wksp, Params=Binning, PreserveEvents=True) # Convert to distributions to remove bin width dependence yunit = tmp_wksp.YUnit() if yunit == "Counts": try: ConvertToDistribution(tmp_wksp) except BaseException: pass # Output to desired level of grouping isEventWksp = isinstance(tmp_wksp, IEventWorkspace) if isEventWksp and GroupingWorkspace and yunit == "Counts": tmp_wksp = DiffractionFocussing(InputWorkspace=tmp_wksp, GroupingWorkspace=GroupingWorkspace, PreserveEvents=False) # Save out wksp to file filename = os.path.join(os.path.abspath(OutputDir), Filename) SaveNexusProcessed(InputWorkspace=tmp_wksp, Filename=filename, Title=Title, Append=True, PreserveEvents=False, WorkspaceIndexList=range( tmp_wksp.getNumberHistograms())) DeleteWorkspace(tmp_wksp)
def add_runs( runs, # noqa: C901 inst='sans2d', defType='.nxs', rawTypes=('.raw', '.s*', 'add', '.RAW'), lowMem=False, binning='Monitors', saveAsEvent=False, isOverlay=False, time_shifts=None, outFile=None, outFile_monitors=None, save_directory=None, estimate_logs=False): if inst.upper() == "SANS2DTUBES": inst = "SANS2D" # Check if there is at least one file in the list if len(runs) < 1: return if not defType.startswith('.'): defType = '.' + defType # Create the correct format of adding files if time_shifts is None: time_shifts = [] adder = AddOperation(isOverlay, time_shifts) # These input arguments need to be arrays of strings, enforce this if isinstance(runs, str): runs = (runs, ) if isinstance(rawTypes, str): rawTypes = (rawTypes, ) if lowMem: if _can_load_periods(runs, defType, rawTypes): period = 1 else: period = _NO_INDIVIDUAL_PERIODS userEntry = runs[0] counter_run = 0 while True: isFirstDataSetEvent = False try: lastPath, lastFile, logFile, num_periods, isFirstDataSetEvent = _load_ws( userEntry, defType, inst, ADD_FILES_SUM_TEMPORARY, rawTypes, period) is_not_allowed_instrument = inst.upper() not in { 'SANS2D', 'LARMOR', 'ZOOM' } if is_not_allowed_instrument and isFirstDataSetEvent: error = 'Adding event data not supported for ' + inst + ' for now' print(error) sanslog.error(error) for workspaceName in (ADD_FILES_SUM_TEMPORARY, ADD_FILES_SUM_TEMPORARY_MONITORS): if workspaceName in mtd: DeleteWorkspace(workspaceName) return "" for i in range(len(runs) - 1): userEntry = runs[i + 1] lastPath, lastFile, logFile, dummy, is_data_set_event = _load_ws( userEntry, defType, inst, ADD_FILES_NEW_TEMPORARY, rawTypes, period) if is_data_set_event != isFirstDataSetEvent: error = 'Datasets added must be either ALL histogram data or ALL event data' print(error) sanslog.error(error) for workspaceName in (ADD_FILES_SUM_TEMPORARY, ADD_FILES_SUM_TEMPORARY_MONITORS, ADD_FILES_NEW_TEMPORARY, ADD_FILES_NEW_TEMPORARY_MONITORS): if workspaceName in mtd: DeleteWorkspace(workspaceName) return "" adder.add(LHS_workspace=ADD_FILES_SUM_TEMPORARY, RHS_workspace=ADD_FILES_NEW_TEMPORARY, output_workspace=ADD_FILES_SUM_TEMPORARY, run_to_add=counter_run, estimate_logs=estimate_logs) if isFirstDataSetEvent: adder.add( LHS_workspace=ADD_FILES_SUM_TEMPORARY_MONITORS, RHS_workspace=ADD_FILES_NEW_TEMPORARY_MONITORS, output_workspace=ADD_FILES_SUM_TEMPORARY_MONITORS, run_to_add=counter_run, estimate_logs=estimate_logs) DeleteWorkspace(ADD_FILES_NEW_TEMPORARY) if isFirstDataSetEvent: DeleteWorkspace(ADD_FILES_NEW_TEMPORARY_MONITORS) # Increment the run number counter_run += 1 except ValueError as e: error = "Error opening file {}: {}".format(userEntry, str(e)) print(error) sanslog.error(error) if ADD_FILES_SUM_TEMPORARY in mtd: DeleteWorkspace(ADD_FILES_SUM_TEMPORARY) return "" except Exception as e: # We need to catch all exceptions to ensure that a dialog box is raised with the error error = "Error finding files: {}".format(str(e)) print(error) sanslog.error(error) for workspaceName in (ADD_FILES_SUM_TEMPORARY, ADD_FILES_NEW_TEMPORARY): if workspaceName in mtd: DeleteWorkspace(workspaceName) return "" # In case of event file force it into a histogram workspace if this is requested if isFirstDataSetEvent and not saveAsEvent: handle_saving_event_workspace_when_saving_as_histogram( binning, runs, defType, inst) lastFile = os.path.splitext(lastFile)[0] # Now save the added file outFile = lastFile + '-add.' + 'nxs' if outFile is None else outFile outFile_monitors = lastFile + '-add_monitors.' + 'nxs' if outFile_monitors is None else outFile_monitors if save_directory is not None: # In ISIS SANS gui, an output directory can be specified. # If one has, add it to filepath here outFile = save_directory + outFile outFile_monitors = save_directory + outFile_monitors sanslog.notice("Writing file: {}".format(outFile)) if period == 1 or period == _NO_INDIVIDUAL_PERIODS: # Replace the file the first time around SaveNexusProcessed(InputWorkspace=ADD_FILES_SUM_TEMPORARY, Filename=outFile, Append=False) # If we are saving event data, then we need to save also the monitor file if isFirstDataSetEvent and saveAsEvent: SaveNexusProcessed( InputWorkspace=ADD_FILES_SUM_TEMPORARY_MONITORS, Filename=outFile_monitors, Append=False) else: # Then append SaveNexusProcessed(ADD_FILES_SUM_TEMPORARY, outFile, Append=True) if isFirstDataSetEvent and saveAsEvent: SaveNexusProcessed(ADD_FILES_SUM_TEMPORARY_MONITORS, outFile_monitors, Append=True) DeleteWorkspace(ADD_FILES_SUM_TEMPORARY) if isFirstDataSetEvent: DeleteWorkspace(ADD_FILES_SUM_TEMPORARY_MONITORS) if period == num_periods: break if period == _NO_INDIVIDUAL_PERIODS: break else: period += 1 if isFirstDataSetEvent and saveAsEvent: filename, ext = _make_filename(runs[0], defType, inst) workspace_type = get_workspace_type(filename) is_multi_period = True if workspace_type is WorkspaceType.MultiperiodEvent else False outFile = bundle_added_event_data_as_group(outFile, outFile_monitors, is_multi_period) # This adds the path to the filename path, base = os.path.split(outFile) if path == '' or base not in os.listdir(path): # Try the default save directory path_prefix = save_directory if save_directory else config[ "defaultsave.directory"] path = path_prefix + path # If the path is still an empty string check in the current working directory if path == '': path = os.getcwd() assert base in os.listdir(path) path_out = path if logFile: _copy_log(lastPath, logFile, path_out) return 'The following file has been created:\n' + outFile
def export_workspaces(ws_name_list): for ws_name in ws_name_list: SaveNexusProcessed(InputWorkspace=ws_name, Filename='/tmp/{}.nxs'.format(ws_name))
def PyExec(self): filenames = self._getLinearizedFilenames('Filename') self.filterBadPulses = self.getProperty('FilterBadPulses').value self.chunkSize = self.getProperty('MaxChunkSize').value self.absorption = self.getProperty('AbsorptionWorkspace').value self.charac = self.getProperty('Characterizations').value finalname = self.getPropertyValue('OutputWorkspace') useCaching = len(self.getProperty('CacheDir').value) > 0 # accumulate the unfocused workspace if it was requested # empty string means it is not used unfocusname = self.getPropertyValue('UnfocussedWorkspace') unfocusname_file = '' if len(unfocusname) > 0: unfocusname_file = '__{}_partial'.format(unfocusname) if useCaching: # unfocus check only matters if caching is requested if unfocusname != '': self.log().warning( 'CacheDir is specified with "UnfocussedWorkspace" - reading cache files disabled' ) else: self.log().warning( 'CacheDir is not specified - functionality disabled') self.prog_per_file = 1. / float( len(filenames)) # for better progress reporting # these are also passed into the child-algorithms self.kwargs = self.__getAlignAndFocusArgs() # outer loop creates chunks to load for (i, filename) in enumerate(filenames): # default name is based off of filename wkspname = os.path.split(filename)[-1].split('.')[0] if useCaching: self.__determineCharacterizations( filename, wkspname, True) # updates instance variable cachefile = self.__getCacheName(wkspname) else: cachefile = None wkspname += '_f%d' % i # add file number to be unique # if the unfocussed data is requested, don't read it from disk # because of the extra complication of the unfocussed workspace if useCaching and os.path.exists(cachefile) and unfocusname == '': LoadNexusProcessed(Filename=cachefile, OutputWorkspace=wkspname) # TODO LoadNexusProcessed has a bug. When it finds the # instrument name without xml it reads in from an IDF # in the instrument directory. editinstrargs = {} for name in PROPS_FOR_INSTR: prop = self.getProperty(name) if not prop.isDefault: editinstrargs[name] = prop.value if editinstrargs: EditInstrumentGeometry(Workspace=wkspname, **editinstrargs) else: self.__processFile(filename, wkspname, unfocusname_file, self.prog_per_file * float(i), not useCaching) # write out the cachefile for the main reduced data independent of whether # the unfocussed workspace was requested if useCaching: SaveNexusProcessed(InputWorkspace=wkspname, Filename=cachefile) # accumulate runs if i == 0: if wkspname != finalname: RenameWorkspace(InputWorkspace=wkspname, OutputWorkspace=finalname) if unfocusname != '': RenameWorkspace(InputWorkspace=unfocusname_file, OutputWorkspace=unfocusname) else: Plus(LHSWorkspace=finalname, RHSWorkspace=wkspname, OutputWorkspace=finalname, ClearRHSWorkspace=self.kwargs['PreserveEvents']) DeleteWorkspace(Workspace=wkspname) if unfocusname != '': Plus(LHSWorkspace=unfocusname, RHSWorkspace=unfocusname_file, OutputWorkspace=unfocusname, ClearRHSWorkspace=self.kwargs['PreserveEvents']) DeleteWorkspace(Workspace=unfocusname_file) if self.kwargs['PreserveEvents']: CompressEvents(InputWorkspace=finalname, OutputWorkspace=finalname) # not compressing unfocussed workspace because it is in d-spacing # and is likely to be from a different part of the instrument # with more than one chunk or file the integrated proton charge is # generically wrong mtd[finalname].run().integrateProtonCharge() # set the output workspace self.setProperty('OutputWorkspace', mtd[finalname]) if unfocusname != '': self.setProperty('UnfocussedWorkspace', mtd[unfocusname])
def save_workspace(workspace_name, filename): SaveNexusProcessed(InputWorkspace=workspace_name, Filename=filename, EnableLogging=False)
def __saveSummedGroupToCache(self, group, wkspname): cache_file = self.__getGroupCacheName(group) if not os.path.exists(cache_file): SaveNexusProcessed(InputWorkspace=wkspname, Filename=cache_file) return
def new_corelli_calibration( database_path: str, date: Optional[str] = None) -> Tuple[str, str, str]: r""" Generate a Corelli calibration set of files for a given day stamp, or for today if no day stamp is given. For each bank, this function will retrieve the calibration with an anterior date as close as possible to the given day stamp. The day stamp for the generated calibration will the most modern day stamp among the day stamps of all banks. The files to be produced are: - database_path/calibration_corelli_YYYYMMDD.nxs.h5 - database_path/mask_corelli_YYYYMMDD.nxs.h5 - database_path/manifest_corelli_YYYYMMDD.nxs.h5 Example: Assume today's date is 20201201 and we have a database with calibrations for two different days. Furthermore our instrument has only one bank, for simplicity. database_path/ |_bank001/ |_calibration_corelli_bank001_20200101.nxs.h5 (calibration in January) |_calibration_corelli_bank001_20206101.nxs.h5 (calibration in June) |_mask_corelli_bank0010_20200101.nxs.h5 |_mask_corelli_bank0010_20200601.nxs.h5 Invoking today new_corelli_calibration(database_path) will create the following files: - database_path/calibration_corelli_20206101.nxs.h5 - database_path/mask_corelli_20206101.nxs.h5 - database_path/manifest_corelli_20206101.nxs.h5 Notice the date of the files (20206101) is not today's date (20201201) but the most "modern" day-stamp in the database. Invoking today new_corelli_calibration(database_path, date=20200301) will create the following files: - database_path/calibration_corelli_20201101.nxs.h5 - database_path/mask_corelli_20201101.nxs.h5 - database_path/manifest_corelli_20201101.nxs.h5 The January files (20201101) are selected because we requested an instrument calibration with a date (20200301) prior to the June files. :param database_path: absolute path to the database containing the bank calibrations :param date: day stamp in format YYYYMMDD :return: absolute path to files containing the calibrated pixels, the masked pixels, and the manifest file, in this order. """ if date is None: date = datetime.now().strftime( '%Y%m%d') # today's date in YYYYMMDD format verify_date_format('new_corelli_calibration', date) file_paths = dict() for table_type in ('calibration', 'mask'): logger.notice( f'** Gathering {table_type} tables from individual banks') bank_tables, bank_stamps = combine_temporal_banks( database_path, date, table_type) if len(bank_stamps) == 0: logger.warning( f'No bank {table_type} files found with date < {date}') continue logger.notice( f'** Combining {table_type} tables from individual banks') table = combine_spatial_banks(bank_tables, table_type=table_type) bank_numbers, day_stamps = zip(*bank_stamps) last_day_stamp = sorted(day_stamps)[-1] filename = str( pathlib.Path(database_path) / f'{table_type}_corelli_{last_day_stamp}.nxs.h5') logger.notice(f'** Saving instrument {table_type} to the database') SaveNexusProcessed(InputWorkspace=table, Filename=filename) file_paths[table_type] = filename if table_type == 'calibration': logger.notice('** Creating and saving the manifest file') file_paths['manifest'] = save_manifest_file( database_path, bank_numbers, day_stamps, manifest_day_stamp=last_day_stamp) return [file_paths[x] for x in ('calibration', 'mask', 'manifest')]
def inner(*args, **kwargs): """ How caching name works """ # unpack key arguments wksp_name = args[0] abs_method = args[1] cache_dirs = kwargs.get("cache_dirs", []) prefix_name = kwargs.get("prefix_name", "") # prompt return if no cache_dirs specified if len(cache_dirs) == 0: return func(*args, **kwargs) # step_1: generate the SHA1 and cachefile name # baseon given kwargs cache_prefix = __get_instrument_name(wksp_name) cache_filenames, ascii_hash = __get_cache_name( wksp_name, abs_method, cache_dirs=cache_dirs, prefix_name=cache_prefix) # step_2: try load the cached data from disk found_sample, found_container, abs_wksp_sample, abs_wksp_container, cache_filename = __load_cached_data( cache_filenames, ascii_hash, abs_method=abs_method, prefix_name=prefix_name, ) # step_3: calculation if (abs_method == "SampleOnly") and found_sample: # Chen: why is this blowing things up? return abs_wksp_sample, "" else: if found_sample and found_container: # cache is available in memory now, skip calculation return abs_wksp_sample, abs_wksp_container else: # no cache found, need calculation log = Logger('calc_absorption_corr_using_wksp') if cache_filename: log.information(f"Storing cached data in {cache_filename}") abs_wksp_sample, abs_wksp_container = func(*args, **kwargs) # set SHA1 to workspace mtd[abs_wksp_sample].mutableRun()["absSHA1"] = ascii_hash if abs_wksp_container != "": mtd[abs_wksp_container].mutableRun( )["absSHA1"] = ascii_hash # save to disk SaveNexusProcessed(InputWorkspace=abs_wksp_sample, Filename=cache_filename) if abs_wksp_container != "": SaveNexusProcessed(InputWorkspace=abs_wksp_container, Filename=cache_filename, Append=True) return abs_wksp_sample, abs_wksp_container
def reduce(input_file, output_dir): ws = Load(input_file) file_name = os.path.join(output_dir, 'load-successful.nxs') SaveNexusProcessed(InputWorkspace=ws, Filename=file_name)