def _run_focus(input_workspace, tof_output_name, vanadium_integration_ws, vanadium_curves_ws, df_kwarg, full_calib, region_calib): simple.NormaliseByCurrent(InputWorkspace=input_workspace, OutputWorkspace=input_workspace) input_workspace /= vanadium_integration_ws simple.ReplaceSpecialValues(InputWorkspace=input_workspace, OutputWorkspace=input_workspace, NaNValue=0, InfinityValue=0) simple.ApplyDiffCal(InstrumentWorkspace=input_workspace, CalibrationWorkspace=full_calib) ws_d = simple.ConvertUnits(InputWorkspace=input_workspace, Target='dSpacing') focused_sample = simple.DiffractionFocussing(InputWorkspace=ws_d, **df_kwarg) curves_rebinned = simple.RebinToWorkspace(WorkspaceToRebin=vanadium_curves_ws, WorkspaceToMatch=focused_sample) normalised = simple.Divide(LHSWorkspace=focused_sample, RHSWorkspace=curves_rebinned, AllowDifferentNumberSpectra=True) simple.ApplyDiffCal(InstrumentWorkspace=normalised, CalibrationWorkspace=region_calib) dspacing_output_name = tof_output_name + "_dSpacing" simple.CloneWorkspace(InputWorkspace=normalised, OutputWorkspace=dspacing_output_name) simple.ConvertUnits(InputWorkspace=normalised, OutputWorkspace=tof_output_name, Target='TOF') simple.DeleteWorkspace(curves_rebinned) simple.DeleteWorkspace(focused_sample) simple.DeleteWorkspace(normalised) simple.DeleteWorkspace(ws_d)
def _calibration_processing(calibration_dir, calibration_runs, cross_correlate_params, get_det_offset_params, grouping_file_name, input_ws, instrument, offset_file, rebin_1_params, rebin_2_params): calibration_ws = input_ws if calibration_ws.getAxis(0).getUnit().unitID() != WORKSPACE_UNITS.d_spacing: calibration_ws = mantid.Rebin(InputWorkspace=input_ws, Params=rebin_1_params) calibration_ws = mantid.ConvertUnits(InputWorkspace=calibration_ws, Target="dSpacing") spectrum_list = [] for i in range(0, calibration_ws.getNumberHistograms()): try: calibration_ws.getDetector(i) except RuntimeError: pass else: spectrum_list.append(i) calibration_ws = mantid.ExtractSpectra(InputWorkspace=calibration_ws, WorkspaceIndexList=spectrum_list) rebinned = mantid.Rebin(InputWorkspace=calibration_ws, Params=rebin_2_params) cross_correlated = mantid.CrossCorrelate(InputWorkspace=rebinned, **cross_correlate_params) # Offsets workspace must be referenced as string so it can be deleted, as simpleapi doesn't recognise it as a ws offsets_ws_name = "offsets" mantid.GetDetectorOffsets(InputWorkspace=cross_correlated, GroupingFileName=offset_file, OutputWorkspace=offsets_ws_name, **get_det_offset_params) rebinned_tof = mantid.ConvertUnits(InputWorkspace=rebinned, Target="TOF") aligned = mantid.AlignDetectors(InputWorkspace=rebinned_tof, CalibrationFile=offset_file) grouping_file = os.path.join(calibration_dir, grouping_file_name) focused = mantid.DiffractionFocussing(InputWorkspace=aligned, GroupingFileName=grouping_file, OutputWorkspace=instrument._generate_output_file_name(calibration_runs) + "_grouped") print("Saved cal file to " + offset_file) common.remove_intermediate_workspace([calibration_ws, rebinned, cross_correlated, rebinned_tof, offsets_ws_name]) return focused
def focus_and_make_van_curves(ceria_d, vanadium_d, grouping_kwarg): # focus ceria focused_ceria = simple.DiffractionFocussing(InputWorkspace=ceria_d, **grouping_kwarg) simple.ApplyDiffCal(InstrumentWorkspace=focused_ceria, ClearCalibration=True) tof_focused = simple.ConvertUnits(InputWorkspace=focused_ceria, Target='TOF') # focus van data focused_van = simple.DiffractionFocussing(InputWorkspace=vanadium_d, **grouping_kwarg) background_van = simple.EnggEstimateFocussedBackground(InputWorkspace=focused_van, NIterations='15', XWindow=0.03) simple.DeleteWorkspace(focused_ceria) simple.DeleteWorkspace(focused_van) return tof_focused, background_van
def create_van(instrument, run_details, absorb): """ Creates a splined vanadium run for the following instrument. Requires the run_details for the vanadium workspace we will process and whether to apply absorption corrections. :param instrument: The instrument object that will be used to supply various instrument specific methods :param run_details: The run details associated with this vanadium run :param absorb: Boolean flag whether to apply absorption corrections :return: Processed workspace group in dSpacing (but not splined) """ van = run_details.vanadium_run_numbers # Always sum a range of inputs as its a vanadium run over multiple captures input_van_ws_list = common.load_current_normalised_ws_list( run_number_string=van, instrument=instrument, input_batching=INPUT_BATCHING.Summed) input_van_ws = input_van_ws_list[ 0] # As we asked for a summed ws there should only be one returned corrected_van_ws = common.subtract_summed_runs( ws_to_correct=input_van_ws, empty_sample_ws_string=run_details.empty_runs, instrument=instrument) # Crop the tail end of the data on PEARL if they are not capturing slow neutrons corrected_van_ws = instrument._crop_raw_to_expected_tof_range( ws_to_crop=corrected_van_ws) if absorb: corrected_van_ws = instrument._apply_absorb_corrections( run_details=run_details, ws_to_correct=corrected_van_ws) aligned_ws = mantid.AlignDetectors( InputWorkspace=corrected_van_ws, CalibrationFile=run_details.offset_file_path) focused_vanadium = mantid.DiffractionFocussing( InputWorkspace=aligned_ws, GroupingFileName=run_details.grouping_file_path) focused_spectra = common.extract_ws_spectra(focused_vanadium) focused_spectra = instrument._crop_van_to_expected_tof_range( focused_spectra) d_spacing_group, tof_group = instrument._output_focused_ws( processed_spectra=focused_spectra, run_details=run_details, output_mode="mods") _create_vanadium_splines(focused_spectra, instrument, run_details) common.keep_single_ws_unit(d_spacing_group=d_spacing_group, tof_group=tof_group, unit_to_keep=instrument._get_unit_to_keep()) common.remove_intermediate_workspace(corrected_van_ws) common.remove_intermediate_workspace(aligned_ws) common.remove_intermediate_workspace(focused_vanadium) common.remove_intermediate_workspace(focused_spectra) return d_spacing_group
def create_calibration(calibration_runs, instrument, offset_file_name, grouping_file_name, calibration_dir, rebin_1_params, rebin_2_params, cross_correlate_params, get_det_offset_params): """ Create a calibration file from (usually) a ceria run :param calibration_runs: Run number(s) for this run :param instrument: The PEARL instrument object :param offset_file_name: Name of the file to write detector offset information to :param grouping_file_name: Name of grouping calibration file :param calibration_dir: Path to directory containing calibration information :param rebin_1_params: Parameters for the first rebin step (as a string in the usual format) :param rebin_2_params: Parameters for the second rebin step (as a string in the usual format) :param cross_correlate_params: Parameters for CrossCorrelate (as a dictionary PropertyName: PropertyValue) :param get_det_offset_params: Parameters for GetDetectorOffsets (as a dictionary PropertyName: PropertyValue) """ input_ws_list = common.load_current_normalised_ws_list( run_number_string=calibration_runs, instrument=instrument, input_batching=INPUT_BATCHING.Summed) input_ws = input_ws_list[0] calibration_ws = mantid.Rebin(InputWorkspace=input_ws, Params=rebin_1_params) if calibration_ws.getAxis( 0).getUnit().unitID() != WORKSPACE_UNITS.d_spacing: calibration_ws = mantid.ConvertUnits(InputWorkspace=calibration_ws, Target="dSpacing") rebinned = mantid.Rebin(InputWorkspace=calibration_ws, Params=rebin_2_params) cross_correlated = mantid.CrossCorrelate(InputWorkspace=rebinned, **cross_correlate_params) offset_file = os.path.join(calibration_dir, offset_file_name) # Offsets workspace must be referenced as string so it can be deleted, as simpleapi doesn't recognise it as a ws offsets_ws_name = "offsets" mantid.GetDetectorOffsets(InputWorkspace=cross_correlated, GroupingFileName=offset_file, OutputWorkspace=offsets_ws_name, **get_det_offset_params) rebinned_tof = mantid.ConvertUnits(InputWorkspace=rebinned, Target="TOF") aligned = mantid.AlignDetectors(InputWorkspace=rebinned_tof, CalibrationFile=offset_file) grouping_file = os.path.join(calibration_dir, grouping_file_name) focused = mantid.DiffractionFocussing( InputWorkspace=aligned, GroupingFileName=grouping_file, OutputWorkspace=instrument._generate_output_file_name(calibration_runs) + "_grouped") common.remove_intermediate_workspace([ calibration_ws, rebinned, cross_correlated, rebinned_tof, aligned, offsets_ws_name ]) return focused
def focus_onepanel(self, work, focus, panel): cal = "WISH_diff{}" if cal.format("_cal") not in simple.mtd: simple.LoadDiffCal(filename=self.get_cal(), InstrumentName="WISH", WorkspaceName=cal.format("")) simple.AlignDetectors(InputWorkspace=work, OutputWorkspace=work, CalibrationWorkspace=cal.format("_cal")) simple.DiffractionFocussing(InputWorkspace=work, OutputWorkspace=focus, GroupingWorkspace=cal.format("_group")) if self.deleteWorkspace: simple.DeleteWorkspace(work) if panel == 5 or panel == 6: simple.CropWorkspace(InputWorkspace=focus, OutputWorkspace=focus, XMin=0.3) return focus
def _focus_run_and_apply_roi_calibration(ws, calibration, ws_foc_name=None): if not ws_foc_name: ws_foc_name = ws.name( ) + "_" + FOCUSED_OUTPUT_WORKSPACE_NAME + calibration.get_foc_ws_suffix( ) ws_foc = mantid.DiffractionFocussing( InputWorkspace=ws, OutputWorkspace=ws_foc_name, GroupingWorkspace=calibration.get_group_ws()) mantid.ApplyDiffCal(InstrumentWorkspace=ws_foc, ClearCalibration=True) ws_foc = mantid.ConvertUnits(InputWorkspace=ws_foc, OutputWorkspace=ws_foc.name(), Target='TOF') mantid.ApplyDiffCal( InstrumentWorkspace=ws_foc, CalibrationWorkspace=calibration.get_calibration_table()) ws_foc = mantid.ConvertUnits(InputWorkspace=ws_foc, OutputWorkspace=ws_foc.name(), Target='dSpacing') return ws_foc
def _do_silicon_calibration(self, runs_to_process, cal_file_name, grouping_file_name): create_si_ws = common._read_ws(number=runs_to_process, instrument=self) cycle_details = self._get_cycle_information(runs_to_process) instrument_version = cycle_details["instrument_version"] if instrument_version == "new" or instrument_version == "new2": create_si_ws = mantid.Rebin(InputWorkspace=create_si_ws, Params="100,-0.0006,19950") create_si_d_spacing_ws = mantid.ConvertUnits(InputWorkspace=create_si_ws, Target="dSpacing") if instrument_version == "new2": create_si_d_spacing_rebin_ws = mantid.Rebin(InputWorkspace=create_si_d_spacing_ws, Params="1.71,0.002,2.1") create_si_cross_corr_ws = mantid.CrossCorrelate(InputWorkspace=create_si_d_spacing_rebin_ws, ReferenceSpectra=20, WorkspaceIndexMin=9, WorkspaceIndexMax=1063, XMin=1.71, XMax=2.1) elif instrument_version == "new": create_si_d_spacing_rebin_ws = mantid.Rebin(InputWorkspace=create_si_d_spacing_ws, Params="1.85,0.002,2.05") create_si_cross_corr_ws = mantid.CrossCorrelate(InputWorkspace=create_si_d_spacing_rebin_ws, ReferenceSpectra=20, WorkspaceIndexMin=9, WorkspaceIndexMax=943, XMin=1.85, XMax=2.05) elif instrument_version == "old": create_si_d_spacing_rebin_ws = mantid.Rebin(InputWorkspace=create_si_d_spacing_ws, Params="3,0.002,3.2") create_si_cross_corr_ws = mantid.CrossCorrelate(InputWorkspace=create_si_d_spacing_rebin_ws, ReferenceSpectra=500, WorkspaceIndexMin=1, WorkspaceIndexMax=1440, XMin=3, XMax=3.2) else: raise NotImplementedError("The instrument version is not supported for creating a silicon calibration") common.remove_intermediate_workspace(create_si_d_spacing_ws) common.remove_intermediate_workspace(create_si_d_spacing_rebin_ws) calibration_output_path = self.calibration_dir + cal_file_name create_si_offsets_ws = mantid.GetDetectorOffsets(InputWorkspace=create_si_cross_corr_ws, Step=0.002, DReference=1.920127251, XMin=-200, XMax=200, GroupingFileName=calibration_output_path) create_si_aligned_ws = mantid.AlignDetectors(InputWorkspace=create_si_ws, CalibrationFile=calibration_output_path) grouping_output_path = self.calibration_dir + grouping_file_name create_si_grouped_ws = mantid.DiffractionFocussing(InputWorkspace=create_si_aligned_ws, GroupingFileName=grouping_output_path) del create_si_offsets_ws, create_si_grouped_ws
def _create_calibration(self, calibration_runs, offset_file_name, grouping_file_name): input_ws = common._read_ws(number=calibration_runs, instrument=self) cycle_information = self._get_cycle_information(calibration_runs) # TODO move these hard coded params to instrument specific if cycle_information["instrument_version"] == "new" or cycle_information["instrument_version"] == "new2": input_ws = mantid.Rebin(InputWorkspace=input_ws, Params="100,-0.0006,19950") d_spacing_cal = mantid.ConvertUnits(InputWorkspace=input_ws, Target="dSpacing") d_spacing_cal = mantid.Rebin(InputWorkspace=d_spacing_cal, Params="1.8,0.002,2.1") if cycle_information["instrument_version"] == "new2": cross_cor_ws = mantid.CrossCorrelate(InputWorkspace=d_spacing_cal, ReferenceSpectra=20, WorkspaceIndexMin=9, WorkspaceIndexMax=1063, XMin=1.8, XMax=2.1) elif cycle_information["instrument_version"] == "new": cross_cor_ws = mantid.CrossCorrelate(InputWorkspace=d_spacing_cal, ReferenceSpectra=20, WorkspaceIndexMin=9, WorkspaceIndexMax=943, XMin=1.8, XMax=2.1) else: cross_cor_ws = mantid.CrossCorrelate(InputWorkspace=d_spacing_cal, ReferenceSpectra=500, WorkspaceIndexMin=1, WorkspaceIndexMax=1440, XMin=1.8, XMax=2.1) if self._old_api_uses_full_paths: # Workaround for old API setting full paths grouping_file_path = grouping_file_name offset_file_path = offset_file_name else: offset_file_path = self.calibration_dir + offset_file_name grouping_file_path = self.calibration_dir + grouping_file_name # Ceo Cell refined to 5.4102(3) so 220 is 1.912795 offset_output_path = mantid.GetDetectorOffsets(InputWorkspace=cross_cor_ws, Step=0.002, DReference=1.912795, XMin=-200, XMax=200, GroupingFileName=offset_file_path) del offset_output_path # This isn't used so delete it to keep linters happy aligned_ws = mantid.AlignDetectors(InputWorkspace=input_ws, CalibrationFile=offset_file_path) cal_grouped_ws = mantid.DiffractionFocussing(InputWorkspace=aligned_ws, GroupingFileName=grouping_file_path) common.remove_intermediate_workspace(d_spacing_cal) common.remove_intermediate_workspace(cross_cor_ws) common.remove_intermediate_workspace(aligned_ws) common.remove_intermediate_workspace(cal_grouped_ws)
def _focus_one_ws(input_workspace, run_number, instrument, perform_vanadium_norm, absorb, sample_details, vanadium_path): run_details = instrument._get_run_details(run_number_string=run_number) if perform_vanadium_norm: _test_splined_vanadium_exists(instrument, run_details) # Subtract empty instrument runs, as long as this run isn't an empty and user hasn't turned empty subtraction off if not common.runs_overlap(run_number, run_details.empty_runs ) and instrument.should_subtract_empty_inst(): input_workspace = common.subtract_summed_runs( ws_to_correct=input_workspace, instrument=instrument, empty_sample_ws_string=run_details.empty_runs) # Subtract a sample empty if specified if run_details.sample_empty: input_workspace = common.subtract_summed_runs( ws_to_correct=input_workspace, instrument=instrument, empty_sample_ws_string=run_details.sample_empty, scale_factor=instrument._inst_settings.sample_empty_scale) # Crop to largest acceptable TOF range input_workspace = instrument._crop_raw_to_expected_tof_range( ws_to_crop=input_workspace) # Correct for absorption / multiple scattering if required if absorb: input_workspace = instrument._apply_absorb_corrections( run_details=run_details, ws_to_correct=input_workspace) else: # Set sample material if specified by the user if sample_details is not None: mantid.SetSample( InputWorkspace=input_workspace, Geometry=common.generate_sample_geometry(sample_details), Material=common.generate_sample_material(sample_details)) # Align aligned_ws = mantid.AlignDetectors( InputWorkspace=input_workspace, CalibrationFile=run_details.offset_file_path) # Focus the spectra into banks focused_ws = mantid.DiffractionFocussing( InputWorkspace=aligned_ws, GroupingFileName=run_details.grouping_file_path) calibrated_spectra = _apply_vanadium_corrections( instrument=instrument, input_workspace=focused_ws, perform_vanadium_norm=perform_vanadium_norm, vanadium_splines=vanadium_path) output_spectra = instrument._crop_banks_to_user_tof(calibrated_spectra) bin_widths = instrument._get_instrument_bin_widths() if bin_widths: # Reduce the bin width if required on this instrument output_spectra = common.rebin_workspace_list( workspace_list=output_spectra, bin_width_list=bin_widths) # Output d_spacing_group, tof_group = instrument._output_focused_ws( output_spectra, run_details=run_details) common.keep_single_ws_unit(d_spacing_group=d_spacing_group, tof_group=tof_group, unit_to_keep=instrument._get_unit_to_keep()) # Tidy workspaces from Mantid common.remove_intermediate_workspace(input_workspace) common.remove_intermediate_workspace(aligned_ws) common.remove_intermediate_workspace(focused_ws) common.remove_intermediate_workspace(output_spectra) return d_spacing_group
def run_calibration(ceria_ws, calibration, full_instrument_cal_ws): """ Creates Engineering calibration files with PDCalibration :param ceria_ws: The workspace with the ceria data. :param bank: The bank to crop to, both if none. :param calfile: The custom calibration file to crop to, not used if none. :param spectrum_numbers: The spectrum numbers to crop to, no crop if none. :return: dict containing calibrated diffractometer constants, and copy of the raw ceria workspace """ # initial process of ceria ws mantid.NormaliseByCurrent(InputWorkspace=ceria_ws, OutputWorkspace=ceria_ws) mantid.ApplyDiffCal(InstrumentWorkspace=ceria_ws, CalibrationWorkspace=full_instrument_cal_ws) mantid.ConvertUnits(InputWorkspace=ceria_ws, OutputWorkspace=ceria_ws, Target='dSpacing') # get grouping workspace and focus grp_ws = calibration.get_group_ws() # (creates if doesn't exist) focused_ceria = mantid.DiffractionFocussing(InputWorkspace=ceria_ws, GroupingWorkspace=grp_ws) mantid.ApplyDiffCal( InstrumentWorkspace=focused_ceria, ClearCalibration=True) # DIFC of detector in middle of bank focused_ceria = mantid.ConvertUnits(InputWorkspace=focused_ceria, Target='TOF') # Run mantid.PDCalibration to fit peaks in TOF foc_name = focused_ceria.name( ) # PDCal invalidates ptr during rebin so keep track of ws name cal_table_name = "engggui_calibration_" + calibration.get_group_suffix() diag_ws_name = "diag_" + calibration.get_group_suffix() cal_table, diag_ws, mask = mantid.PDCalibration( InputWorkspace=foc_name, OutputCalibrationTable=cal_table_name, DiagnosticWorkspaces=diag_ws_name, PeakPositions=default_ceria_expected_peaks(final=True), TofBinning=[12000, -0.0003, 52000], PeakWindow=default_ceria_expected_peak_windows(final=True), MinimumPeakHeight=0.5, PeakFunction='BackToBackExponential', CalibrationParameters='DIFC+TZERO+DIFA', UseChiSq=True) mantid.ApplyDiffCal(InstrumentWorkspace=foc_name, CalibrationWorkspace=cal_table) # warn user which spectra were unsuccessfully calibrated focused_ceria = ADS.retrieve(foc_name) masked_detIDs = mask.getMaskedDetectors() for ispec in range(focused_ceria.getNumberHistograms()): if focused_ceria.getSpectrum( ispec).getDetectorIDs()[0] in masked_detIDs: logger.warning( f'mantid.PDCalibration failed for spectrum index {ispec} - proceeding with uncalibrated DIFC.' ) # store cal_table in calibration calibration.set_calibration_table(cal_table_name) return focused_ceria, cal_table, diag_ws
def _focus_one_ws(ws, run_number, instrument, perform_vanadium_norm, absorb): run_details = instrument._get_run_details(run_number_string=run_number) if perform_vanadium_norm: _test_splined_vanadium_exists(instrument, run_details) # Subtract empty instrument runs input_workspace = common.subtract_summed_runs( ws_to_correct=ws, instrument=instrument, empty_sample_ws_string=run_details.empty_runs) # Subtract a sample empty if specified if run_details.sample_empty: input_workspace = common.subtract_summed_runs( ws_to_correct=input_workspace, instrument=instrument, empty_sample_ws_string=run_details.sample_empty, scale_factor=instrument._inst_settings.sample_empty_scale) # Crop to largest acceptable TOF range input_workspace = instrument._crop_raw_to_expected_tof_range( ws_to_crop=input_workspace) # Correct for absorption / multiple scattering if required if absorb: input_workspace = instrument._apply_absorb_corrections( run_details=run_details, ws_to_correct=input_workspace) # Align aligned_ws = mantid.AlignDetectors( InputWorkspace=input_workspace, CalibrationFile=run_details.offset_file_path) # Focus the spectra into banks focused_ws = mantid.DiffractionFocussing( InputWorkspace=aligned_ws, GroupingFileName=run_details.grouping_file_path) calibrated_spectra = _apply_vanadium_corrections( instrument=instrument, run_number=run_number, input_workspace=focused_ws, perform_vanadium_norm=perform_vanadium_norm) output_spectra = instrument._crop_banks_to_user_tof(calibrated_spectra) bin_widths = instrument._get_instrument_bin_widths() if bin_widths: # Reduce the bin width if required on this instrument output_spectra = common.rebin_workspace_list( workspace_list=output_spectra, bin_width_list=bin_widths) # Output d_spacing_group, tof_group = instrument._output_focused_ws( output_spectra, run_details=run_details) common.keep_single_ws_unit(d_spacing_group=d_spacing_group, tof_group=tof_group, unit_to_keep=instrument._get_unit_to_keep()) # Tidy workspaces from Mantid common.remove_intermediate_workspace(input_workspace) common.remove_intermediate_workspace(aligned_ws) common.remove_intermediate_workspace(focused_ws) common.remove_intermediate_workspace(output_spectra) return d_spacing_group
def _focus_one_ws(input_workspace, run_number, instrument, perform_vanadium_norm, absorb, sample_details, vanadium_path, empty_can_subtraction_method, paalman_pings_events_per_point=None): run_details = instrument._get_run_details(run_number_string=run_number) if perform_vanadium_norm: _test_splined_vanadium_exists(instrument, run_details) # Subtract empty instrument runs, as long as this run isn't an empty, user hasn't turned empty subtraction off, or # The user has not supplied a sample empty is_run_empty = common.runs_overlap(run_number, run_details.empty_inst_runs) summed_empty = None if not is_run_empty and instrument.should_subtract_empty_inst( ) and not run_details.sample_empty: if os.path.isfile(run_details.summed_empty_inst_file_path): logger.warning('Pre-summed empty instrument workspace found at ' + run_details.summed_empty_inst_file_path) summed_empty = mantid.LoadNexus( Filename=run_details.summed_empty_inst_file_path) else: summed_empty = common.generate_summed_runs( empty_sample_ws_string=run_details.empty_inst_runs, instrument=instrument) elif run_details.sample_empty: scale_factor = 1.0 if empty_can_subtraction_method != 'PaalmanPings': scale_factor = instrument._inst_settings.sample_empty_scale # Subtract a sample empty if specified ie empty can summed_empty = common.generate_summed_runs( empty_sample_ws_string=run_details.sample_empty, instrument=instrument, scale_factor=scale_factor) if absorb and empty_can_subtraction_method == 'PaalmanPings': if run_details.sample_empty: # need summed_empty including container input_workspace = instrument._apply_paalmanpings_absorb_and_subtract_empty( workspace=input_workspace, summed_empty=summed_empty, sample_details=sample_details, paalman_pings_events_per_point=paalman_pings_events_per_point) # Crop to largest acceptable TOF range input_workspace = instrument._crop_raw_to_expected_tof_range( ws_to_crop=input_workspace) else: raise TypeError( "The PaalmanPings absorption method requires 'sample_empty' to be supplied." ) else: if summed_empty: input_workspace = common.subtract_summed_runs( ws_to_correct=input_workspace, empty_sample=summed_empty) # Crop to largest acceptable TOF range input_workspace = instrument._crop_raw_to_expected_tof_range( ws_to_crop=input_workspace) if absorb: input_workspace = instrument._apply_absorb_corrections( run_details=run_details, ws_to_correct=input_workspace) else: # Set sample material if specified by the user if sample_details is not None: mantid.SetSample( InputWorkspace=input_workspace, Geometry=sample_details.generate_sample_geometry(), Material=sample_details.generate_sample_material()) # Align mantid.ApplyDiffCal(InstrumentWorkspace=input_workspace, CalibrationFile=run_details.offset_file_path) aligned_ws = mantid.ConvertUnits(InputWorkspace=input_workspace, Target="dSpacing") solid_angle = instrument.get_solid_angle_corrections( run_details.vanadium_run_numbers, run_details) if solid_angle: aligned_ws = mantid.Divide(LHSWorkspace=aligned_ws, RHSWorkspace=solid_angle) mantid.DeleteWorkspace(solid_angle) # Focus the spectra into banks focused_ws = mantid.DiffractionFocussing( InputWorkspace=aligned_ws, GroupingFileName=run_details.grouping_file_path) instrument.apply_calibration_to_focused_data(focused_ws) calibrated_spectra = _apply_vanadium_corrections( instrument=instrument, input_workspace=focused_ws, perform_vanadium_norm=perform_vanadium_norm, vanadium_splines=vanadium_path) output_spectra = instrument._crop_banks_to_user_tof(calibrated_spectra) bin_widths = instrument._get_instrument_bin_widths() if bin_widths: # Reduce the bin width if required on this instrument output_spectra = common.rebin_workspace_list( workspace_list=output_spectra, bin_width_list=bin_widths) # Output d_spacing_group, tof_group = instrument._output_focused_ws( output_spectra, run_details=run_details) common.keep_single_ws_unit(d_spacing_group=d_spacing_group, tof_group=tof_group, unit_to_keep=instrument._get_unit_to_keep()) # Tidy workspaces from Mantid common.remove_intermediate_workspace(input_workspace) common.remove_intermediate_workspace(aligned_ws) common.remove_intermediate_workspace(focused_ws) common.remove_intermediate_workspace(output_spectra) return d_spacing_group
def _run_pearl_focus(instrument, run_number, perform_attenuation, perform_vanadium_norm): cycle_information = instrument._get_cycle_information( run_number=run_number) alg_range, save_range = instrument._get_instrument_alg_save_ranges( cycle_information["instrument_version"]) input_file_paths = instrument._get_calibration_full_paths( cycle=cycle_information["cycle"]) output_file_paths = instrument._generate_out_file_paths( run_number, instrument.output_dir) read_ws = _read_ws(number=run_number, instrument=instrument) input_workspace = mantid.Rebin(InputWorkspace=read_ws, Params=instrument._get_focus_tof_binning()) input_workspace = mantid.AlignDetectors( InputWorkspace=input_workspace, CalibrationFile=input_file_paths["calibration"]) input_workspace = mantid.DiffractionFocussing( InputWorkspace=input_workspace, GroupingFileName=input_file_paths["grouping"]) calibrated_spectra = _focus_load(alg_range, input_workspace, input_file_paths, instrument, perform_vanadium_norm) remove_intermediate_workspace(read_ws) remove_intermediate_workspace(input_workspace) focus_mode = instrument.focus_mode if focus_mode == "all": processed_nexus_files = _focus_mode_all(output_file_paths, calibrated_spectra) elif focus_mode == "groups": processed_nexus_files = _focus_mode_groups(cycle_information, output_file_paths, save_range, calibrated_spectra) elif focus_mode == "trans": processed_nexus_files = _focus_mode_trans(output_file_paths, perform_attenuation, instrument, calibrated_spectra) elif focus_mode == "mods": processed_nexus_files = _focus_mode_mods(output_file_paths, calibrated_spectra) else: raise ValueError("Focus mode unknown") for ws in calibrated_spectra: remove_intermediate_workspace(ws) return processed_nexus_files
def create_van(instrument, run_details, absorb): """ Creates a splined vanadium run for the following instrument. Requires the run_details for the vanadium workspace we will process and whether to apply absorption corrections. :param instrument: The instrument object that will be used to supply various instrument specific methods :param run_details: The run details associated with this vanadium run :param absorb: Boolean flag whether to apply absorption corrections :return: Processed workspace group in dSpacing (but not splined) """ van = run_details.vanadium_run_numbers # Always sum a range of inputs as its a vanadium run over multiple captures input_van_ws_list = common.load_current_normalised_ws_list( run_number_string=van, instrument=instrument, input_batching=INPUT_BATCHING.Summed) input_van_ws = input_van_ws_list[ 0] # As we asked for a summed ws there should only be one returned instrument.create_solid_angle_corrections(input_van_ws, run_details) if not (run_details.empty_runs is None): summed_empty = common.generate_summed_runs( empty_sample_ws_string=run_details.empty_runs, instrument=instrument) mantid.SaveNexus(Filename=run_details.summed_empty_file_path, InputWorkspace=summed_empty) corrected_van_ws = common.subtract_summed_runs( ws_to_correct=input_van_ws, empty_sample=summed_empty) # Crop the tail end of the data on PEARL if they are not capturing slow neutrons corrected_van_ws = instrument._crop_raw_to_expected_tof_range( ws_to_crop=corrected_van_ws) if absorb: corrected_van_ws = instrument._apply_absorb_corrections( run_details=run_details, ws_to_correct=corrected_van_ws) else: # Assume that create_van only uses Vanadium runs mantid.SetSampleMaterial(InputWorkspace=corrected_van_ws, ChemicalFormula='V') mantid.ApplyDiffCal(InstrumentWorkspace=corrected_van_ws, CalibrationFile=run_details.offset_file_path) aligned_ws = mantid.ConvertUnits(InputWorkspace=corrected_van_ws, Target="dSpacing") solid_angle = instrument.get_solid_angle_corrections( run_details.run_number, run_details) if solid_angle: aligned_ws = mantid.Divide(LHSWorkspace=aligned_ws, RHSWorkspace=solid_angle) mantid.DeleteWorkspace(solid_angle) focused_vanadium = mantid.DiffractionFocussing( InputWorkspace=aligned_ws, GroupingFileName=run_details.grouping_file_path) # convert back to TOF based on engineered detector positions mantid.ApplyDiffCal(InstrumentWorkspace=focused_vanadium, ClearCalibration=True) focused_spectra = common.extract_ws_spectra(focused_vanadium) focused_spectra = instrument._crop_van_to_expected_tof_range( focused_spectra) d_spacing_group, tof_group = instrument._output_focused_ws( processed_spectra=focused_spectra, run_details=run_details) _create_vanadium_splines(focused_spectra, instrument, run_details) common.keep_single_ws_unit(d_spacing_group=d_spacing_group, tof_group=tof_group, unit_to_keep=instrument._get_unit_to_keep()) common.remove_intermediate_workspace(corrected_van_ws) common.remove_intermediate_workspace(aligned_ws) common.remove_intermediate_workspace(focused_vanadium) common.remove_intermediate_workspace(focused_spectra) return d_spacing_group
def align_and_focus_event_ws(event_ws_name, output_ws_name, binning_params, diff_cal_ws_name, grouping_ws_name, reduction_params_dict, convert_to_matrix): """ Align and focus event workspace. The procedure to reduce from the EventNexus includes 1. compress event 2. mask workspace 3. align detectors 4. sort events 5. diffraction focus 6. sort events 7. edit instruments 8. rebin (uniform binning) Output: still event workspace :exception RuntimeError: intolerable error :param event_ws_name: :param output_ws_name: :param binning_params: :param diff_cal_ws_name: :param grouping_ws_name: :param reduction_params_dict: :param convert_to_matrix: :return: string as ERROR message """ # check inputs if not mantid_helper.is_event_workspace(event_ws_name): raise RuntimeError('Input {0} is not an EventWorkspace'.format(event_ws_name)) if not mantid_helper.is_calibration_workspace(diff_cal_ws_name): diff_ws = mantid_helper.retrieve_workspace(diff_cal_ws_name) raise RuntimeError('Input {0} is not a Calibration workspace but a {1}'.format(diff_cal_ws_name, diff_ws.__class__.__name__)) # if not mantid_helper.is_masking_workspace(mask_ws_name): # raise RuntimeError('Input {0} is not a Masking workspace'.format(mask_ws_name)) if not mantid_helper.is_grouping_workspace(grouping_ws_name): raise RuntimeError('Input {0} is not a grouping workspace'.format(grouping_ws_name)) datatypeutility.check_dict('Reduction parameter dictionary', reduction_params_dict) # Align detector mantidapi.AlignDetectors(InputWorkspace=event_ws_name, OutputWorkspace=output_ws_name, CalibrationWorkspace=diff_cal_ws_name) # # Mask detectors # mantid_helper.mask_workspace(to_mask_workspace_name=output_ws_name, # mask_workspace_name=mask_ws_name) # Sort events mantidapi.SortEvents(InputWorkspace=output_ws_name, SortBy='X Value') # Diffraction focus event_ws = mantid_helper.retrieve_workspace(output_ws_name) if event_ws.getNumberEvents() == 0: print('[DB...BAT] {}: # events = {}'.format(event_ws, event_ws.getNumberEvents())) error_message = 'Unable to reduced {} as number of events = 0'.format(event_ws_name) raise RuntimeError(error_message) mantidapi.DiffractionFocussing(InputWorkspace=output_ws_name, OutputWorkspace=output_ws_name, GroupingWorkspace=grouping_ws_name, PreserveEvents=True) # Sort again! mantidapi.SortEvents(InputWorkspace=output_ws_name, SortBy='X Value') # Compress events as an option if 'CompressEvents' in reduction_params_dict: compress_events_tolerance = reduction_params_dict['CompressEvents']['Tolerance'] print('[DB...BAT] User-specified compress tolerance = {}'.format(compress_events_tolerance)) mantidapi.CompressEvents(InputWorkspace=output_ws_name, OutputWorkspace=output_ws_name, Tolerance=1.E-5) # rebin if binning_params is not None: mantid_helper.rebin(workspace_name=output_ws_name, params=binning_params, preserve=not convert_to_matrix) # Edit instrument as an option if 'EditInstrumentGeometry' in reduction_params_dict: try: # TODO - NIGHT - In case the number of histograms of output workspace does not match (masked a lot) ... # TODO - FIXME - 27 bank Polar and Azimuthal are all None print(reduction_params_dict['EditInstrumentGeometry'].keys()) print(output_ws_name) print(mantid_helper.VULCAN_L1) print(reduction_params_dict['EditInstrumentGeometry']['SpectrumIDs']) print(reduction_params_dict['EditInstrumentGeometry']['L2']) print(reduction_params_dict['EditInstrumentGeometry']['Polar']) print(reduction_params_dict['EditInstrumentGeometry']['Azimuthal']) mantidapi.EditInstrumentGeometry(Workspace=output_ws_name, PrimaryFlightPath=mantid_helper.VULCAN_L1, SpectrumIDs=reduction_params_dict['EditInstrumentGeometry']['SpectrumIDs'], L2=reduction_params_dict['EditInstrumentGeometry']['L2'], Polar=reduction_params_dict['EditInstrumentGeometry']['Polar'], Azimuthal=reduction_params_dict['EditInstrumentGeometry']['Azimuthal']) """ Workspace PrimaryFlightPath SpectrumIDs L2 Polar Azimuthal DetectorIDs InstrumentName """ except RuntimeError as run_err: error_message = 'Non-critical failure on EditInstrumentGeometry: {}\n'.format(run_err) return error_message return ''
def _create_van(instrument, van, empty, output_van_file_name, num_of_splines=60, absorb=True, gen_absorb=False): cycle_information = instrument._get_cycle_information(van) input_van_ws = _read_ws(number=van, instrument=instrument) input_empty_ws = _read_ws(number=empty, instrument=instrument) corrected_van_ws = mantid.Minus(LHSWorkspace=input_van_ws, RHSWorkspace=input_empty_ws) remove_intermediate_workspace(input_empty_ws) remove_intermediate_workspace(input_van_ws) calibration_full_paths = instrument._get_calibration_full_paths( cycle=cycle_information["cycle"]) tof_binning = instrument._get_create_van_tof_binning() if absorb: corrected_van_ws = _apply_absorb_corrections(calibration_full_paths, corrected_van_ws, gen_absorb) corrected_van_ws = mantid.ConvertUnits(InputWorkspace=corrected_van_ws, Target="TOF") corrected_van_ws = mantid.Rebin(InputWorkspace=corrected_van_ws, Params=tof_binning["1"]) corrected_van_ws = mantid.AlignDetectors( InputWorkspace=corrected_van_ws, CalibrationFile=calibration_full_paths["calibration"]) focused_van_file = mantid.DiffractionFocussing( InputWorkspace=corrected_van_ws, GroupingFileName=calibration_full_paths["grouping"]) focused_van_file = mantid.ConvertUnits(InputWorkspace=focused_van_file, Target="TOF") focused_van_file = mantid.Rebin(InputWorkspace=focused_van_file, Params=tof_binning["2"]) focused_van_file = mantid.ConvertUnits(InputWorkspace=focused_van_file, Target="dSpacing") remove_intermediate_workspace(corrected_van_ws) splined_ws_list = instrument._spline_background( focused_van_file, num_of_splines, cycle_information["instrument_version"]) if instrument._PEARL_use_full_path(): out_van_file_path = output_van_file_name else: out_van_file_path = instrument.calibration_dir + output_van_file_name append = False for ws in splined_ws_list: mantid.SaveNexus(Filename=out_van_file_path, InputWorkspace=ws, Append=append) remove_intermediate_workspace(ws) append = True mantid.LoadNexus(Filename=out_van_file_path, OutputWorkspace="Van_data")
def create_calibration(self, calibration_runs, offset_file_name, grouping_file_name): input_ws_list = common.load_current_normalised_ws_list( run_number_string=calibration_runs, instrument=self, input_batching=INPUT_BATCHING.Summed) input_ws = input_ws_list[0] run_details = self._get_run_details(calibration_runs) if run_details.instrument_version == "new" or run_details.instrument_version == "new2": input_ws = mantid.Rebin(InputWorkspace=input_ws, Params="100,-0.0006,19950") d_spacing_cal = mantid.ConvertUnits(InputWorkspace=input_ws, Target="dSpacing") d_spacing_cal = mantid.Rebin(InputWorkspace=d_spacing_cal, Params="1.8,0.002,2.1") if run_details.instrument_version == "new2": cross_cor_ws = mantid.CrossCorrelate(InputWorkspace=d_spacing_cal, ReferenceSpectra=20, WorkspaceIndexMin=9, WorkspaceIndexMax=1063, XMin=1.8, XMax=2.1) elif run_details.instrument_version == "new": cross_cor_ws = mantid.CrossCorrelate(InputWorkspace=d_spacing_cal, ReferenceSpectra=20, WorkspaceIndexMin=9, WorkspaceIndexMax=943, XMin=1.8, XMax=2.1) else: cross_cor_ws = mantid.CrossCorrelate(InputWorkspace=d_spacing_cal, ReferenceSpectra=500, WorkspaceIndexMin=1, WorkspaceIndexMax=1440, XMin=1.8, XMax=2.1) if self._old_api_uses_full_paths: # Workaround for old API setting full paths grouping_file_path = grouping_file_name offset_file_path = offset_file_name else: offset_file_path = os.path.join(self.calibration_dir, offset_file_name) grouping_file_path = os.path.join(self.calibration_dir, grouping_file_name) # Ceo Cell refined to 5.4102(3) so 220 is 1.912795 offset_output_path = mantid.GetDetectorOffsets( InputWorkspace=cross_cor_ws, Step=0.002, DReference=1.912795, XMin=-200, XMax=200, GroupingFileName=offset_file_path) del offset_output_path # This isn't used so delete it to keep linters happy aligned_ws = mantid.AlignDetectors(InputWorkspace=input_ws, CalibrationFile=offset_file_path) cal_grouped_ws = mantid.DiffractionFocussing( InputWorkspace=aligned_ws, GroupingFileName=grouping_file_path) common.remove_intermediate_workspace(d_spacing_cal) common.remove_intermediate_workspace(cross_cor_ws) common.remove_intermediate_workspace(aligned_ws) common.remove_intermediate_workspace(cal_grouped_ws)