def _define_corrections(self): """ Defines all the corrections that are required """ self._correction_workspaces = list() if self._container_ws != "": container_name = str(self._correction_wsg) + "_Container" self._container_ws = ms.ExtractSingleSpectrum( InputWorkspace=self._container_ws, OutputWorkspace=container_name, WorkspaceIndex=self._spec_idx) self._correction_workspaces.append(self._container_ws.name()) # Do gamma correction if self.getProperty( "GammaBackground").value and not self._back_scattering: self._correction_workspaces.append(self._gamma_correction()) # Do multiple scattering correction if self.getProperty("MultipleScattering").value: self._correction_workspaces.extend(self._ms_correction()) # Output correction workspaces as a WorkspaceGroup if self._correction_wsg != "": ms.GroupWorkspaces(InputWorkspaces=self._correction_workspaces, OutputWorkspace=self._correction_wsg) self.setProperty("CorrectionWorkspaces", self._correction_wsg)
def split(focus): for i in range(Wish.NUM_PANELS): out = "{0}-{1}foc".format(focus[0:len(focus) - 3], i + 1) simple.ExtractSingleSpectrum(InputWorkspace=focus, OutputWorkspace=out, WorkspaceIndex=i) simple.DeleteWorkspace(focus)
def PyExec(self): # get parameter values wsString = self.getPropertyValue("InputWorkspace").strip() #internal values wsOutput = "__OutputWorkspace" wsTemp = "__Sort_temp" #get the workspace list wsNames = [] for wsName in wsString.split(","): ws = mtd[wsName.strip()] if isinstance(ws, WorkspaceGroup): wsNames.extend(ws.getNames()) else: wsNames.append(wsName) if wsOutput in mtd: ms.DeleteWorkspace(Workspace=wsOutput) sortStat = [] for wsName in wsNames: if "qvectors" in wsName: #extract the spectrum ws = mtd[wsName.strip()] for s in range(0, ws.getNumberHistograms()): y_s = ws.readY(s) stuple = (self.GetXValue(y_s), s) sortStat.append(stuple) sortStat.sort() if len(sortStat) == 0: raise RuntimeError("Cannot find file with qvectors, aborting") #sort spectra using norm of q for wsName in wsNames: ws = mtd[wsName.strip()] yUnit = ws.getAxis(1).getUnit().unitID() transposed = False if ws.getNumberHistograms() < len(sortStat): ms.Transpose(InputWorkspace=wsName, OutputWorkspace=wsName) transposed = True for norm, spec in sortStat: ms.ExtractSingleSpectrum(InputWorkspace=wsName, OutputWorkspace=wsTemp, WorkspaceIndex=spec) if wsOutput in mtd: ms.ConjoinWorkspaces(InputWorkspace1=wsOutput,InputWorkspace2=wsTemp,CheckOverlapping=False) if wsTemp in mtd: ms.DeleteWorkspace(Workspace=wsTemp) else: ms.RenameWorkspace(InputWorkspace=wsTemp, OutputWorkspace=wsOutput) #put norm as y value and copy units from input loopIndex = 0 wsOut = mtd[wsOutput] for norm, spec in sortStat: wsOut.getSpectrum(loopIndex).setSpectrumNo(int(norm*1000)) loopIndex = loopIndex + 1 if len(yUnit) > 0: wsOut.getAxis(1).setUnit(yUnit) if transposed: ms.Transpose(InputWorkspace=wsOutput, OutputWorkspace=wsOutput) ms.RenameWorkspace(InputWorkspace=wsOutput, OutputWorkspace=wsName)
def calc_calibration_without_vanadium(focused_ws, index, instrument): focus_spectrum = mantid.ExtractSingleSpectrum(InputWorkspace=focused_ws, WorkspaceIndex=index) focus_spectrum = mantid.ConvertUnits(InputWorkspace=focus_spectrum, Target="TOF") focus_spectrum = mantid.Rebin(InputWorkspace=focus_spectrum, Params=instrument.tof_binning) focus_calibrated = mantid.CropWorkspace(InputWorkspace=focus_spectrum, XMin=0.1) return focus_calibrated
def extract_single_spectrum(ws_to_process, spectrum_number_to_extract): """ Extracts the monitor spectrum into its own individual workspaces from the input workspace based on the number of the spectrum given :param ws_to_process: The workspace to extract the monitor from :param spectrum_number_to_extract: The spectrum of the workspace to extract :return: The extracted monitor as a workspace """ load_monitor_ws = mantid.ExtractSingleSpectrum(InputWorkspace=ws_to_process, WorkspaceIndex=spectrum_number_to_extract) return load_monitor_ws
def calc_calibration_with_vanadium(focused_ws, index, vanadium_ws, instrument): data_ws = mantid.ExtractSingleSpectrum(InputWorkspace=focused_ws, WorkspaceIndex=index) data_ws = mantid.ConvertUnits(InputWorkspace=data_ws, Target="TOF") data_ws = mantid.Rebin(InputWorkspace=data_ws, Params=instrument._get_focus_tof_binning()) data_processed = "van_processed" + str( index) # Workaround for Mantid overwriting the WS in a loop mantid.Divide(LHSWorkspace=data_ws, RHSWorkspace=vanadium_ws, OutputWorkspace=data_processed) mantid.CropWorkspace(InputWorkspace=data_processed, XMin=0.1, OutputWorkspace=data_processed) mantid.Scale(InputWorkspace=data_processed, Factor=10, OutputWorkspace=data_processed) remove_intermediate_workspace(data_ws) return data_processed
def PyExec(self): ms.ExtractSingleSpectrum(InputWorkspace=self._input_ws, OutputWorkspace=self._output_ws, WorkspaceIndex=self._spec_idx) # Performs corrections self._define_corrections() # The workspaces to fit for correction scale factors fit_corrections = [ wks for wks in self._correction_workspaces if 'MultipleScattering' not in wks ] # Perform fitting of corrections fixed_params = {} fixed_gamma_factor = self.getProperty("GammaBackgroundScale").value if fixed_gamma_factor != 0.0 and not self._back_scattering: fixed_params['GammaBackground'] = fixed_gamma_factor fixed_container_scale = self.getProperty("ContainerScale").value if fixed_container_scale != 0.0: fixed_params['Container'] = fixed_container_scale params_ws = self._fit_corrections(fit_corrections, self._linear_fit_table, **fixed_params) self.setProperty("LinearFitResult", params_ws) # Scale gamma background if self.getProperty( "GammaBackground").value and not self._back_scattering: gamma_correct_ws = self._get_correction_workspace( 'GammaBackground')[1] gamma_factor = self._get_correction_scale_factor( 'GammaBackground', fit_corrections, params_ws) ms.Scale(InputWorkspace=gamma_correct_ws, OutputWorkspace=gamma_correct_ws, Factor=gamma_factor) # Scale multiple scattering if self.getProperty("MultipleScattering").value: # Use factor of total scattering as this includes single and multiple scattering multi_scatter_correct_ws = self._get_correction_workspace( 'MultipleScattering')[1] total_scatter_correct_ws = self._get_correction_workspace( 'TotalScattering')[1] total_scatter_factor = self._get_correction_scale_factor( 'TotalScattering', fit_corrections, params_ws) ms.Scale(InputWorkspace=multi_scatter_correct_ws, OutputWorkspace=multi_scatter_correct_ws, Factor=total_scatter_factor) ms.Scale(InputWorkspace=total_scatter_correct_ws, OutputWorkspace=total_scatter_correct_ws, Factor=total_scatter_factor) # Scale by container if self._container_ws != "": container_correct_ws = self._get_correction_workspace( 'Container')[1] container_factor = self._get_correction_scale_factor( 'Container', fit_corrections, params_ws) ms.Scale(InputWorkspace=container_correct_ws, OutputWorkspace=container_correct_ws, Factor=container_factor) # Calculate and output corrected workspaces as a WorkspaceGroup if self._corrected_wsg != "": corrected_workspaces = [ ws_name.replace(self._correction_wsg, self._corrected_wsg) for ws_name in self._correction_workspaces ] for corrected, correction in zip(corrected_workspaces, self._correction_workspaces): ms.Minus(LHSWorkspace=self._output_ws, RHSWorkspace=correction, OutputWorkspace=corrected) ms.GroupWorkspaces(InputWorkspaces=corrected_workspaces, OutputWorkspace=self._corrected_wsg) self.setProperty("CorrectedWorkspaces", self._corrected_wsg) # Apply corrections for correction in self._correction_workspaces: if 'TotalScattering' not in correction: ms.Minus(LHSWorkspace=self._output_ws, RHSWorkspace=correction, OutputWorkspace=self._output_ws) self.setProperty("OutputWorkspace", self._output_ws) # Remove correction workspaces if they are no longer required if self._correction_wsg == "": for wksp in self._correction_workspaces: ms.DeleteWorkspace(wksp)
def process_incidentmon(self, number, extension, spline_terms=20): if type(number) is int: filename = self.get_file_name(number, extension) works = "monitor{}".format(number) shared_load_files(extension, filename, works, 4, 4, True) if extension[:9] == "nxs_event": temp = "w{}_monitors".format(number) works = "w{}_monitor4".format(number) simple.Rebin(InputWorkspace=temp, OutputWorkspace=temp, Params='6000,-0.00063,110000', PreserveEvents=False) simple.ExtractSingleSpectrum(InputWorkspace=temp, OutputWorkspace=works, WorkspaceIndex=3) else: num_1, num_2 = split_run_string(number) works = "monitor{0}_{1}".format(num_1, num_2) filename = self.get_file_name(num_1, extension) works1 = "monitor{}".format(num_1) simple.LoadRaw(Filename=filename, OutputWorkspace=works1, SpectrumMin=4, SpectrumMax=4, LoadLogFiles="0") filename = self.get_file_name(num_2, extension) works2 = "monitor{}".format(num_2) simple.LoadRaw(Filename=filename, OutputWorkspace=works2, SpectrumMin=4, SpectrumMax=4, LoadLogFiles="0") simple.MergeRuns(InputWorkspaces=works1 + "," + works2, OutputWorkspace=works) simple.DeleteWorkspace(works1) simple.DeleteWorkspace(works2) simple.ConvertUnits(InputWorkspace=works, OutputWorkspace=works, Target="Wavelength", Emode="Elastic") lambda_min, lambda_max = Wish.LAMBDA_RANGE simple.CropWorkspace(InputWorkspace=works, OutputWorkspace=works, XMin=lambda_min, XMax=lambda_max) ex_regions = np.array([[4.57, 4.76], [3.87, 4.12], [2.75, 2.91], [2.24, 2.50]]) simple.ConvertToDistribution(works) for reg in range(0, 4): simple.MaskBins(InputWorkspace=works, OutputWorkspace=works, XMin=ex_regions[reg, 0], XMax=ex_regions[reg, 1]) simple.SplineBackground(InputWorkspace=works, OutputWorkspace=works, WorkspaceIndex=0, NCoeff=spline_terms) simple.SmoothData(InputWorkspace=works, OutputWorkspace=works, NPoints=40) simple.ConvertFromDistribution(works) return works