def _focus_mode_trans(output_file_paths, atten, instrument, calibrated_spectra): summed_ws = mantid.CloneWorkspace(InputWorkspace=calibrated_spectra[0]) for i in range(1, 9): # Add workspaces 2-9 to workspace 1 summed_ws = mantid.Plus(LHSWorkspace=summed_ws, RHSWorkspace=calibrated_spectra[i]) summed_ws = mantid.Scale(InputWorkspace=summed_ws, Factor=0.111111111111111) if atten: # Clone a workspace which is not attenuated no_att = output_file_paths["output_name"] + "_noatten" mantid.CloneWorkspace(InputWorkspace=summed_ws, OutputWorkspace=no_att) summed_ws = mantid.ConvertUnits(InputWorkspace=summed_ws, Target="dSpacing") summed_ws = instrument._attenuate_workspace(summed_ws) summed_ws = mantid.ConvertUnits(InputWorkspace=summed_ws, Target="TOF") mantid.SaveGSS(InputWorkspace=summed_ws, Filename=output_file_paths["gss_filename"], Append=False, Bank=1) mantid.SaveFocusedXYE(InputWorkspace=summed_ws, Filename=output_file_paths["tof_xye_filename"], Append=False, IncludeHeader=False) summed_ws = mantid.ConvertUnits(InputWorkspace=summed_ws, Target="dSpacing") # Rename to user friendly name: summed_ws_name = output_file_paths["output_name"] + "_mods1-9" summed_ws = mantid.RenameWorkspace(InputWorkspace=summed_ws, OutputWorkspace=summed_ws_name) mantid.SaveFocusedXYE(InputWorkspace=summed_ws, Filename=output_file_paths["dspacing_xye_filename"], Append=False, IncludeHeader=False) mantid.SaveNexus(InputWorkspace=summed_ws, Filename=output_file_paths["nxs_filename"], Append=False) output_list = [summed_ws] for i in range(0, 9): workspace_name = output_file_paths["output_name"] + "_mod" + str(i + 1) to_save = mantid.ConvertUnits(InputWorkspace=calibrated_spectra[i], Target="dSpacing", OutputWorkspace=workspace_name) output_list.append(to_save) mantid.SaveNexus(Filename=output_file_paths["nxs_filename"], InputWorkspace=to_save, Append=True) return output_list
def _focus_mode_trans(output_file_paths, attenuation_filepath, calibrated_spectra): summed_ws = mantid.MergeRuns(InputWorkspaces=calibrated_spectra[:9]) xList = summed_ws.readX(0) summed_ws = mantid.CropWorkspace(InputWorkspace=summed_ws, XMin=xList[1], Xmax=xList[-2]) summed_ws = mantid.Scale(InputWorkspace=summed_ws, Factor=0.111111111111111) if attenuation_filepath: summed_ws = _attenuate_workspace( output_file_paths=output_file_paths, attenuated_ws=summed_ws, attenuation_filepath=attenuation_filepath) summed_ws = mantid.ConvertUnits(InputWorkspace=summed_ws, Target="TOF") mantid.SaveGSS(InputWorkspace=summed_ws, Filename=output_file_paths["gss_filename"], Append=False, Bank=1) mantid.SaveFocusedXYE(InputWorkspace=summed_ws, Filename=output_file_paths["tof_xye_filename"], Append=False, IncludeHeader=False) summed_ws = mantid.ConvertUnits(InputWorkspace=summed_ws, Target="dSpacing") # Rename to user friendly name: summed_ws_name = output_file_paths["output_name"] + "_mods1-9" summed_ws = mantid.RenameWorkspace(InputWorkspace=summed_ws, OutputWorkspace=summed_ws_name) mantid.SaveFocusedXYE(InputWorkspace=summed_ws, Filename=output_file_paths["dspacing_xye_filename"], Append=False, IncludeHeader=False) mantid.SaveNexus(InputWorkspace=summed_ws, Filename=output_file_paths["nxs_filename"], Append=False) output_list = [summed_ws] for i in range(0, 9): workspace_name = output_file_paths["output_name"] + "_mod" + str(i + 1) to_save = mantid.ConvertUnits(InputWorkspace=calibrated_spectra[i], Target="dSpacing", OutputWorkspace=workspace_name) output_list.append(to_save) mantid.SaveNexus(Filename=output_file_paths["nxs_filename"], InputWorkspace=to_save, Append=True) return output_list
def _focus_mode_mods(output_file_paths, calibrated_spectra): append = False output_list = [] for index, ws in enumerate(calibrated_spectra): output_name = output_file_paths["output_name"] + "_mod" + str(index + 1) tof_ws = mantid.ConvertUnits(InputWorkspace=ws, OutputWorkspace=output_name, Target=WORKSPACE_UNITS.tof) mantid.SaveFocusedXYE(InputWorkspace=tof_ws, Filename=output_file_paths["tof_xye_filename"], Append=False, IncludeHeader=False) mantid.SaveGSS(InputWorkspace=tof_ws, Filename=output_file_paths["gss_filename"], Append=append, Bank=index + 1) dspacing_ws = mantid.ConvertUnits(InputWorkspace=ws, OutputWorkspace=output_name, Target=WORKSPACE_UNITS.d_spacing) output_list.append(dspacing_ws) mantid.SaveNexus(Filename=output_file_paths["nxs_filename"], InputWorkspace=dspacing_ws, Append=append) append = True return output_list
def _build_gsas2_reader_with_data(self, gs2, gs2_focused_wks): """ Build an "rd" GSAS-II data structure with reader, and importantly the rd.powderdata list with the histogram data. @param gs2_focused_wks :: a workspace with a histogram from focused data @return an "rd" object as used in GSAS-II, with histogram data in the 'powderdata' data member """ # produce histo_file, to "import" it with the reader from GSAS-II which will initialize # the "rd" object. import tempfile with tempfile.NamedTemporaryFile(mode='w', suffix='.xye', delete=False) as histo_data_tmp: # SplitFiles=False is important to get the filename without suffix msapi.SaveFocusedXYE(InputWorkspace=gs2_focused_wks, Filename=histo_data_tmp.name, Format="XYE", SplitFiles=False) gs2_rd = self._get_histo_data_reader(gs2, histo_data_tmp.name) gs2_rd.powderdata = self._transform_to_centers_bins(gs2_rd.powderdata) if not isinstance(gs2_rd.powderdata, list): raise ValueError('rd.powderdata is not a list of array as expected') return gs2_rd
def _save_out(run_number, focus_directory, focus_general, output, enginx_file_name_format, bank_id): """ save out the files required for the focus @param run_number :: the run number of the focused run @param focus_directory :: the user directory to save to @param focus_general :: the general folder to copy the saved out files to @param output :: the workspace to save @param enginx_file_name_format :: the naming scheme of the files @param bank_id :: the bank being saved """ # work out where to save the files dat_name, genie_filename, gss_name, hdf5_name, nxs_name = _find_focus_file_location(bank_id, focus_directory, enginx_file_name_format, run_number) if not str(bank_id).isnumeric(): bank_id = 0 # save the files out to the user directory simple.SaveFocusedXYE(InputWorkspace=output, Filename=dat_name, SplitFiles=False, StartAtBankNumber=bank_id) simple.SaveGSS(InputWorkspace=output, Filename=gss_name, SplitFiles=False, Bank=bank_id) simple.SaveOpenGenieAscii(InputWorkspace=output, Filename=genie_filename, OpenGenieFormat="ENGIN-X Format") simple.SaveNexus(InputWorkspace=output, Filename=nxs_name) simple.ExportSampleLogsToHDF5(InputWorkspace=output, Filename=hdf5_name, Blacklist="bankid") if not focus_general == focus_directory: if not os.path.exists(focus_general): os.makedirs(focus_general) # copy the files to the general directory copy2(dat_name, focus_general) copy2(gss_name, focus_general) copy2(genie_filename, focus_general) copy2(nxs_name, focus_general) copy2(hdf5_name, focus_general)
def save_combined_panel(self, run, panel): panel_combination = {5: 6, 4: 7, 3: 8, 2: 9, 1: 10} input_ws1 = "w{0}-{1}foc".format(run, panel) input_ws2 = "w{0}-{1}foc".format(run, panel_combination.get(panel)) combined = "{0}{1}-{2}_{3}foc{4}".format("{0}", run, panel, panel_combination.get(panel), "{1}") combined_save = combined.format("", "{}") combined_ws = combined.format("w", "") simple.RebinToWorkspace(WorkspaceToRebin=input_ws2, WorkspaceToMatch=input_ws1, OutputWorkspace=input_ws2, PreserveEvents='0') simple.Plus(LHSWorkspace=input_ws1, RHSWorkspace=input_ws2, OutputWorkspace=combined_ws) simple.ConvertUnits(InputWorkspace=combined_ws, OutputWorkspace=combined_ws + "-d", Target="dSpacing", EMode="Elastic") simple.SaveGSS(combined_ws, os.path.join(self.user_directory, combined_save.format("raw.gss")), Append=False, Bank=1) simple.SaveFocusedXYE( combined_ws, os.path.join(self.user_directory, combined_save.format("raw.dat"))) simple.SaveNexusProcessed( combined_ws, os.path.join(self.user_directory, combined_save.format("raw.nxs")))
def savePDFile(self, exp, scan, filetype, sfilename): """ Save a reduced workspace to gsas/fullprof/topaz data file """ # get workspace wsmanager = self.getWorkspace(exp, scan, raiseexception=True) if wsmanager.reducedws is None: raise NotImplementedError( "Unable to rebin the data for exp=%d, scan=%d because \ either data MD workspace and monitor MD workspace is not present." % (exp, scan)) else: wksp = wsmanager.reducedws # save filetype = filetype.lower() if "gsas" in filetype: if sfilename.endswith('.dat') is True: sfilename.replace('.dat', '.gsa') api.SaveGSS(InputWorkspace=wksp, Filename=sfilename, SplitFiles=False, Append=False, MultiplyByBinWidth=False, Bank=1, Format="SLOG", ExtendedHeader=True) # ENDIF if "fullprof" in filetype: if sfilename.endswith('.gsa') is True: sfilename.replace('.gsa', '.dat') api.SaveFocusedXYE(InputWorkspace=wksp, StartAtBankNumber=1, Filename=sfilename) # ENDIF if "topas" in filetype: sfilename = sfilename[:-4] + ".xye" api.SaveFocusedXYE(InputWorkspace=wksp, StartAtBankNumber=info["bank"], Filename=sfilename, Format="TOPAS") # ENDIF return
def save_maud(d_spacing_group, output_path): for i, ws in enumerate(d_spacing_group): mantid.SaveFocusedXYE(InputWorkspace=ws, Filename=output_path, SplitFiles=False, StartAtBankNumber=i, Append=i > 0, IncludeHeader=True, Format="MAUD")
def _save_output_files(focus_dirs, sample_ws_foc, calibration, van_run, rb_num=None): # set bankid for use in fit tab foc_suffix = calibration.get_foc_ws_suffix() xunit = sample_ws_foc.getDimension(0).name xunit_suffix = XUNIT_SUFFIXES[xunit] sample_run_no = sample_ws_foc.run().get('run_number').value # save all spectra to single ASCII files ascii_fname = _generate_output_file_name(calibration.get_instrument(), sample_run_no, van_run, calibration.get_group_suffix(), xunit_suffix, ext='') for focus_dir in focus_dirs: if not path.exists(focus_dir): makedirs(focus_dir) mantid.SaveGSS(InputWorkspace=sample_ws_foc, Filename=path.join(focus_dir, ascii_fname + '.gss'), SplitFiles=False, UseSpectrumNumberAsBankID=True) mantid.SaveFocusedXYE(InputWorkspace=sample_ws_foc, Filename=path.join(focus_dir, ascii_fname + ".abc"), SplitFiles=False, Format="TOPAS") # Save nxs per spectrum nxs_paths = [] mantid.AddSampleLog(Workspace=sample_ws_foc, LogName="Vanadium Run", LogText=van_run) for ispec in range(sample_ws_foc.getNumberHistograms()): # add a bankid and vanadium to log that is read by fitting model bankid = foc_suffix if sample_ws_foc.getNumberHistograms( ) == 1 else f'{foc_suffix}_{ispec + 1}' mantid.AddSampleLog(Workspace=sample_ws_foc, LogName="bankid", LogText=bankid.replace('_', ' ')) # overwrites # save spectrum as nexus filename = _generate_output_file_name(calibration.get_instrument(), sample_run_no, van_run, bankid, xunit_suffix, ext=".nxs") nxs_path = path.join(focus_dir, filename) mantid.SaveNexus(InputWorkspace=sample_ws_foc, Filename=nxs_path, WorkspaceIndexList=[ispec]) nxs_paths.append(nxs_path) return nxs_paths # from last focus_dir only
def saveMergedScan(self, sfilename, mergeindex): """ Save the current merged scan """ if self._myMergedWSDict.has_key(mergeindex) is True: wksp = self._myMergedWSDict[mergeindex] else: raise NotImplementedError( 'Unable to locate the merged scan workspace.') api.SaveFocusedXYE(InputWorkspace=wksp, StartAtBankNumber=1, Filename=sfilename) return
def _save_temporary_fxye(self, spectrum): """ Create a temporary fxye file for GSAS to read the spectrum from. This is required as we cannot pass a workspace straight to GSASIIscriptable, but rather it must be read from a file :param spectrum: The spectrum to save :return: Fully qualified path to the new file """ workspace_index = self.getPropertyValue(self.PROP_WORKSPACE_INDEX) temp_dir = tempfile.gettempdir() # Output file MUST end with "-n.fxye" where n is a number # If you see "Runtime error: Rvals" from GSASIIscriptable.py, it may be because this name is badly formatted file_path = os.path.join(temp_dir, "{}_focused_spectrum-{}.fxye".format(self.name(), workspace_index)) mantid.SaveFocusedXYE(Filename=file_path, InputWorkspace=spectrum, SplitFiles=False, IncludeHeader=False) return file_path
def _save_xye(ws_group, filename_template): """ Saves XYE data into .dat files. This expects the .dat folder to be created and passed. It saves the specified group with the specified units into a file whose name contains that information. :param ws_group: The workspace group to save out to .dat files :param filename_template: A string containing a fullpath with a string format template {bankno} to denote where the bank number should be inserted """ for bank_index, ws in enumerate(ws_group): bank_index += 1 # Ensure we start a 1 when saving out mantid.SaveFocusedXYE( InputWorkspace=ws, Filename=filename_template.format(bankno=bank_index), SplitFiles=False, IncludeHeader=False)
def saveProcessedVanadium(self, expno, scanno, savefilename): """ Save processed vanadium data """ # Get workspace wsmanager = self.getWorkspace(expno, scanno, raiseexception=True) if wsmanager.isSmoothApplied() is True: wksp = wsmanager.getProcessedVanadiumWSTemp() else: wksp = wsmanager.getProcessedVanadiumWS() # Save api.SaveFocusedXYE(InputWorkspace=wksp, StartAtBankNumber=1, Filename=savefilename) return
def _save_out(run_number, focus_directory, focus_general, output, join_string, bank_id): """ save out the files required for the focus @param run_number :: the run number of the focused run @param focus_directory :: the user directory to save to @param focus_general :: the general folder to copy the saved out files to @param output :: the workspace to save @param join_string :: the nameing scheme of the files @param bank_id :: the bank being saved """ # work out where to save the files filename = os.path.join(focus_directory, join_string.format(run_number, bank_id)) hdf5_name = os.path.join(focus_directory, run_number + ".hdf5") if not unicode(bank_id).isnumeric(): bank_id = 0 # save the files out to the user directory simple.SaveFocusedXYE(InputWorkspace=output, Filename=filename + ".dat", SplitFiles=False, StartAtBankNumber=bank_id) simple.SaveGSS(InputWorkspace=output, Filename=filename + ".gss", SplitFiles=False, Bank=bank_id) simple.SaveOpenGenieAscii(InputWorkspace=output, Filename=filename + ".his", OpenGenieFormat="ENGIN-X Format") simple.SaveNexus(InputWorkspace=output, Filename=filename + ".nxs") simple.ExportSampleLogsToHDF5(InputWorkspace=output, Filename=hdf5_name, Blacklist="bankid") if not focus_general == focus_directory: if not os.path.exists(focus_general): os.makedirs(focus_general) # copy the files to the general directory copy2(filename + ".dat", focus_general) copy2(filename + ".gss", focus_general) copy2(filename + ".his", focus_general) copy2(filename + ".nxs", focus_general) copy2(hdf5_name, focus_general)
def _save_xye(ws_group, ws_units, run_number, output_folder, inst_prefix, file_ext): """ Saves XYE data into .dat files. This expects the .dat folder to be created and passed. It saves the specified group with the specified units into a file whose name contains that information. :param ws_group: The workspace group to save out to .dat files :param ws_units: The units of all workspaces in that group :param run_number: The run number string to use when generating the filename :param output_folder: The output folder to save these files to :param inst_prefix: The prefix of the instrument to generate the filename :return: """ prefix_filename = str(inst_prefix) + str(run_number) for bank_index, ws in enumerate(ws_group): bank_index += 1 # Ensure we start a 1 when saving out outfile_name = file_ext + prefix_filename + "-b_" + str(bank_index) + "-" + ws_units + ".dat" full_file_path = os.path.join(output_folder, outfile_name) mantid.SaveFocusedXYE(InputWorkspace=ws, Filename=full_file_path, SplitFiles=False, IncludeHeader=False)
def process_run(self, number, panel, extension, cycle_vana="09_4", absorb=False, number_density=0.0, scattering=0.0, attenuation=0.0, height=0.0, radius=0.0): ws_to_focus = self.read(number, panel, extension) if absorb: absorption_corrections(attenuation, height, number_density, radius, scattering, ws_to_focus) focused_ws = self.focus(ws_to_focus, panel) panel_crop = { 1: (0.8, 53.3), 2: (0.5, 13.1), 3: (0.5, 7.77), 4: (0.4, 5.86), 5: (0.35, 4.99), 6: (0.35, 4.99), 7: (0.4, 5.86), 8: (0.5, 7.77), 9: (0.5, 13.1), 10: (0.8, 53.3) } d_min, d_max = panel_crop.get(panel) simple.CropWorkspace(InputWorkspace=focused_ws, OutputWorkspace=focused_ws, XMin=d_min, XMax=d_max) save_location = os.path.join(self.user_directory, "{0}-{1}{2}.{3}") if panel == 0: for panel_i in range(Wish.NUM_PANELS): focused_ws = "w{0}-{1}foc".format(number, panel_i) simple.CropWorkspace(InputWorkspace=focused_ws, OutputWorkspace=focused_ws, XMin=d_min, XMax=d_max) logger.notice( "will try to load a vanadium with the name: {}".format( self.get_vanadium(panel_i, cycle_vana))) self.apply_vanadium_corrections(cycle_vana, panel_i, focused_ws) simple.SaveGSS(InputWorkspace=focused_ws, Filename=save_location.format( number, panel_i, extension, "gss"), Append=False, Bank=1) simple.SaveFocusedXYE( focused_ws, save_location.format(number, panel_i, extension, "dat")) simple.SaveNexusProcessed( focused_ws, save_location.format(number, panel_i, extension, "nxs")) else: logger.notice( "will try to load a vanadium with the name: {}".format( self.get_vanadium(panel, cycle_vana))) self.apply_vanadium_corrections(cycle_vana, panel, focused_ws) simple.SaveGSS(InputWorkspace=focused_ws, Filename=save_location.format( number, panel, extension, "gss"), Append=False, Bank=1) simple.SaveFocusedXYE( focused_ws, save_location.format(number, panel, extension, "dat")) simple.SaveNexusProcessed( focused_ws, save_location.format(number, panel, extension, "nxs")) return focused_ws
def _focus_mode_all(output_file_paths, processed_spectra, attenuation_filepath): summed_spectra_name = output_file_paths["output_name"] + "_mods1-9" summed_spectra = mantid.MergeRuns(InputWorkspaces=processed_spectra[:9], OutputWorkspace=summed_spectra_name) xList = summed_spectra.readX(0) summed_spectra = mantid.CropWorkspace(InputWorkspace=summed_spectra, XMin=xList[1], Xmax=xList[-2]) summed_spectra = mantid.Scale(InputWorkspace=summed_spectra, Factor=0.111111111111111, OutputWorkspace=summed_spectra_name) if attenuation_filepath: summed_spectra = _attenuate_workspace( output_file_paths=output_file_paths, attenuated_ws=summed_spectra, attenuation_filepath=attenuation_filepath) summed_spectra = mantid.ConvertUnits(InputWorkspace=summed_spectra, Target="TOF", OutputWorkspace=summed_spectra_name) mantid.SaveGSS(InputWorkspace=summed_spectra, Filename=output_file_paths["gss_filename"], Append=False, Bank=1) summed_spectra = mantid.ConvertUnits(InputWorkspace=summed_spectra, Target="dSpacing", OutputWorkspace=summed_spectra_name) mantid.SaveNexus(Filename=output_file_paths["nxs_filename"], InputWorkspace=summed_spectra, Append=False) mantid.SaveFocusedXYE(InputWorkspace=summed_spectra_name, Filename=output_file_paths["tof_xye_filename"], Append=False, IncludeHeader=False) output_list = [summed_spectra] for i in range(0, 5): spectra_index = (i + 9) # Compensate for 0 based index ws_to_save = processed_spectra[ spectra_index] # Save out workspaces 10/11/12 output_name = output_file_paths["output_name"] + "_mod" + str( spectra_index + 1) ws_to_save = mantid.ConvertUnits(InputWorkspace=ws_to_save, OutputWorkspace=ws_to_save, Target="TOF") mantid.SaveGSS(InputWorkspace=ws_to_save, Filename=output_file_paths["gss_filename"], Append=True, Bank=i + 2) splits = output_file_paths["tof_xye_filename"].split(".") tof_xye_name = splits[0] + "-" + str(i + 10) + "." + splits[1] mantid.SaveFocusedXYE(InputWorkspace=ws_to_save, Filename=tof_xye_name, Append=False, IncludeHeader=False) ws_to_save = mantid.ConvertUnits(InputWorkspace=ws_to_save, OutputWorkspace=output_name, Target="dSpacing") mantid.SaveNexus(Filename=output_file_paths["nxs_filename"], InputWorkspace=ws_to_save, Append=True) output_list.append(ws_to_save) return output_list
def _focus_mode_groups(output_file_paths, calibrated_spectra): output_list = [] to_save = _sum_groups_of_three_ws(calibrated_spectra=calibrated_spectra, output_file_names=output_file_paths) workspaces_4_to_9_name = output_file_paths["output_name"] + "_mods4-9" workspaces_4_to_9 = mantid.MergeRuns( InputWorkspaces=calibrated_spectra[3:9], OutputWorkspace=workspaces_4_to_9_name) xList = workspaces_4_to_9.readX(0) workspaces_4_to_9 = mantid.CropWorkspace(InputWorkspace=workspaces_4_to_9, XMin=xList[1], Xmax=xList[-2]) workspaces_4_to_9 = mantid.Scale(InputWorkspace=workspaces_4_to_9, Factor=0.5, OutputWorkspace=workspaces_4_to_9_name) to_save.append(workspaces_4_to_9) append = False index = 1 for ws in to_save: ws = mantid.ConvertUnits(InputWorkspace=ws, OutputWorkspace=ws, Target="TOF") mantid.SaveGSS(InputWorkspace=ws, Filename=output_file_paths["gss_filename"], Append=False, Bank=index) mantid.SaveFocusedXYE(InputWorkspace=ws, Filename=output_file_paths["tof_xye_filename"], Append=False, IncludeHeader=False) workspace_names = ws.name() ws = mantid.ConvertUnits(InputWorkspace=ws, OutputWorkspace=workspace_names, Target="dSpacing") output_list.append(ws) mantid.SaveNexus(Filename=output_file_paths["nxs_filename"], InputWorkspace=ws, Append=append) append = True index += 1 save_range = 5 for i in range(0, save_range): monitor_ws_name = output_file_paths["output_name"] + "_mod" + str(i + 10) monitor_ws = calibrated_spectra[i + 9] to_save = mantid.CloneWorkspace(InputWorkspace=monitor_ws, OutputWorkspace=monitor_ws_name) to_save = mantid.ConvertUnits(InputWorkspace=to_save, OutputWorkspace=to_save, Target="TOF") splits = output_file_paths["tof_xye_filename"].split(".") tof_xye_name = splits[0] + "-" + str(i + 10) + "." + splits[1] mantid.SaveGSS(InputWorkspace=to_save, Filename=output_file_paths["gss_filename"], Append=True, Bank=i + 5) mantid.SaveFocusedXYE(InputWorkspace=to_save, Filename=tof_xye_name, Append=False, IncludeHeader=False) to_save = mantid.ConvertUnits(InputWorkspace=to_save, OutputWorkspace=monitor_ws_name, Target="dSpacing") mantid.SaveNexus(Filename=output_file_paths["nxs_filename"], InputWorkspace=to_save, Append=True) output_list.append(to_save) return output_list