def calculate_scaled_hab_output(self, shift, scale, sample_count_secondary, sample_norm_secondary, can_count_secondary, can_norm_secondary): scaled_norm_front = mantid_api.Scale( InputWorkspace=sample_norm_secondary, Factor=1.0 / scale, Operation='Multiply', StoreInADS=False) shifted_norm_front = mantid_api.Scale( InputWorkspace=sample_norm_secondary, Factor=shift, Operation='Multiply', StoreInADS=False) numerator = mantid_api.Plus(LHSWorkspace=sample_count_secondary, RHSWorkspace=shifted_norm_front, StoreInADS=False) hab_sample = mantid_api.Divide(LHSWorkspace=numerator, RHSWorkspace=scaled_norm_front, StoreInADS=False) if can_count_secondary is not None and can_norm_secondary is not None: scaled_norm_front_can = mantid_api.Scale( InputWorkspace=can_norm_secondary, Factor=1.0 / scale, Operation='Multiply', StoreInADS=False) hab_can = mantid_api.Divide(LHSWorkspace=can_count_secondary, RHSWorkspace=scaled_norm_front_can, StoreInADS=False) hab_sample = mantid_api.Minus(LHSWorkspace=hab_sample, RHSWorkspace=hab_can, StoreInADS=False) return hab_sample else: return hab_sample
def create_solid_angle_corrections(self, vanadium, run_details): """ Creates the solid angle corrections from a vanadium run, only applicable on HRPD otherwise return None :param vanadium: The vanadium used to create this :param run_details: the run details of to use """ if not self._inst_settings.do_solid_angle: return solid_angle = mantid.SolidAngle(InputWorkspace=vanadium) scale = mantid.CreateSingleValuedWorkspace(DataValue='100') correction = mantid.Multiply(LHSWorkspace=solid_angle, RHSWorkspace=scale) eff = mantid.Divide(LHSWorkspace=vanadium, RHSWorkspace=correction) eff = mantid.ConvertUnits(InputWorkspace=eff, Target='Wavelength') eff = mantid.Integration(InputWorkspace=eff, RangeLower='1.3999999999999999', RangeUpper='3') correction = mantid.Multiply(LHSWorkspace=correction, RHSWorkspace=eff) scale = mantid.CreateSingleValuedWorkspace(DataValue='100000') correction = mantid.Divide(LHSWorkspace=correction, RHSWorkspace=scale) name = "sac" + common.generate_splined_name(run_details.run_number, []) path = run_details.van_paths mantid.SaveNexus(InputWorkspace=correction, Filename=os.path.join(path, name)) common.remove_intermediate_workspace(solid_angle) common.remove_intermediate_workspace(scale) common.remove_intermediate_workspace(eff) common.remove_intermediate_workspace(correction)
def PyExec(self): # Input vana_input = self.getProperty("VanadiumWorkspaces").value bg_input = self.getProperty("BackgroundWorkspaces").value vana_workspaces = self._expand_groups(vana_input) bg_workspaces = self._expand_groups(bg_input) self.log().notice("Input Vanadium workspaces: " + str(vana_workspaces)) self.log().notice("Input Background workspaces: " + str(bg_workspaces)) # number of vanadium and background workspaces must match if len(vana_workspaces) != len(bg_workspaces): raise RuntimeError("Number of Vanadium and background workspaces doe not match!") # compare optional sample logs, throw warnings result = api.CompareSampleLogs(vana_workspaces+bg_workspaces, self.properties_to_compare, 5e-3) if result: self.log().warning("Following properties do not match: " + result) # split input workspaces to groups SF/NSF and detector angles deterota = self._get_detector_positions(vana_workspaces) sfvana, nsfvana = self._sort_workspaces(vana_workspaces, deterota) sfbg, nsfbg = self._sort_workspaces(bg_workspaces, deterota) # subract background sfv = self._subtract_background(sfvana, sfbg, deterota) nsfv = self._subtract_background(nsfvana, nsfbg, deterota) total = self._sum_signal(sfv, nsfv, deterota) # compute vmean _mean_ws_ = api.Mean(",".join(list(total.values()))) # Mean takes string self.toremove.append(_mean_ws_.name()) num = self._get_notmasked_detectors_number(_mean_ws_) if num == 0: self.cleanup(self.toremove) raise RuntimeError("All detectors are masked! Cannot compute coefficients.") _vana_mean_ = api.SumSpectra(_mean_ws_)/num self.toremove.append(_vana_mean_.name()) # compute coefficients k_i = (VSF_i + VNSF_i)/Vmean outws_name = self.getPropertyValue("OutputWorkspace") # for only one detector position only one workspace will be created if len(deterota) == 1: api.Divide(list(total.values())[0], _vana_mean_, OutputWorkspace=outws_name) else: # for many detector positions group of workspaces will be created results = [] for angle in deterota: wsname = outws_name + '_2theta' + str(angle) api.Divide(total[angle], _vana_mean_, OutputWorkspace=wsname) results.append(wsname) api.GroupWorkspaces(results, OutputWorkspace=outws_name) self.cleanup(self.toremove) outws = api.AnalysisDataService.retrieve(outws_name) self.setProperty("OutputWorkspace", outws) return
def _divide_one_spectrum_by_spline(spectrum, spline, instrument): rebinned_spline = mantid.RebinToWorkspace(WorkspaceToRebin=spline, WorkspaceToMatch=spectrum, StoreInADS=False) if instrument.get_instrument_prefix() == "GEM": divided = mantid.Divide(LHSWorkspace=spectrum, RHSWorkspace=rebinned_spline, OutputWorkspace=spectrum, StoreInADS=False) complete = mantid.ReplaceSpecialValues(InputWorkspace=divided, NaNValue=0, StoreInADS=False) # crop based off max between 1000 and 2000 tof as the vanadium peak on Gem will always occur here return _crop_spline_to_percent_of_max(rebinned_spline, complete, spectrum, 1000, 2000) divided = mantid.Divide(LHSWorkspace=spectrum, RHSWorkspace=rebinned_spline, StoreInADS=False) complete = mantid.ReplaceSpecialValues(InputWorkspace=divided, NaNValue=0, OutputWorkspace=spectrum) return complete
def _correct_sample_can(self): """ Correct for sample and container. """ logger.information('Correcting sample and container') corrected_can_ws = '__corrected_can' factor_types = ['_ass'] if self._use_can: factor_types.extend(['_acc', '_acsc', '_assc']) corr_unit = s_api.mtd[self._corrections + '_ass'].getAxis(0).getUnit().unitID() for f_type in factor_types: self._convert_units_wavelength(corr_unit, self._corrections + f_type, self._corrections + f_type, "Wavelength") if self._rebin_container_ws: s_api.RebinToWorkspace( WorkspaceToRebin=self._scaled_container_wavelength, WorkspaceToMatch=self._corrections + '_acc', OutputWorkspace=self._scaled_container_wavelength) # Acc s_api.Divide(LHSWorkspace=self._scaled_container_wavelength, RHSWorkspace=self._corrections + '_acc', OutputWorkspace=corrected_can_ws) # Acsc s_api.Multiply(LHSWorkspace=corrected_can_ws, RHSWorkspace=self._corrections + '_acsc', OutputWorkspace=corrected_can_ws) s_api.Minus(LHSWorkspace=self._sample_ws_wavelength, RHSWorkspace=corrected_can_ws, OutputWorkspace=self._output_ws_name) # Assc s_api.Divide(LHSWorkspace=self._output_ws_name, RHSWorkspace=self._corrections + '_assc', OutputWorkspace=self._output_ws_name) for f_type in factor_types: self._convert_units_wavelength(corr_unit, self._corrections + f_type, self._corrections + f_type, corr_unit) s_api.DeleteWorkspace(corrected_can_ws)
def _fr_correction(self): """ applies flipping ratio correction according to J Appl. Cryst. 42, 69-84, 2009 creates the corrected workspaces """ wslist = [] # 1. retrieve NiCr and Background sf_nicr = api.AnalysisDataService.retrieve(self.input_workspaces['SF_NiCr']) nsf_nicr = api.AnalysisDataService.retrieve(self.input_workspaces['NSF_NiCr']) sf_bkgr = api.AnalysisDataService.retrieve(self.input_workspaces['SF_Background']) nsf_bkgr = api.AnalysisDataService.retrieve(self.input_workspaces['NSF_Background']) # 2. subtract background from NiCr _sf_nicr_bg_ = sf_nicr - sf_bkgr wslist.append(_sf_nicr_bg_.name()) _nsf_nicr_bg_ = nsf_nicr - nsf_bkgr wslist.append(_nsf_nicr_bg_.name()) # check negative values, throw exception sf_arr = np.array(_sf_nicr_bg_.extractY()).flatten() nsf_arr = np.array(_nsf_nicr_bg_.extractY()).flatten() sf_neg_values = np.where(sf_arr < 0)[0] nsf_neg_values = np.where(nsf_arr < 0)[0] if len(sf_neg_values) or len(nsf_neg_values): self.cleanup(wslist) message = "Background is higher than NiCr signal!" self.log().error(message) raise RuntimeError(message) # 3. calculate flipping ratio F - 1 = (NiCr - Bkg)NSF/(NiCr - Bkg)SF - 1 _coef_ws_ = api.Divide(LHSWorkspace=_nsf_nicr_bg_, RHSWorkspace=_sf_nicr_bg_, WarnOnZeroDivide=True) - 1.0 wslist.append(_coef_ws_.name()) # 4. apply correction raw data sf_data_ws = api.AnalysisDataService.retrieve(self.input_workspaces['SF_Data']) nsf_data_ws = api.AnalysisDataService.retrieve(self.input_workspaces['NSF_Data']) # NSF_corr[i] = NSF[i] + (NSF[i] - SF[i])/(F[i] - 1) _diff_ws_ = nsf_data_ws - sf_data_ws wslist.append(_diff_ws_.name()) _tmp_ws_ = api.Divide(LHSWorkspace=_diff_ws_, RHSWorkspace=_coef_ws_, WarnOnZeroDivide=True) _tmp_ws_.setYUnit(nsf_data_ws.YUnit()) api.Plus(LHSWorkspace=nsf_data_ws, RHSWorkspace=_tmp_ws_, OutputWorkspace=self.nsf_outws_name) # SF_corr[i] = SF[i] - (NSF[i] - SF[i])/(F[i] - 1) api.Minus(LHSWorkspace=sf_data_ws, RHSWorkspace=_tmp_ws_, OutputWorkspace=self.sf_outws_name) api.DeleteWorkspace(_tmp_ws_) # cleanup self.cleanup(wslist) return
def ProcessVana(rnum, cycle): # Preparation of the V/Nd sphere run for SX normalization mantid.LoadRaw(Filename='/archive/NDXWISH/Instrument/data/cycle_' + cycle + '/WISH000' + str(rnum) + '.raw', OutputWorkspace='Vana', LoadMonitors='Separate') mantid.CropWorkspace(InputWorkspace='Vana', OutputWorkspace='Vana', XMin=6000, XMax=99000) mantid.NormaliseByCurrent(InputWorkspace='Vana', OutputWorkspace='Vana') mantid.ConvertUnits(InputWorkspace='Vana', OutputWorkspace='Vana', Target='Wavelength') # create Abs Correction for V shape = '''<sphere id="V-sphere"> <centre x="0.0" y="0.0" z="0.0" /> <radius val="0.0025"/> </sphere>''' mantid.CreateSampleShape('Vana', shape) mantid.SetSampleMaterial('Vana', SampleNumberDensity=0.0719, ScatteringXSection=5.197, AttenuationXSection=4.739, ChemicalFormula='V0.95 Nb0.05') mantid.AbsorptionCorrection(InputWorkspace='Vana', OutputWorkspace='Abs_corr', ElementSize=0.5) # SphericalAbsorption(InputWorkspace='WISH00038428', OutputWorkspace='Abs_corr_sphere', SphericalSampleRadius=0.25) # correct Vanadium run for absorption mantid.Divide(LHSWorkspace='Vana', RHSWorkspace='Abs_corr', OutputWorkspace='Vana_Abs') mantid.DeleteWorkspace('Vana') mantid.DeleteWorkspace('Abs_corr') # Smoot data with redius 3 mantid.SmoothNeighbours(InputWorkspace='Vana_Abs', OutputWorkspace='Vana_smoot', Radius=3) mantid.DeleteWorkspace('Vana_Abs') # SmoothData38428 mantid.SmoothData(InputWorkspace='Vana_smoot', OutputWorkspace='Vana_smoot1', NPoints=300) mantid.DeleteWorkspace('Vana_smoot')
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 _divide_one_spectrum_by_spline(spectrum, spline, instrument): rebinned_spline = mantid.RebinToWorkspace(WorkspaceToRebin=spline, WorkspaceToMatch=spectrum, StoreInADS=False) if instrument.get_instrument_prefix() == "GEM": divided = mantid.Divide(LHSWorkspace=spectrum, RHSWorkspace=rebinned_spline, OutputWorkspace=spectrum, StoreInADS=False) return _crop_spline_to_percent_of_max(rebinned_spline, divided, spectrum) divided = mantid.Divide(LHSWorkspace=spectrum, RHSWorkspace=rebinned_spline, OutputWorkspace=spectrum) return divided
def create_solid_angle_corrections(self, vanadium, run_details): """ Creates the solid angle corrections from a vanadium run, only applicable on HRPD otherwise return None :param vanadium: The vanadium used to create this :param run_details: the run details of to use """ settings = self._inst_settings if not settings.do_solid_angle: return solid_angle = mantid.SolidAngle(InputWorkspace=vanadium) solid_angle = mantid.Scale(InputWorkspace=solid_angle, Factor=100, Operation='Multiply') eff = mantid.Divide(LHSWorkspace=vanadium, RHSWorkspace=solid_angle) eff = mantid.ConvertUnits(InputWorkspace=eff, Target='Wavelength') integration_range = settings.eff_integration_range # use full range if no range is supplied integration_range = integration_range if integration_range is not None else (None, None) eff = mantid.Integration(InputWorkspace=eff, RangeLower=integration_range[0], RangeUpper=integration_range[1]) correction = mantid.Multiply(LHSWorkspace=solid_angle, RHSWorkspace=eff) correction = mantid.Scale(InputWorkspace=correction, Factor=1e-5, Operation='Multiply') name = "sac" + common.generate_splined_name(run_details.run_number, []) path = run_details.van_paths mantid.SaveNexus(InputWorkspace=correction, Filename=os.path.join(path, name)) common.remove_intermediate_workspace(eff) common.remove_intermediate_workspace(correction)
def _calibData(self, sam_ws, mon_ws): sapi.MaskDetectors(Workspace=sam_ws, DetectorList=self._dMask) sapi.ModeratorTzeroLinear(InputWorkspace=sam_ws, OutputWorkspace=sam_ws) sapi.LoadParameterFile(Workspace=sam_ws, Filename=pjoin(DEFAULT_CONFIG_DIR, self._reflection["parameter_file"])) sapi.ConvertUnits(InputWorkspace=sam_ws, OutputWorkspace=sam_ws, Target='Wavelength', EMode='Indirect') if self._MonNorm: sapi.ModeratorTzeroLinear(InputWorkspace=mon_ws, OutputWorkspace=mon_ws) sapi.Rebin(InputWorkspace=mon_ws, OutputWorkspace=mon_ws, Params='10') sapi.ConvertUnits(InputWorkspace=mon_ws, OutputWorkspace=mon_ws, Target='Wavelength') sapi.OneMinusExponentialCor(InputWorkspace=mon_ws, OutputWorkspace=mon_ws, C='0.20749999999999999', C1='0.001276') sapi.Scale(InputWorkspace=mon_ws, OutputWorkspace=mon_ws, Factor='1e-06') sapi.RebinToWorkspace(WorkspaceToRebin=sam_ws, WorkspaceToMatch=mon_ws, OutputWorkspace=sam_ws) sapi.Divide(LHSWorkspace=sam_ws, RHSWorkspace=mon_ws, OutputWorkspace=sam_ws)
def apply_vanadium_absorb_corrections(van_ws, run_details, absorb_ws=None): if absorb_ws is None: absorb_ws = mantid.Load(Filename=run_details.vanadium_absorption_path) van_original_units = van_ws.getAxis(0).getUnit().unitID() absorb_units = absorb_ws.getAxis(0).getUnit().unitID() if van_original_units != absorb_units: van_ws = mantid.ConvertUnits(InputWorkspace=van_ws, Target=absorb_units, OutputWorkspace=van_ws) absorb_ws = mantid.RebinToWorkspace(WorkspaceToRebin=absorb_ws, WorkspaceToMatch=van_ws, OutputWorkspace=absorb_ws) van_ws = mantid.Divide(LHSWorkspace=van_ws, RHSWorkspace=absorb_ws, OutputWorkspace=van_ws) if van_original_units != absorb_units: van_ws = mantid.ConvertUnits(InputWorkspace=van_ws, Target=van_original_units, OutputWorkspace=van_ws) common.remove_intermediate_workspace(absorb_ws) return van_ws
def convert_to_y_space_and_symmetrise(ws_name,mass): # phenomenological roule-of-thumb to define the y-range for a given mass max_Y = np.ceil(2.5*mass+27) rebin_parameters = str(-max_Y)+","+str(2.*max_Y/120)+","+str(max_Y) # converting to y-space, rebinning, and defining a normalisation matrix to take into account the kinetic cut-off sapi.ConvertToYSpace(InputWorkspace=ws_name,Mass=mass,OutputWorkspace=ws_name+"_JoY",QWorkspace=ws_name+"_Q") ws = sapi.Rebin(InputWorkspace=ws_name+"_JoY", Params = rebin_parameters,FullBinsOnly=True, OutputWorkspace= ws_name+"_JoY") tmp=sapi.CloneWorkspace(InputWorkspace=ws_name+"_JoY") for j in range(tmp.getNumberHistograms()): for k in range(tmp.blocksize()): tmp.dataE(j)[k] =0. if np.isnan( tmp.dataY(j)[k] ) : ws.dataY(j)[k] =0. tmp.dataY(j)[k] =0. if (tmp.dataY(j)[k]!=0): tmp.dataY(j)[k] =1. tmp=sapi.SumSpectra('tmp') sapi.SumSpectra(InputWorkspace=ws_name+"_JoY",OutputWorkspace=ws_name+"_JoY_sum") sapi.Divide(LHSWorkspace=ws_name+"_JoY_sum", RHSWorkspace="tmp", OutputWorkspace =ws_name+"_JoY_sum") #rewriting the temporary workspaces ws and tmp ws=sapi.mtd[ws_name+"_JoY_sum"] tmp=sapi.CloneWorkspace(InputWorkspace=ws_name+"_JoY_sum") for k in range(tmp.blocksize()): tmp.dataE(0)[k] =(ws.dataE(0)[k]+ws.dataE(0)[ws.blocksize()-1-k])/2. tmp.dataY(0)[k] =(ws.dataY(0)[k]+ws.dataY(0)[ws.blocksize()-1-k])/2. sapi.RenameWorkspace(InputWorkspace="tmp",OutputWorkspace=ws_name+"_JoY_sym") normalise_workspace(ws_name+"_JoY_sym") return max_Y
def absorption_corrections(attenuation, height, number_density, radius, scattering, input_ws): simple.ConvertUnits(InputWorkspace=input_ws, OutputWorkspace=input_ws, Target="Wavelength", EMode="Elastic") simple.CylinderAbsorption(InputWorkspace=input_ws, OutputWorkspace="absorptionWS", CylinderSampleHeight=height, CylinderSampleRadius=radius, AttenuationXSection=attenuation, ScatteringXSection=scattering, SampleNumberDensity=number_density, NumberOfSlices="10", NumberOfAnnuli="10", NumberOfWavelengthPoints="25", ExpMethod="Normal") simple.Divide(LHSWorkspace=input_ws, RHSWorkspace="absorptionWS", OutputWorkspace=input_ws) simple.DeleteWorkspace("absorptionWS") simple.ConvertUnits(InputWorkspace=input_ws, OutputWorkspace=input_ws, Target="TOF", EMode="Elastic")
def correct_for_multiple_scattering(ws_name,first_spectrum,last_spectrum, sample_properties, transmission_guess, multiple_scattering_order, number_of_events, g_log, masses, mean_intensity_ratios): g_log.debug( "Evaluating the Multiple Scattering Correction.") dens, trans = sapi.VesuvioThickness(Masses=masses, Amplitudes=mean_intensity_ratios, TransmissionGuess=transmission_guess,Thickness=0.1) _TotScattering, _MulScattering = sapi.VesuvioCalculateMS(ws_name, NoOfMasses=len(masses), SampleDensity=dens.cell(9,1), AtomicProperties=sample_properties, BeamRadius=2.5, NumScatters=multiple_scattering_order, NumEventsPerRun=int(number_of_events)) data_normalisation = sapi.Integration(ws_name) simulation_normalisation = sapi.Integration("_TotScattering") for workspace in ("_MulScattering","_TotScattering"): ws = sapi.mtd[workspace] for j in range(ws.getNumberHistograms()): for k in range(ws.blocksize()): ws.dataE(j)[ k] =0. # set the errors from the MonteCarlo simulation to zero - no propagation of such uncertainties #- Use high number of events for final corrections!!! sapi.Divide(LHSWorkspace = workspace, RHSWorkspace = simulation_normalisation, OutputWorkspace = workspace) sapi.Multiply(LHSWorkspace = workspace, RHSWorkspace = data_normalisation, OutputWorkspace = workspace) sapi.RenameWorkspace(InputWorkspace = workspace, OutputWorkspace = str(ws_name)+workspace) safe_delete_ws(data_normalisation) safe_delete_ws(simulation_normalisation) safe_delete_ws(trans) safe_delete_ws(dens) return
def _calibData(self, sam_ws, mon_ws): api.MaskDetectors(Workspace=sam_ws, DetectorList=self._dMask) #MaskedWorkspace='BASIS_MASK') api.ModeratorTzeroLinear(InputWorkspace=sam_ws,\ OutputWorkspace=sam_ws) api.LoadParameterFile(Workspace=sam_ws, Filename=config.getInstrumentDirectory() + 'BASIS_silicon_111_Parameters.xml') api.ConvertUnits(InputWorkspace=sam_ws, OutputWorkspace=sam_ws, Target='Wavelength', EMode='Indirect') if not self._noMonNorm: api.ModeratorTzeroLinear(InputWorkspace=mon_ws,\ OutputWorkspace=mon_ws) api.Rebin(InputWorkspace=mon_ws, OutputWorkspace=mon_ws, Params='10') api.ConvertUnits(InputWorkspace=mon_ws, OutputWorkspace=mon_ws, Target='Wavelength') api.OneMinusExponentialCor(InputWorkspace=mon_ws, OutputWorkspace=mon_ws, C='0.20749999999999999', C1='0.001276') api.Scale(InputWorkspace=mon_ws, OutputWorkspace=mon_ws, Factor='9.9999999999999995e-07') api.RebinToWorkspace(WorkspaceToRebin=sam_ws, WorkspaceToMatch=mon_ws, OutputWorkspace=sam_ws) api.Divide(LHSWorkspace=sam_ws, RHSWorkspace=mon_ws, OutputWorkspace=sam_ws)
def _divide_one_spectrum_by_spline(spectrum, spline): rebinned_spline = mantid.RebinToWorkspace(WorkspaceToRebin=spline, WorkspaceToMatch=spectrum, StoreInADS=False) divided = mantid.Divide(LHSWorkspace=spectrum, RHSWorkspace=rebinned_spline, OutputWorkspace=spectrum) return divided
def _correct_sample(self): """ Correct for sample only (when no container is given). """ logger.information('Correcting sample') # Ass s_api.Divide(LHSWorkspace=self._sample_ws_wavelength, RHSWorkspace=self._corrections + '_ass', OutputWorkspace=self._output_ws_name)
def _divide_by_vanadium_splines(spectra_list, spline_file_path): vanadium_ws_list = mantid.LoadNexus(Filename=spline_file_path) output_list = [] for data_ws, van_ws in zip(spectra_list, vanadium_ws_list[1:]): vanadium_ws = mantid.RebinToWorkspace(WorkspaceToRebin=van_ws, WorkspaceToMatch=data_ws) output_ws = mantid.Divide(LHSWorkspace=data_ws, RHSWorkspace=vanadium_ws, OutputWorkspace=data_ws) output_list.append(output_ws) common.remove_intermediate_workspace(vanadium_ws) return output_list
def _run_attenuate_workspace(self, input_workspace): if self._old_atten_file is None: # For old API support attenuation_path = self._attenuation_full_path else: attenuation_path = self._old_atten_file wc_attenuated = mantid.PearlMCAbsorption(attenuation_path) wc_attenuated = mantid.ConvertToHistogram(InputWorkspace=wc_attenuated, OutputWorkspace=wc_attenuated) wc_attenuated = mantid.RebinToWorkspace(WorkspaceToRebin=wc_attenuated, WorkspaceToMatch=input_workspace, OutputWorkspace=wc_attenuated) pearl_attenuated_ws = mantid.Divide(LHSWorkspace=input_workspace, RHSWorkspace=wc_attenuated) common.remove_intermediate_workspace(workspace_name=wc_attenuated) return pearl_attenuated_ws
def attenuate_workspace(attenuation_file_path, ws_to_correct): original_units = ws_to_correct.getAxis(0).getUnit().unitID() wc_attenuated = mantid.PearlMCAbsorption(attenuation_file_path) wc_attenuated = mantid.ConvertToHistogram(InputWorkspace=wc_attenuated, OutputWorkspace=wc_attenuated) ws_to_correct = mantid.ConvertUnits(InputWorkspace=ws_to_correct, OutputWorkspace=ws_to_correct, Target=wc_attenuated.getAxis(0).getUnit().unitID()) wc_attenuated = mantid.RebinToWorkspace(WorkspaceToRebin=wc_attenuated, WorkspaceToMatch=ws_to_correct, OutputWorkspace=wc_attenuated) pearl_attenuated_ws = mantid.Divide(LHSWorkspace=ws_to_correct, RHSWorkspace=wc_attenuated) common.remove_intermediate_workspace(workspaces=wc_attenuated) pearl_attenuated_ws = mantid.ConvertUnits(InputWorkspace=pearl_attenuated_ws, OutputWorkspace=pearl_attenuated_ws, Target=original_units) return pearl_attenuated_ws
def calculate_slab_absorb_corrections(ws_to_correct, sample_details_obj): """ Sets a slab sample from the user specified dictionary and performs HRPDSlabCanAbsorption on the workspace. The SampleDetails object defines the sample, material and associated properties. :param ws_to_correct: The workspace to do corrections on :param sample_details_obj: The object containing the sample details :return: The corrected workspace """ if not isinstance(sample_details_obj, sample_details.SampleDetails): raise RuntimeError("A SampleDetails object was not set or a different object type was found when sample" " absorption corrections were requested. If you want sample absorption corrections please " "create a SampleDetails object and set the relevant properties it. " "Then set the new sample by calling set_sample_details().") if not sample_details_obj.is_material_set(): raise RuntimeError("The material for this sample has not been set yet. Please call" " set_material on the SampleDetails object to set the material") geometry_json = {"Shape": "FlatPlate", "Thick": sample_details_obj.thickness(), "Width": sample_details_obj.width(), "Height": sample_details_obj.height(), "Center": sample_details_obj.center(), "Angle": sample_details_obj.angle()} material = sample_details_obj.material_object # See SetSampleMaterial for documentation on this dictionary material_json = {"ChemicalFormula": material.chemical_formula} if material.number_density: material_json["SampleNumberDensity"] = material.number_density if material.absorption_cross_section: material_json["AttenuationXSection"] = material.absorption_cross_section if material.scattering_cross_section: material_json["ScatteringXSection"] = material.scattering_cross_section mantid.SetSample(InputWorkspace=ws_to_correct, Geometry=geometry_json, Material=material_json) previous_units = ws_to_correct.getAxis(0).getUnit().unitID() ws_units = common_enums.WORKSPACE_UNITS # HRPDSlabCanAbsorption must be completed in units of wavelength - convert if needed, than convert back afterwards if previous_units != ws_units.wavelength: ws_to_correct = mantid.ConvertUnits(InputWorkspace=ws_to_correct, OutputWorkspace=ws_to_correct, Target=ws_units.wavelength) absorb_factors = mantid.HRPDSlabCanAbsorption(InputWorkspace=ws_to_correct) ws_to_correct = mantid.Divide(LHSWorkspace=ws_to_correct, RHSWorkspace=absorb_factors, OutputWorkspace=ws_to_correct) mantid.DeleteWorkspace(Workspace=absorb_factors) if previous_units != ws_units.wavelength: ws_to_correct = mantid.ConvertUnits(InputWorkspace=ws_to_correct, OutputWorkspace=ws_to_correct, Target=previous_units) return ws_to_correct
def _normalize_one_spectrum(single_spectrum_ws, spline, instrument): rebinned_spline = mantid.RebinToWorkspace( WorkspaceToRebin=spline, WorkspaceToMatch=single_spectrum_ws, StoreInADS=False) divided = mantid.Divide(LHSWorkspace=single_spectrum_ws, RHSWorkspace=rebinned_spline, StoreInADS=False) if instrument.get_instrument_prefix() == "GEM": values_replaced = mantid.ReplaceSpecialValues(InputWorkspace=divided, NaNValue=0, StoreInADS=False) # crop based off max between 1000 and 2000 tof as the vanadium peak on Gem will always occur here complete = _crop_spline_to_percent_of_max(rebinned_spline, values_replaced, single_spectrum_ws, 1000, 2000) else: complete = mantid.ReplaceSpecialValues( InputWorkspace=divided, NaNValue=0, OutputWorkspace=single_spectrum_ws) if instrument.perform_abs_vanadium_norm(): vanadium_material = spline.sample().getMaterial() v_number_density = vanadium_material.numberDensityEffective v_cross_section = vanadium_material.totalScatterXSection() vanadium_shape = spline.sample().getShape() # number density in Angstroms-3, volume in m3. Don't bother with 1E30 factor because will cancel num_v_atoms = vanadium_shape.volume() * v_number_density sample_material = single_spectrum_ws.sample().getMaterial() sample_number_density = sample_material.numberDensityEffective sample_shape = spline.sample().getShape() num_sample_atoms = sample_shape.volume() * sample_number_density abs_norm_factor = v_cross_section * num_v_atoms / \ (num_sample_atoms * 4 * math.pi) logger.notice( "Performing absolute normalisation, multiplying by factor=" + str(abs_norm_factor)) # avoid "Variable invalidated, data has been deleted" error when debugging output_ws_name = single_spectrum_ws.name() abs_norm_factor_ws = mantid.CreateSingleValuedWorkspace( DataValue=abs_norm_factor, OutputWorkspace="__abs_norm_factor_ws") complete = mantid.Multiply(LHSWorkspace=complete, RHSWorkspace=abs_norm_factor_ws, OutputWorkspace=output_ws_name) return complete
def apply_vanadium_absorb_corrections(van_ws, run_details, absorb_ws=None): def generate_det_id_list(ws): det_id_list = [] for i in range(0, ws.getNumberHistograms()): try: det_ids = ws.getSpectrum(i).getDetectorIDs() except RuntimeError: pass else: for det_id in det_ids: det_id_list.append(det_id) return det_id_list if absorb_ws is None: absorb_ws = mantid.Load(Filename=run_details.vanadium_absorption_path) van_original_units = van_ws.getAxis(0).getUnit().unitID() absorb_units = absorb_ws.getAxis(0).getUnit().unitID() if van_original_units != absorb_units: van_ws = mantid.ConvertUnits(InputWorkspace=van_ws, Target=absorb_units, OutputWorkspace=van_ws) # PEARL sometimes do special runs with different detector cards so extract common spectra before doing # RebinToWorkspace to ensure histogram by histogram by rebin abs_det_id_list = generate_det_id_list(absorb_ws) van_det_id_list = generate_det_id_list(van_ws) common_det_ids = [det_id for det_id in abs_det_id_list if det_id in van_det_id_list] if not common_det_ids: raise RuntimeError("No common detectors in Vanadium and sample workspaces") MSG_STEM = "Vanadium workspace and absorption workspaces have different spectra. " if common_det_ids != van_det_id_list: logger.warning(MSG_STEM + "Removing unmatched spectra from the Vanadium workspace") van_ws = mantid.ExtractSpectra(InputWorkspace=van_ws, DetectorList=common_det_ids) if common_det_ids != abs_det_id_list: logger.warning(MSG_STEM + "Removing unmatched spectra from the absorption workspace") absorb_ws = mantid.ExtractSpectra(InputWorkspace=absorb_ws, DetectorList=common_det_ids) absorb_ws = mantid.RebinToWorkspace(WorkspaceToRebin=absorb_ws, WorkspaceToMatch=van_ws, OutputWorkspace=absorb_ws) van_ws = mantid.Divide(LHSWorkspace=van_ws, RHSWorkspace=absorb_ws, OutputWorkspace=van_ws, AllowDifferentNumberSpectra=True) if van_original_units != absorb_units: van_ws = mantid.ConvertUnits(InputWorkspace=van_ws, Target=van_original_units, OutputWorkspace=van_ws) common.remove_intermediate_workspace(absorb_ws) return van_ws
def _calibrate_data(self, run_set, sam_ws): sapi.MaskDetectors(Workspace=sam_ws, DetectorList=self._dMask) rpf = self._elucidate_reflection_parameter_file(sam_ws) sapi.LoadParameterFile(Workspace=sam_ws, Filename=rpf) sapi.ModeratorTzeroLinear(InputWorkspace=sam_ws, OutputWorkspace=sam_ws) sapi.ConvertUnits(InputWorkspace=sam_ws, OutputWorkspace=sam_ws, Target='Wavelength', EMode='Indirect') if self._flux_normalization_type is not None: flux_ws = self._generate_flux_spectrum(run_set, sam_ws) sapi.RebinToWorkspace(WorkspaceToRebin=sam_ws, WorkspaceToMatch=flux_ws, OutputWorkspace=sam_ws) sapi.Divide(LHSWorkspace=sam_ws, RHSWorkspace=flux_ws, OutputWorkspace=sam_ws)
def apply_vanadium_corrections(self, cyclevana, i, focused_ws): simple.LoadNexusProcessed(Filename=self.get_vanadium(i, cyclevana), OutputWorkspace="vana") simple.RebinToWorkspace(WorkspaceToRebin="vana", WorkspaceToMatch=focused_ws, OutputWorkspace="vana") simple.Divide(LHSWorkspace=focused_ws, RHSWorkspace="vana", OutputWorkspace=focused_ws) simple.DeleteWorkspace("vana") simple.ConvertUnits(InputWorkspace=focused_ws, OutputWorkspace=focused_ws, Target="TOF", EMode="Elastic") simple.ReplaceSpecialValues(InputWorkspace=focused_ws, OutputWorkspace=focused_ws, NaNValue=0.0, NaNError=0.0, InfinityValue=0.0, InfinityError=0.0)
def _apply_vanadium_norm(sample_ws_foc, van_ws_foc): # divide by curves - automatically corrects for solid angle, det efficiency and lambda dep. flux sample_ws_foc = mantid.CropWorkspace(InputWorkspace=sample_ws_foc, OutputWorkspace=sample_ws_foc.name(), XMin=0.45) van_ws_foc_rb = mantid.RebinToWorkspace( WorkspaceToRebin=van_ws_foc, WorkspaceToMatch=sample_ws_foc, OutputWorkspace=VAN_CURVE_REBINNED_NAME) # copy so as not to lose data sample_ws_foc = mantid.Divide(LHSWorkspace=sample_ws_foc, RHSWorkspace=van_ws_foc_rb, OutputWorkspace=sample_ws_foc.name(), AllowDifferentNumberSpectra=False) sample_ws_foc = mantid.ReplaceSpecialValues( InputWorkspace=sample_ws_foc, OutputWorkspace=sample_ws_foc.name(), NaNValue=0, NaNError=0.0, InfinityValue=0, InfinityError=0.0) return sample_ws_foc
def Norm_data(rnum, cycle): # Load and normalize SX data mantid.LoadRaw( Filename='/archive/Instruments$/NDXWISH/Instrument/data/cycle_' + cycle + '/WISH000' + str(rnum) + '.raw', OutputWorkspace='WISH000' + str(rnum), LoadMonitors='Separate') # ConvertToEventWorkspace(InputWorkspace='WISH000'+str(rnum), OutputWorkspace='WISH000'+str(rnum)) mantid.CropWorkspace(InputWorkspace='WISH000' + str(rnum), OutputWorkspace='WISH000' + str(i), XMin=6000, XMax=99000) mantid.ConvertUnits(InputWorkspace='WISH000' + str(rnum), OutputWorkspace='WISH000' + str(rnum), Target='Wavelength') mantid.NormaliseByCurrent(InputWorkspace='WISH000' + str(rnum), OutputWorkspace='WISH000' + str(rnum)) # normalize By vanadium PredictPeaks mantid.CropWorkspace(InputWorkspace='WISH000' + str(rnum), OutputWorkspace='WISH000' + str(rnum), XMin=0.75, XMax=9.3) mantid.RebinToWorkspace(WorkspaceToRebin='Vana_smoot1', WorkspaceToMatch='WISH000' + str(rnum), OutputWorkspace='Vana_smoot1') mantid.Divide(LHSWorkspace='WISH000' + str(rnum), RHSWorkspace='Vana_smoot1', OutputWorkspace='WISH000' + str(rnum)) # remove spike in the data above 1e15 and -1e15 mantid.ReplaceSpecialValues(InputWorkspace='WISH000' + str(rnum), OutputWorkspace='WISH000' + str(rnum), NaNValue=0, InfinityValue=0, BigNumberThreshold=1e15, SmallNumberThreshold=-1e15) # Convert to Diffraction MD and Lorentz Correction mantid.ConvertToDiffractionMDWorkspace( InputWorkspace='WISH000' + str(rnum), OutputWorkspace='WISH000' + str(rnum) + '_MD', LorentzCorrection=True)
def _apply_absorb_corrections(calibration_full_paths, corrected_van_ws, gen_absorb): corrected_van_ws = mantid.ConvertUnits(InputWorkspace=corrected_van_ws, Target="Wavelength") if gen_absorb: raise NotImplementedError( "Generating absorption corrections is not currently working correctly" ) # TODO look into this and see what is missing from the original script based on the current # TODO generated NXS file history absorb_ws = _generate_vanadium_absorb_corrections( calibration_full_paths, corrected_van_ws) else: absorb_ws = _load_van_absorb_corr(calibration_full_paths) corrected_van_ws = mantid.RebinToWorkspace( WorkspaceToRebin=corrected_van_ws, WorkspaceToMatch=absorb_ws) corrected_van_ws = mantid.Divide(LHSWorkspace=corrected_van_ws, RHSWorkspace=absorb_ws) remove_intermediate_workspace(absorb_ws) return corrected_van_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