def _spline_old_background(in_workspace): van_stripped = mantid.ConvertUnits(InputWorkspace=in_workspace, Target="dSpacing") # remove bragg peaks before spline van_stripped = mantid.StripPeaks(InputWorkspace=van_stripped, FWHM=15, Tolerance=6, WorkspaceIndex=0) van_stripped = mantid.StripPeaks(InputWorkspace=van_stripped, FWHM=15, Tolerance=6, WorkspaceIndex=2) van_stripped = mantid.StripPeaks(InputWorkspace=van_stripped, FWHM=15, Tolerance=6, WorkspaceIndex=3) van_stripped = mantid.StripPeaks(InputWorkspace=van_stripped, FWHM=40, Tolerance=12, WorkspaceIndex=1) van_stripped = mantid.StripPeaks(InputWorkspace=van_stripped, FWHM=60, Tolerance=12, WorkspaceIndex=1) # Mask low d region that is zero before spline for reg in range(0, 4): if reg == 1: van_stripped = mantid.MaskBins(InputWorkspace=van_stripped, XMin=0, XMax=0.14, SpectraList=reg) else: van_stripped = mantid.MaskBins(InputWorkspace=van_stripped, XMin=0, XMax=0.06, SpectraList=reg) van_stripped = mantid.ConvertUnits(InputWorkspace=van_stripped, Target="TOF") splined_ws_list = [] for i in range(0, 4): out_ws_name = "spline" + str(i+1) if i == 1: coeff = 80 else: coeff = 100 splined_ws_list.append(mantid.SplineBackground(InputWorkspace=van_stripped, OutputWorkspace=out_ws_name, WorkspaceIndex=i, NCoeff=coeff)) common.remove_intermediate_workspace(van_stripped) return splined_ws_list
def normalise_ws_current(ws_to_correct, monitor_ws, spline_coeff, lambda_values, integration_range, ex_regions): processed_monitor_ws = mantid.ConvertUnits(InputWorkspace=monitor_ws, Target="Wavelength") processed_monitor_ws = mantid.CropWorkspace(InputWorkspace=processed_monitor_ws, XMin=lambda_values[0], XMax=lambda_values[-1]) for reg in range(0, 4): processed_monitor_ws = mantid.MaskBins(InputWorkspace=processed_monitor_ws, XMin=ex_regions[0, reg], XMax=ex_regions[1, reg]) splined_monitor_ws = mantid.SplineBackground(InputWorkspace=processed_monitor_ws, WorkspaceIndex=0, NCoeff=spline_coeff) normalised_ws = mantid.ConvertUnits(InputWorkspace=ws_to_correct, Target="Wavelength", OutputWorkspace=ws_to_correct) normalised_ws = mantid.NormaliseToMonitor(InputWorkspace=normalised_ws, MonitorWorkspace=splined_monitor_ws, IntegrationRangeMin=integration_range[0], IntegrationRangeMax=integration_range[-1], OutputWorkspace=normalised_ws) normalised_ws = mantid.ConvertUnits(InputWorkspace=normalised_ws, Target="TOF", OutputWorkspace=normalised_ws) common.remove_intermediate_workspace(processed_monitor_ws) common.remove_intermediate_workspace(splined_monitor_ws) return normalised_ws
def _mask_prompt_pulse(workspace, middle, left_crop, right_crop): min_crop = middle - left_crop max_crop = middle + right_crop mantid.MaskBins(InputWorkspace=workspace, OutputWorkspace=workspace, XMin=min_crop, XMax=max_crop)
def _apply_bragg_peaks_masking(workspaces_to_mask, mask_list): output_workspaces = list(workspaces_to_mask) for ws_index, (bank_mask_list, workspace) in enumerate(zip(mask_list, output_workspaces)): output_name = "masked_vanadium-" + str(ws_index + 1) for mask_params in bank_mask_list: output_workspaces[ws_index] = mantid.MaskBins(InputWorkspace=output_workspaces[ws_index], OutputWorkspace=output_name, XMin=mask_params[0], XMax=mask_params[1]) return output_workspaces
def _mask_prompt_pulses(self, ws): left_crop = 30 right_crop = 140 for i in range(6): middle = 100000 + 20000 * i min_crop = middle - left_crop max_crop = middle + right_crop mantid.MaskBins(InputWorkspace=ws, OutputWorkspace=ws, XMin=min_crop, XMax=max_crop)
def _mask_bins_and_spectra(ws, xmin, xmax, num_spectra, indices=None): import mantid.simpleapi as mantid masked_ws = mantid.MaskBins(ws, XMin=xmin, XMax=xmax, InputWorkspaceIndexSet=indices) # mask the first 3 spectra for i in range(num_spectra): masked_ws.spectrumInfo().setMasked(i, True) return masked_ws
def _mask_prompt_pulses(self, ws): left_crop = 30 right_crop = 140 pulse_interval = 20000 for i in range(1, 6): middle = i * pulse_interval min_crop = middle - left_crop max_crop = middle + right_crop mantid.MaskBins(InputWorkspace=ws, OutputWorkspace=ws, XMin=min_crop, XMax=max_crop)
def read_event_nexus(self, number, output, panel): simple.RenameWorkspace("{}_monitors".format(output), "w{}_monitors".format(number)) simple.Rebin(InputWorkspace=output, OutputWorkspace=output, Params='6000,-0.00063,110000') simple.ConvertToMatrixWorkspace(output, output) spectra_min, spectra_max = self.return_panel.get(panel) simple.CropWorkspace(InputWorkspace=output, OutputWorkspace=output, StartWorkspaceIndex=spectra_min - 6, EndWorkspaceIndex=spectra_max - 6) simple.MaskBins(InputWorkspace=output, OutputWorkspace=output, XMin=99900, XMax=106000)
def apply_bragg_peaks_masking(workspaces_to_mask, mask_list): """ Mask a series of peaks defined by the lower/upper bounds :param workspaces_to_mask: Mask these workspaces :param mask_list: A list of pairs of peak X min/max for masking :return: A list of masked workspaces """ output_workspaces = list(workspaces_to_mask) for ws_index, (bank_mask_list, workspace) in enumerate(zip(mask_list, output_workspaces)): output_name = "masked_vanadium-" + str(ws_index + 1) for mask_params in bank_mask_list: output_workspaces[ws_index] = mantid.MaskBins(InputWorkspace=output_workspaces[ws_index], OutputWorkspace=output_name, XMin=mask_params[0], XMax=mask_params[1]) return output_workspaces
def normalise_ws_current(ws_to_correct, monitor_ws, spline_coeff, lambda_values, integration_range): processed_monitor_ws = mantid.ConvertUnits(InputWorkspace=monitor_ws, Target="Wavelength") processed_monitor_ws = mantid.CropWorkspace( InputWorkspace=processed_monitor_ws, XMin=lambda_values[0], XMax=lambda_values[-1]) # TODO move these masks to the adv. config file ex_regions = numpy.zeros((2, 4)) ex_regions[:, 0] = [3.45, 3.7] ex_regions[:, 1] = [2.96, 3.2] ex_regions[:, 2] = [2.1, 2.26] ex_regions[:, 3] = [1.73, 1.98] for reg in range(0, 4): processed_monitor_ws = mantid.MaskBins( InputWorkspace=processed_monitor_ws, XMin=ex_regions[0, reg], XMax=ex_regions[1, reg]) splined_monitor_ws = mantid.SplineBackground( InputWorkspace=processed_monitor_ws, WorkspaceIndex=0, NCoeff=spline_coeff) normalised_ws = mantid.ConvertUnits(InputWorkspace=ws_to_correct, Target="Wavelength", OutputWorkspace=ws_to_correct) normalised_ws = mantid.NormaliseToMonitor( InputWorkspace=normalised_ws, MonitorWorkspace=splined_monitor_ws, IntegrationRangeMin=integration_range[0], IntegrationRangeMax=integration_range[-1], OutputWorkspace=normalised_ws) normalised_ws = mantid.ConvertUnits(InputWorkspace=normalised_ws, Target="TOF", OutputWorkspace=normalised_ws) common.remove_intermediate_workspace(processed_monitor_ws) common.remove_intermediate_workspace(splined_monitor_ws) return normalised_ws
def _mask_prompt_pulses(self, ws): """ HRPD has a long flight path from the moderator resulting in sharp peaks from the proton pulse that maintain their sharp resolution. Here we mask these pulses out that occur at 20ms intervals. :param ws: The workspace containing the pulses. It is masked in place. """ # The number of pulse can vary depending on the data range # Compute number of pulses that occur at each 20ms interval. x_data = ws.readX(0) pulse_min = int(round(x_data[0]) / PROMPT_PULSE_INTERVAL) + 1 pulse_max = int(round(x_data[-1]) / PROMPT_PULSE_INTERVAL) + 1 for i in range(pulse_min, pulse_max): centre = PROMPT_PULSE_INTERVAL * float(i) mantid.MaskBins(InputWorkspace=ws, OutputWorkspace=ws, XMin=centre - PROMPT_PULSE_LEFT_WIDTH, XMax=centre + PROMPT_PULSE_RIGHT_WIDTH)
def _run_get_monitor(self, run_number, input_dir, spline_terms): load_monitor_ws = common._load_monitor(run_number, input_dir=input_dir, instrument=self) get_monitor_ws = mantid.ConvertUnits(InputWorkspace=load_monitor_ws, Target="Wavelength") common.remove_intermediate_workspace(load_monitor_ws) lmin, lmax = self._get_lambda_range() get_monitor_ws = mantid.CropWorkspace(InputWorkspace=get_monitor_ws, XMin=lmin, XMax=lmax) ex_regions = numpy.zeros((2, 4)) ex_regions[:, 0] = [3.45, 3.7] ex_regions[:, 1] = [2.96, 3.2] ex_regions[:, 2] = [2.1, 2.26] ex_regions[:, 3] = [1.73, 1.98] # ConvertToDistribution(works) for reg in range(0, 4): get_monitor_ws = mantid.MaskBins(InputWorkspace=get_monitor_ws, XMin=ex_regions[0, reg], XMax=ex_regions[1, reg]) monitor_ws = mantid.SplineBackground(InputWorkspace=get_monitor_ws, WorkspaceIndex=0, NCoeff=spline_terms) common.remove_intermediate_workspace(get_monitor_ws) return monitor_ws
def shared_load_files(extension, filename, ws, spectrum_max, spectrum_min, is_monitor): if not (extension == "nxs" or extension == "raw" or extension[0] == "s"): return False if extension == "nxs": simple.Load(Filename=filename, OutputWorkspace=ws, SpectrumMin=spectrum_min, SpectrumMax=spectrum_min) else: simple.LoadRaw(Filename=filename, OutputWorkspace=ws, SpectrumMin=spectrum_min, SpectrumMax=spectrum_max, LoadLogFiles="0") simple.Rebin(InputWorkspace=ws, OutputWorkspace=ws, Params='6000,-0.00063,110000') if not is_monitor: simple.MaskBins(InputWorkspace=ws, OutputWorkspace=ws, XMin=99900, XMax=106000) return True
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