def _load_monitor_sum_range(files, input_dir, instrument): loop = 0 num = files.split("_") frange = list(range(int(num[0]), int(num[1]) + 1)) mspectra = instrument._get_monitor_spectra(int(num[0])) for i in frange: file_path = instrument._generate_input_full_path(i, input_dir) outwork = "mon" + str(i) mantid.LoadRaw(Filename=file_path, OutputWorkspace=outwork, SpectrumMin=mspectra, SpectrumMax=mspectra, LoadLogFiles="0") loop += 1 if loop == 2: firstwk = "mon" + str(i - 1) secondwk = "mon" + str(i) load_monitor_summed = mantid.Plus(LHSWorkspace=firstwk, RHSWorkspace=secondwk) mantid.mtd.remove(firstwk) mantid.mtd.remove(secondwk) elif loop > 2: secondwk = "mon" + str(i) load_monitor_summed = mantid.Plus(LHSWorkspace=load_monitor_summed, RHSWorkspace=secondwk) mantid.mtd.remove(secondwk) return load_monitor_summed
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 _load_raw_files(run_number, instrument, input_dir): if isinstance(run_number, int): infile = instrument._generate_input_full_path(run_number=run_number, input_dir=input_dir) load_raw_ws = mantid.LoadRaw(Filename=infile, LoadLogFiles="0") else: load_raw_ws = _load_raw_file_range(run_number, input_dir, instrument) return load_raw_ws
def load_multi_run_part(self, extension, run, panel): filename = self.get_file_name(run, extension) logger.notice("reading filename... {}".format(filename)) spectra_min, spectra_max = self.return_panel.get(panel) output1 = "w{0}-{1}".format(run, panel) simple.LoadRaw(Filename=filename, OutputWorkspace=output1, SpectrumMin=str(spectra_min), SpectrumMax=str(spectra_max), LoadLogFiles="0") return output1
def _load_monitor(number, input_dir, instrument): if isinstance(number, int): full_file_path = instrument._generate_input_full_path( run_number=number, input_dir=input_dir) mspectra = instrument._get_monitor_spectra(number) load_monitor_ws = mantid.LoadRaw(Filename=full_file_path, SpectrumMin=mspectra, SpectrumMax=mspectra, LoadLogFiles="0") else: load_monitor_ws = _load_monitor_sum_range(files=number, input_dir=input_dir, instrument=instrument) return load_monitor_ws
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 _load_raw_file_range(files, input_dir, instrument): loop = 0 num = files.split("_") frange = list(range(int(num[0]), int(num[1]) + 1)) out_ws = None for i in frange: file_path = instrument._generate_input_full_path(i, input_dir) outwork = "run" + str(i) mantid.LoadRaw(Filename=file_path, OutputWorkspace=outwork, LoadLogFiles="0") loop += 1 if loop == 2: firstwk = "run" + str(i - 1) secondwk = "run" + str(i) out_ws = mantid.Plus(LHSWorkspace=firstwk, RHSWorkspace=secondwk) mantid.mtd.remove(firstwk) mantid.mtd.remove(secondwk) elif loop > 2: secondwk = "run" + str(i) out_ws = mantid.Plus(LHSWorkspace=out_ws, RHSWorkspace=secondwk) mantid.mtd.remove(secondwk) return out_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 calibrateMerlin(filename): # == Set parameters for calibration == rangeLower = 3000 # Integrate counts in each spectra from rangeLower to rangeUpper rangeUpper = 20000 # # Get calibration raw file and integrate it rawCalibInstWS = mantid.LoadRaw( filename) # 'raw' in 'rawCalibInstWS' means unintegrated. print("Integrating Workspace") CalibInstWS = mantid.Integration(rawCalibInstWS, RangeLower=rangeLower, RangeUpper=rangeUpper) mantid.DeleteWorkspace(rawCalibInstWS) print( "Created workspace (CalibInstWS) with integrated data from run and instrument to calibrate" ) # the known positions are given in pixels inside the tubes and transformed to provide the positions # with the center of the tube as the origin knownPositions = 2.92713867188 * (numpy.array([ 27.30074322, 92.5, 294.65178585, 362.37861919, 512.77103043, 663.41425323, 798.3223896, 930.9, 997.08480835 ]) / 1024 - 0.5) funcForm = numpy.array([2, 2, 1, 1, 1, 1, 1, 2, 2], numpy.int8) # The calibration will follow different steps for sets of tubes # For the door9, the best points to define the known positions are the 1st edge, 5 peaks, last edge. points7 = knownPositions[[0, 2, 3, 4, 5, 6, 8]] points7func = funcForm[[0, 2, 3, 4, 5, 6, 8]] door9pos = points7 door9func = points7func CalibratedComponent = 'MERLIN/door9' # door9 # == Get the calibration and put results into calibration table == # also put peaks into PeakFile calibrationTable, peakTable = tube.calibrate( CalibInstWS, CalibratedComponent, door9pos, door9func, outputPeak=True, margin=30, rangeList=list(range(20)) # because 20, 21, 22, 23 are defective detectors ) print( "Got calibration (new positions of detectors) and put slit peaks into file TubeDemoMerlin01.txt" ) analisePeakTable(peakTable, 'door9_tube1_peaks') # For the door8, the best points to define the known positions are the 1st edge, 5 peaks, last_edge door8pos = points7 door8func = points7func CalibratedComponent = 'MERLIN/door8' calibrationTable, peakTable = tube.calibrate( CalibInstWS, CalibratedComponent, door8pos, door8func, outputPeak=True, # change to peakTable to append to peakTable calibTable=calibrationTable, margin=30) analisePeakTable(peakTable, 'door8_peaks') # For the doors 7,6,5,4, 2, 1 we may use the 9 points doorpos = knownPositions doorfunc = funcForm CalibratedComponent = ['MERLIN/door%d' % (i) for i in [7, 6, 5, 4, 2, 1]] calibrationTable, peakTable = tube.calibrate(CalibInstWS, CalibratedComponent, doorpos, doorfunc, outputPeak=True, calibTable=calibrationTable, margin=30) analisePeakTable(peakTable, 'door1to7_peaks') # The door 3 is a special case, because it is composed by diffent kind of tubes. # door 3 tubes: 5_8, 5_7, 5_6, 5_5, 5_4, 5_3, 5_2, 5_1, 4_8, 4_7, 4_6, 4_5, 4_4, 4_3, 4_2, 4_1, 3_8, 3_7, 3_6, 3_5, 3_4 # obeys the same rules as the doors 7, 6, 5, 4, 2, 1 # For the tubes 3_3, 3_2, 3_1 -> it is better to skip the central peak # For the tubes 1_x (smaller tube below), it is better to take the final part of known positions: peak4,peak5,edge6,edge7 # For the tubes 2_x (smaller tube above, it is better to take the first part of known positions: edge1, edge2, peak1,peak2 # NOTE: the smaller tubes they have length = 1.22879882813, but 1024 detectors # so we have to correct the known positiosn by multiplying by its lenght and dividing by the longer dimension from tube_calib_fit_params import TubeCalibFitParams # calibrating tubes 1_x CalibratedComponent = ['MERLIN/door3/tube_1_%d' % (i) for i in range(1, 9)] half_diff_center = ( 2.92713867188 - 1.22879882813) / 2 # difference among the expected center position for # both tubes here a little bit of attempts is necessary. # The effective center position and lengh is different for the calibrated tube, that is the reason, # the calibrated values of the smaller tube does not seems aligned with the others. By, finding the # 'best' half_diff_center value, the alignment occurs nicely. half_diff_center = 0.835 # # the knownpositions were given with the center of the bigger tube as origin, to convert # to the center of the upper tube as origin is necessary to subtract them with the half_diff_center doorpos = knownPositions[[5, 6, 7, 8]] - half_diff_center doorfunc = [1, 1, 2, 2] # for the smal tubes, automatically searching for the peak position in pixel was not working quite well, # so we will give the aproximate position for these tubes through fitPar argument fitPar = TubeCalibFitParams([216, 527, 826, 989]) fitPar.setAutomatic(True) calibrationTable, peakTable = tube.calibrate(CalibInstWS, CalibratedComponent, doorpos, doorfunc, outputPeak=True, fitPar=fitPar, calibTable=calibrationTable, margin=30) analisePeakTable(peakTable, 'door3_tube1_peaks') # calibrating tubes 2_x CalibratedComponent = ['MERLIN/door3/tube_2_%d' % (i) for i in range(1, 9)] # the knownpositions were given with the center of the bigger tube as origin, to convert # to the center of the lower tube as origin is necessary to sum them with (len_big - len_small)/2 doorpos = knownPositions[[0, 1, 2, 3]] + half_diff_center # print doorpos doorfunc = [2, 2, 1, 1] # for the smal tubes, automatically searching for the peak position in pixel was not working quite well, # so we will give the aproximate position for these tubes through fitPar argument fitPar = TubeCalibFitParams([50, 202, 664, 815]) fitPar.setAutomatic(True) calibrationTable, peakTable = tube.calibrate(CalibInstWS, CalibratedComponent, doorpos, doorfunc, outputPeak=True, calibTable=calibrationTable, fitPar=fitPar, margin=30) analisePeakTable(peakTable, 'door3_tube2_peaks') # calibrating tubes 3_3,3_2,3_1 CalibratedComponent = ['MERLIN/door3/tube_3_%d' % (i) for i in [1, 2, 3]] doorpos = knownPositions[[0, 1, 2, 3, 5, 6, 7, 8]] doorfunc = funcForm[[0, 1, 2, 3, 5, 6, 7, 8]] calibrationTable, peakTable = tube.calibrate(CalibInstWS, CalibratedComponent, doorpos, doorfunc, outputPeak=True, calibTable=calibrationTable, margin=30) analisePeakTable(peakTable, 'door3_123_peaks') # calibrating others inside door3 # 5_8, 5_7, 5_6, 5_5, 5_4, 5_3, 5_2, 5_1, 4_8, 4_7, 4_6, 4_5, 4_4, 4_3, 4_2, 4_1, 3_8, 3_7, 3_6, 3_5, 3_4 part_3 = ['MERLIN/door3/tube_3_%d' % (i) for i in [4, 5, 6, 7, 8]] part_4 = ['MERLIN/door3/tube_4_%d' % (i) for i in range(1, 9)] part_5 = ['MERLIN/door3/tube_5_%d' % (i) for i in range(1, 9)] CalibratedComponent = part_3 + part_4 + part_5 doorpos = knownPositions doorfunc = funcForm calibrationTable, peakTable = tube.calibrate(CalibInstWS, CalibratedComponent, doorpos, doorfunc, outputPeak=True, calibTable=calibrationTable, margin=30) analisePeakTable(peakTable, 'door3_peaks') # == Apply the Calibation == mantid.ApplyCalibration(Workspace=CalibInstWS, PositionTable=calibrationTable) print("Applied calibration")
def _load_and_sum_runs(self, spectra): """Load the input set of runs & sum them if there is more than one. @param spectra :: The list of spectra to load @returns a tuple of length 2 containing (main_detector_ws, monitor_ws) """ isis = config.getFacility("ISIS") inst_prefix = isis.instrument("VESUVIO").shortName() runs = self._get_runs() self.summed_ws, self.summed_mon = "__loadraw_evs", "__loadraw_evs_monitors" for index, run in enumerate(runs): run = inst_prefix + str(run) self._raise_error_period_scatter(run, self._back_scattering) if index == 0: out_name, out_mon = SUMMED_WS, SUMMED_MON else: out_name, out_mon = SUMMED_WS + 'tmp', SUMMED_MON + 'tmp' # Load data raw_filepath = FileFinder.findRuns(run)[0] ms.LoadRaw(Filename=raw_filepath, SpectrumList=spectra, OutputWorkspace=out_name, LoadMonitors='Exclude', EnableLogging=_LOGGING_) ms.LoadRaw(Filename=raw_filepath, SpectrumList=self._mon_spectra, OutputWorkspace=out_mon, EnableLogging=_LOGGING_) # Sum if index > 0: ms.Plus(LHSWorkspace=SUMMED_WS, RHSWorkspace=out_name, OutputWorkspace=SUMMED_WS, EnableLogging=_LOGGING_) ms.Plus(LHSWorkspace=SUMMED_MON, RHSWorkspace=out_mon, OutputWorkspace=SUMMED_MON, EnableLogging=_LOGGING_) ms.DeleteWorkspace(out_name, EnableLogging=_LOGGING_) ms.DeleteWorkspace(out_mon, EnableLogging=_LOGGING_) # Check to see if extra data needs to be loaded to normalise in data x_max = self._tof_max if self._foil_out_norm_end > self._tof_max: x_max = self._foil_out_norm_end self._crop_required = True ms.CropWorkspace(Inputworkspace= SUMMED_WS, OutputWorkspace=SUMMED_WS, XMax=x_max, EnableLogging=_LOGGING_) ms.CropWorkspace(Inputworkspace= SUMMED_MON, OutputWorkspace=SUMMED_MON, XMax=self._mon_tof_max, EnableLogging=_LOGGING_) summed_data, summed_mon = mtd[SUMMED_WS], mtd[SUMMED_MON] self._load_diff_mode_parameters(summed_data) return summed_data, summed_mon
def _exec_single_foil_state_mode(self): """ Execution path when a single foil state is requested """ runs = self._get_runs() if len(runs) > 1: raise RuntimeError("Single foil state mode does not currently support summing " "multiple files") isis = config.getFacility("ISIS") inst_prefix = isis.instrument("VESUVIO").shortName() try: run_str = inst_prefix + runs[0] except ValueError: run_str = runs[0] self._raise_error_period_scatter(run_str, self._back_scattering) all_spectra = [item for sublist in self._spectra for item in sublist] ms.LoadRaw(Filename=run_str, OutputWorkspace=SUMMED_WS, SpectrumList=all_spectra, EnableLogging=_LOGGING_) raw_group = mtd[SUMMED_WS] self._nperiods = raw_group.size() first_ws = raw_group[0] foil_out = WorkspaceFactory.create(first_ws) x_values = first_ws.readX(0) self.foil_out = foil_out foil_map = SpectraToFoilPeriodMap(self._nperiods) for ws_index, spectrum_no in enumerate(all_spectra): self._set_spectra_type(spectrum_no) foil_out_periods, foil_thin_periods, _ = self._get_foil_periods() if self._diff_opt == "FoilOut": raw_grp_indices = foil_map.get_indices(spectrum_no, foil_out_periods) elif self._diff_opt == "FoilIn": indices_thin = foil_map.get_indices(spectrum_no, foil_thin_periods) indices_thick = foil_map.get_indices(spectrum_no, foil_thin_periods) raw_grp_indices = indices_thin + indices_thick elif self._diff_opt == "FoilInOut": raw_grp_indices = range(0, self._nperiods) else: raise RuntimeError("Unknown single foil mode: %s." % (self._diff_opt)) dataY = foil_out.dataY(ws_index) dataE = foil_out.dataE(ws_index) for group_index in raw_grp_indices: dataY += raw_group[group_index].readY(ws_index) dataE += np.square(raw_group[group_index].readE(ws_index)) np.sqrt(dataE, dataE) foil_out.setX(ws_index, x_values) ip_file = self.getPropertyValue(INST_PAR_PROP) if len(ip_file) > 0: self.foil_out = self._load_ip_file(self.foil_out, ip_file) if self._sumspectra: self._sum_all_spectra() ms.DeleteWorkspace(Workspace=SUMMED_WS) self._store_results()
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
def CalibrateWish(run_per_panel_list): ''' :param run_per_panel_list: is a list of tuples with the run number and the associated panel run_per_panel_list = [ (17706, 'panel01'), (17705, 'panel02'), (17701, 'panel03'), (17702, 'panel04'), (17695, 'panel05')] ''' # == Set parameters for calibration == previousDefaultInstrument = mantid.config['default.instrument'] mantid.config['default.instrument'] = "WISH" # definition of the parameters static for the calibration lower_tube = numpy.array( [-0.41, -0.31, -0.21, -0.11, -0.02, 0.09, 0.18, 0.28, 0.39]) upper_tube = numpy.array(lower_tube + 0.003) funcForm = 9 * [1] # 9 gaussian peaks margin = 15 low_range = list(range(0, 76)) high_range = list(range(76, 152)) kwargs = {'margin': margin} # it will copy all the data from the runs to have a single instrument with the calibrated data. whole_instrument = mantid.LoadRaw(str(run_per_panel_list[0][0])) whole_instrument = mantid.Integration(whole_instrument) for (run_number, panel_name) in run_per_panel_list: panel_name = str(panel_name) run_number = str(run_number) # load your data and integrate it ws = mantid.LoadRaw(run_number, OutputWorkspace=panel_name) ws = mantid.Integration(ws, 1, 20000, OutputWorkspace=panel_name) # use the TubeSpec object to be able to copy the data to the whole_instrument tube_set = TubeSpec(ws) tube_set.setTubeSpecByString(panel_name) # update kwargs argument before calling calibrate kwargs['rangeList'] = low_range # calibrate only the lower tubes calibrationTable = tube.calibrate(ws, tube_set, lower_tube, funcForm, **kwargs) # update kwargs kwargs[ 'calibTable'] = calibrationTable # append calib to calibrationtable kwargs['rangeList'] = high_range # calibrate only the upper tubes calibrationTable = tube.calibrate(ws, tube_set, upper_tube, funcForm, **kwargs) kwargs['calibTable'] = calibrationTable mantid.ApplyCalibration(ws, calibrationTable) # copy data from the current panel to the whole_instrument for i in range(tube_set.getNumTubes()): for spec_num in tube_set.getTube(i): whole_instrument.setY(spec_num, ws.dataY(spec_num)) # calibrate the whole_instrument with the last calibrated panel which has the calibration accumulation # of all the others mantid.CopyInstrumentParameters(run_per_panel_list[-1][1], whole_instrument) mantid.config['default.instrument'] = previousDefaultInstrument
def CalibrateMerlin(RunNumber): # == Set parameters for calibration == previousDefaultInstrument = mantid.config['default.instrument'] mantid.config['default.instrument'] = "MERLIN" filename = str(RunNumber) # Name of calibration run. rangeLower = 3000 # Integrate counts in each spectra from rangeLower to rangeUpper rangeUpper = 20000 # # Set parameters for ideal tube. Left = 2.0 # Where the left end of tube should be in pixels (target for AP) Centre = 512.5 # Where the centre of the tube should be in pixels (target for CP) Right = 1023.0 # Where the right of the tube should be in pixels (target for BP) ActiveLength = 2.9 # Active length of tube in Metres # Set initial parameters for peak finding ExpectedHeight = 1000.0 # Expected Height of Gaussian Peaks (initial value of fit parameter) ExpectedWidth = 32.0 # Expected width of centre peak in Pixels (initial value of fit parameter) ExpectedPositions = [ 35.0, 512.0, 989.0 ] # Expected positions of the edges and peak in pixels (initial values of fit parameters) # Set what we want to calibrate (e.g whole instrument or one door ) CalibratedComponent = 'MERLIN' # Calibrate door 2 # Get calibration raw file and integrate it print(filename) rawCalibInstWS = mantid.LoadRaw(filename) # 'raw' in 'rawCalibInstWS' means unintegrated. print("Integrating Workspace") CalibInstWS = mantid.Integration(rawCalibInstWS, RangeLower=rangeLower, RangeUpper=rangeUpper) mantid.DeleteWorkspace(rawCalibInstWS) print( "Created workspace (CalibInstWS) with integrated data from run and instrument to calibrate" ) # == Create Objects needed for calibration == ## In the merlin case, the positions are usually given in pixels, instead of being given in ## meters, to convert to meter and put the origin in the center, we have to apply the following ## transformation: ## ## pos = pixel * length/npixels - length/2 = length (pixel/npixels - 1/2) ## ## for merlin: npixels = 1024 knownPos = ActiveLength * (numpy.array([Left, Centre, Right]) / 1024.0 - 0.5) funcForm = 3 * [1] # Get fitting parameters fitPar = TubeCalibFitParams(ExpectedPositions, ExpectedHeight, ExpectedWidth, margin=40) print("Created objects needed for calibration.") # == Get the calibration and put results into calibration table == # also put peaks into PeakFile calibrationTable, peakTable = tube.calibrate(CalibInstWS, CalibratedComponent, knownPos, funcForm, outputPeak=True, fitPar=fitPar, plotTube=list( range(0, 280, 20))) print( "Got calibration (new positions of detectors) and put slit peaks into file TubeDemoMerlin01.txt" ) # == Apply the Calibation == mantid.ApplyCalibration(Workspace=CalibInstWS, CalibrationTable=calibrationTable) print("Applied calibration") # == Save workspace == # mantid.SaveNexusProcessed(CalibInstWS, 'TubeCalibDemoMerlinResult.nxs', "Result of Running TubeCalibDemoMerlin_Simple.py") # print("saved calibrated workspace (CalibInstWS) into Nexus file TubeCalibDemoMerlinResult.nxs") # == Reset default instrument == mantid.config['default.instrument'] = previousDefaultInstrument