def mult_params_peaks_Lorentzian(x, y): #http://cars9.uchicago.edu/software/python/lmfit/builtin_models.html loren_mod1 = LorentzianModel(prefix='l1_') pars = loren_mod1.guess(y, x) loren_mod2 = LorentzianModel(prefix='l2_') pars.update(loren_mod2.make_params()) loren_mod3 = LorentzianModel(prefix='l3_') pars.update(loren_mod3.make_params()) mod = loren_mod1 + loren_mod2 + loren_mod3 init = mod.eval(pars, x=x) out = mod.fit(y, pars, x=x) print(out.fit_report(min_correl=0.5)) plot_components = False plt.plot(x, y, 'b') plt.plot(x, init, 'k--') plt.plot(x, out.best_fit, 'r-') if plot_components: comps = out.eval_components(x=x) plt.plot(x, comps['l1_'], 'b--') plt.plot(x, comps['l2_'], 'b--') plt.plot(x, comps['l3_'], 'b--')
def test_imagefile_ops(self): self.a2.gridimage() self.a3.gridimage() self.a2.crop(5,-15,5,-5,_=True) self.a3.crop(5,-15,5,-5,_=True) self.b=self.a2//self.a3 self.assertEqual(self.b.shape,(90,80),"Failure to crop image correctly.") self.assertGreater(self.b.max(),0.047,"XMCD Ratio calculation failed") self.assertLess(self.b.min(),-0.05,"XMCD Ratio calculation failed") self.b.normalise() self.assertEqual(self.b.max(),1.0,"Normalise Image failed") self.assertEqual(self.b.min(),-1.0,"Normalise Image failed") self.profile=self.b.profile_line((0,0),(100,100)) self.profile.plot() self.b.mask=self.a2.image>25E3 self.hist=self.b.hist(bins=200) self.hist.column_headers=["XMCD Signal","Frequency"] self.hist.labels=None g1=LorentzianModel(prefix="g1_") g2=LorentzianModel(prefix="g2_") params=g1.make_params() params.update(g2.make_params()) double_peak=g1+g2 g1=np.argmax(self.hist.y[:100]) # Location of first peak g2=np.argmax(self.hist.y[100:])+100 for k, p in zip(params,[0.25,self.hist.x[g1],self.hist.y[g1]/np.sqrt(2),0.5,self.hist.y[g1], 0.25,self.hist.x[g2],self.hist.y[g2]/np.sqrt(2),0.5,self.hist.y[g2]]): params[k].value=p print(g1,g2,params) self.res=self.hist.lmfit(double_peak,p0=params,output="report") self.hist.add_column(self.res.init_fit,header="Initial Fit") self.hist.add_column(self.res.best_fit,header="Best Fit") self.hist.setas="xyyy" self.hist.plot(fmt=["b+","b--","r-"]) plt.close("all")
def fitLorentzian(x,y): signalGuess = max(y)-min(y) # centerGuess = x[np.argmax(y)] centerGuess = (max(x)+min(x))/2. span = max(x)-min(x) sigmaGuess = span/10. x_bg = np.concatenate((x[:10],x[10:])) y_bg = np.concatenate((y[:10],y[10:])) background = LinearModel() pars = background.guess(y_bg, x=x_bg) peak = LorentzianModel() pars.update( peak.make_params()) pars['center'].set(centerGuess)#,min=min(x),max=max(x)) pars['sigma'].set(sigmaGuess,max=span/2.) pars['amplitude'].set(signalGuess*sigmaGuess*np.pi,min=0.00000001) pars.add('signal', expr='amplitude/(sigma*pi)') pars.add('background', expr='intercept+slope*center') pars.add('contrast', expr='amplitude/(sigma*pi*background)') pars.add('centerDoubled', expr='2*center') pars.add('shift', expr='2*center-9192631770') pars.add('fwhmDoubled', expr='4*sigma') model = peak + background init = model.eval(pars, x=x) out = model.fit(y, pars, x=x) #print out.fit_report() return init,out
def add_peak(prefix, center, amplitude=0.005, sigma=0.05): peak = LorentzianModel(prefix=prefix) pars = peak.make_params() pars[prefix + 'center'].set(center) pars[prefix + 'amplitude'].set(amplitude) pars[prefix + 'sigma'].set(sigma, min=0) return peak, pars
def add_lz_peak(prefix: str, center: float, amplitude: float = 0.005, sigma: float = 0.05) -> Tuple[LorentzianModel, Parameters]: peak = LorentzianModel(prefix=prefix) pars = peak.make_params() pars[prefix + "center"].set(center) pars[prefix + "amplitude"].set(amplitude, min=0) pars[prefix + "sigma"].set(sigma, min=0) return peak, pars
def fitsample(data, theta_initial, theta_final): x = data[:,0] y = data[:,1] m = (x > theta_initial) & (x < theta_final) x_fit = x[m] y_fit = y[m] pseudovoigt1 = VoigtModel(prefix = 'pv1_') pars= pseudovoigt1.make_params() pars['pv1_center'].set(13.5, min = 13.4, max = 13.6) pars['pv1_sigma'].set(0.05, min= 0.01, max = 0.1) pars['pv1_amplitude'].set(70, min = 1, max = 100) #pars['pv1_fraction'].set(0.5) lorentz2 = LorentzianModel(prefix = 'lor2_') pars.update(lorentz2.make_params()) pars['lor2_center'].set(13.60, min = 13.4, max = 13.9) pars['lor2_sigma'].set(0.1, min= 0.01) pars['lor2_amplitude'].set(10, min = 1, max = 50 ) #pars['lor2_fraction'].set(0.5) line1 = LinearModel(prefix ='l1_') pars.update(line1.make_params()) pars['l1_slope'].set(0) pars['l1_intercept'].set(240, min = 200, max = 280) mod = pseudovoigt1 + lorentz2 + line1 v = pars.valuesdict() result = mod.fit(y_fit, pars, x=x_fit) #print(result.fit_report()) pv1_pos = result.params['pv1_center'].value pv1_height = result.params['pv1_height'].value lor2_pos = result.params['lor2_center'].value lor2_height = result.params['lor2_height'].value #peak_area = pars['gau1_fwhm'].value*peak_amp #plt.xlim([theta_initial, theta_final]) #plt.ylim([100, 500]) #plt.semilogy(x_fit, y_fit, 'bo') #plt.semilogy (x_fit, result.init_fit, 'k--') #plt.semilogy(x_fit, result.best_fit, 'r-') #plt.show() return pv1_pos, pv1_height, lor2_pos, lor2_height
def fitDoubleLorentzian(x,y) : signalGuess = 0.5*(max(y)-min(y)) centerGuess = (max(x)+min(x))/2. span = max(x)-min(x) sigmaGuess = span/10. x_bg = np.concatenate((x[:10],x[10:])) y_bg = np.concatenate((y[:10],y[10:])) background = LinearModel() pars = background.guess(y_bg, x=x_bg) peak1 = LorentzianModel(prefix="p1_") pars.update(peak1.make_params()) pars['p1_center'].set(centerGuess,min=min(x),max=max(x)) pars['p1_sigma'].set(sigmaGuess,max=span/2.) pars['p1_amplitude'].set(signalGuess*sigmaGuess*np.pi,min=0.00000001) pars.add('p1_signal', expr='p1_amplitude/(p1_sigma*pi)') pars.add('background', expr='intercept+slope*p1_center') pars.add('p1_contrast', expr='p1_amplitude/(p1_sigma*pi*background)') pars.add('p1_centerDoubled', expr='2*p1_center') pars.add('p1_shift', expr='2*p1_center-9192631770') pars.add('p1_fwhmDoubled', expr='4*p1_sigma') peak2 = LorentzianModel(prefix="p2_") pars.update(peak2.make_params()) pars['p2_center'].set(centerGuess,min=min(x),max=max(x)) pars.add('broadScale',value=2.0, min=1.9, max=100.0) pars['p2_sigma'].set(sigmaGuess*2,max=span/2.,expr='p1_sigma*broadScale') pars['p2_amplitude'].set(signalGuess*sigmaGuess*np.pi,min=0.00000001) pars.add('p2_signal', expr='p2_amplitude/(p2_sigma*pi)') pars.add('p2_contrast', expr='p2_amplitude/(p2_sigma*pi*background)') pars.add('p2_centerDoubled', expr='2*p2_center') pars.add('p2_shift', expr='2*p2_center-9192631770') pars.add('p2_fwhmDoubled', expr='4*p2_sigma') model = peak1 + peak2 + background init = model.eval(pars, x=x) out = model.fit(y, pars, x=x) print out.fit_report() return init,out
def fitTwoLorentzians(x,y): background = PolynomialModel(2) pars = background.make_params() peak1 = LorentzianModel(prefix='p1_') pars.update( peak1.make_params()) peak2 = LorentzianModel(prefix='p2_') pars.update( peak2.make_params()) # Guess some parameters from data to help the fitting span = max(x)-min(x) c1Guess = (y[-1]-y[0])/(x[-1]-x[0]) c0Guess = y[0]-c1Guess*x[0] bgGuess = background.func(x=x,c0=c0Guess,c1=c1Guess,c2=0) signalGuess=min(y-bgGuess) sigmaGuess = span/50. amplitudeGuess = signalGuess*(sigmaGuess*np.pi) # Fit variables initialization pars.add('splitting',value=min(x)+span*0.56,min=0.0000001,max=max(x)-min(x)) pars['c2'].set(0.) pars['c1'].set(c1Guess) pars['c0'].set(c0Guess) pars['p1_center'].set(min(x)+span*0.45,min=min(x),max=max(x)) pars['p2_center'].set(min(x)+span*0.55,expr='p1_center+splitting') # pars['p2_center'].set(min(x)+span*0.55,min=min(x),max=max(x)) pars['p1_amplitude'].set(amplitudeGuess,max=amplitudeGuess/100.) pars['p2_amplitude'].set(amplitudeGuess,max=amplitudeGuess/100.) pars['p1_sigma'].set(sigmaGuess, min=sigmaGuess/1000.,max=sigmaGuess*1000.) pars['p2_sigma'].set(sigmaGuess, min=sigmaGuess/1000.,max=sigmaGuess*1000.) #Add some useful parameters to evaluate pars.add('p1_signal', expr='p1_amplitude/(p1_sigma*pi)') pars.add('p2_signal', expr='p2_amplitude/(p2_sigma**pi)') pars.add('p1_contrast', expr='-p1_amplitude/(p1_sigma*pi*(c0+c1*p1_center+c2*p1_center**2))') pars.add('p2_contrast', expr='-p2_amplitude/(p2_sigma*pi*(c0+c1*p2_center+c2*p2_center**2))') model = peak1 + peak2 + background init = model.eval(pars, x=x) out = model.fit(y, pars, x=x) print out.fit_report() return init,out
def test_PeakLogicFiles_add_lz_peak(mocker): TEST_PREFIX = "test" TEST_CENTER = -0.4 EXPECTED_PEAK = LorentzianModel(prefix="test") EXPECTED_PARAMS = EXPECTED_PEAK.make_params( center=-0.4, amplitude=0.005, sigma=0.05 ) mocker.patch("SWV_AnyPeakFinder.SWV_AnyPeakFinder.PeakFinderApp") app = swv.PeakFinderApp() logic = swv.PeakLogicFiles(app) _, actual_params = logic.add_lz_peak(TEST_PREFIX, TEST_CENTER) # assert EXPECTED_PEAK == actual_peak # FIXME assert EXPECTED_PARAMS == actual_params
def make_lorentzian_model(self): """ This method creates a model of lorentzian with an offset. The parameters are: 'amplitude', 'center', 'sigma, 'fwhm' and offset 'c'. For function see: http://cars9.uchicago.edu/software/python/lmfit/builtin_models.html#models.LorentzianModel @return lmfit.model.CompositeModel model: Returns an object of the class CompositeModel @return object params: lmfit.parameter.Parameters object, returns an object of the class Parameters with all parameters for the lorentzian model. """ model = LorentzianModel() + ConstantModel() params = model.make_params() return model, params
def onclick(event): global X plt.clf() x = event.xdata y = event.ydata print('waint...') L1 = LorentzianModel(prefix='L1_') pars = L1.guess(psd, x=freq) pars.update(L1.make_params()) pars['L1_center'].set(x, min=x - 10, max=x + 10) #pars['L1_sigma'].set(y, min=0) pars['L1_amplitude'].set(y, min=0) out = L1.fit(psd, pars, x=freq) X = out.best_fit plt.title(str(ordem) + " Lorenzian fit") plt.ylabel('PSD[ppm$^2$/$\mu$Hz]') plt.xlabel('Frequency [$\mu$Hz]') plt.minorticks_on() plt.tick_params(direction='in', which='major', top=True, right=True, left=True, length=8, width=1, labelsize=15) plt.tick_params(direction='in', which='minor', top=True, right=True, length=5, width=1, labelsize=15) plt.tight_layout() plt.loglog(freq, psd, 'k', lw=0.5, alpha=0.5) plt.plot(freq, out.best_fit, 'k-', lw=0.5, alpha=0.5) plt.xlim(min(freq), max(freq)) plt.ylim(min(psd), max(psd)) plt.draw() print('Done')
def fit_lz_peaks(potentials, currents): min_y = float(min(currents)) model = QuadraticModel(prefix="Background") params = model.make_params() # a=0, b=0, c=0 params.add("a", 0, min=0) params.add("b", 0) params.add("c", 0, min=min_y) peak = LorentzianModel(prefix="peak") pars = peak.make_params() pars.add("center", -0.3) pars.add("amplitude", 0.005, min=0) pars.add("sigma", 0.05, min=0) model = model + peak params.update(pars) # _ = model.eval(params, x=potentials) # not needed result = model.fit(currents, params, x=potentials) comps = result.eval_components() return result.best_fit, float(max(comps["peak"]))
def test_convolution(): r"""Convolution of function with delta dirac should return the function""" # Reference Lorentzian parameter values amplitude = 42.0 sigma = 0.042 center = 0.0003 c1 = LorentzianModel(prefix='c1_') p = c1.make_params(amplitude=amplitude, center=center, sigma=sigma) c2 = DeltaDiracModel(prefix='c2_') p.update(c2.make_params(amplitude=1.0, center=0.0)) e = 0.0004 * np.arange(-250, 1500) # energies in meV # convolve Lorentzian with delta Dirac y1 = Convolve(c1, c2).eval(params=p, x=e) # should be the lorentzian # reverse order, convolve delta Dirac with Lorentzian y2 = Convolve(c2, c1).eval(params=p, x=e) # should be the lorentzian # We will fit a Lorentzian model against datasets y1 and y2 m = LorentzianModel() all_params = 'amplitude sigma center'.split() for y in (y1, y2): params = m.guess(y, x=e) # Set initial model Lorentzian parameters far from optimal solution params['amplitude'].set(value=amplitude * 10) params['sigma'].set(value=sigma * 4) params['center'].set(value=center * 7) # fit Lorentzian model against dataset y r = m.fit(y, params, x=e) # Compare the reference Lorentzian parameters against # parameters of the fitted model assert_allclose([amplitude, sigma, center], [r.params[p].value for p in all_params], rtol=0.01, atol=0.00001)
def fit_lorentzian(y: np.ndarray, x: np.ndarray) -> np.ndarray: """Fits profile to lorentzian. Used with np.apply_along_axis. Parameters ---------- y y values of profile to be fitted. Units: none. x x values of profiles to be fitted Units: Hz. Returns ------- result_params A numpy array of the returning parameters ['Center', 'HWHM', 'max height', 'chi sq']. Units: [same as x, same as x, None, None]. """ model = LorentzianModel() center_guess = x[y.argmax()] HWHM_guess = x[y.argmax()] / 1000 params = model.make_params(amplitude=y.max() * np.pi * HWHM_guess, center=center_guess, sigma=HWHM_guess) result = model.fit(y, params, x=x) result_params = np.array([ result.params["center"].value, result.params["sigma"].value, result.params["height"].value, result.chisqr, ]) return result_params
def calculateQ_2peaks(filename, time, taper, lambda0, slope, modulation_coefficient, rg): q = readlvm(filename) q = q.ravel() q = q / taper - 1 valley = q.min() valley_index = np.argmin(q) max_height = -1 * q[valley_index] q_valley = q[valley_index - rg:valley_index + rg] l_valley = time[valley_index - rg:valley_index + rg] q_valley = q_valley * -1 peaks, peak_info = find_peaks(q_valley, height=max_height * 0.6, prominence=0.05, distance=50) #results_half = peak_widths(q_valley, peaks, rel_height=0.5) if len(peaks) != 2: print("Wrong peaks with num:", len(peaks)) return None, None, None, None, None, None x = np.asarray(list(range(0, 2 * rg))) y = q_valley # One peak guess to get width g_mod = LorentzianModel() g_pars = g_mod.guess(y, x=x) g_out = g_mod.fit(y, g_pars, x=x) g_res = g_out.fit_report() g_info = g_res.split("\n") g_variables = parse_info(g_info, 1) guessedWidth = float(g_variables['fwhm']) / 2 exp_mod = ExponentialModel(prefix='exp_') pars = exp_mod.guess(y, x=x) lorenz1 = LorentzianModel(prefix='l1_') pars.update(lorenz1.make_params()) pars['l1_center'].set(peaks[0]) pars['l1_sigma'].set(guessedWidth) pars['l1_amplitude'].set(np.pi * guessedWidth * q_valley[peaks[0]]) lorenz2 = LorentzianModel(prefix='l2_') pars.update(lorenz2.make_params()) pars['l2_center'].set(peaks[1]) pars['l2_sigma'].set(guessedWidth) pars['l2_amplitude'].set(np.pi * guessedWidth * q_valley[peaks[1]]) mod = lorenz1 + lorenz2 + exp_mod init = mod.eval(pars, x=x) out = mod.fit(y, pars, x=x) res = out.fit_report() info = res.split("\n") variables = parse_info(info, 2) l1_h_res, l1_w_res, l1_c_res = variables['l1_height'], variables[ 'l1_fwhm'], variables['l1_center'] print(l1_h_res, l1_w_res, l1_c_res) l1 = lambda0 + l_valley[int( float(l1_c_res))] * slope * modulation_coefficient d_lambda1 = (l_valley[1] - l_valley[0] ) * float(l1_w_res) * slope * modulation_coefficient Q1 = l1 / d_lambda1 l2_h_res, l2_w_res, l2_c_res = variables['l2_height'], variables[ 'l2_fwhm'], variables['l2_center'] print(l2_h_res, l2_w_res, l2_c_res) l2 = lambda0 + l_valley[int( float(l2_c_res))] * slope * modulation_coefficient d_lambda2 = (l_valley[1] - l_valley[0] ) * float(l2_w_res) * slope * modulation_coefficient Q2 = l2 / d_lambda2 return Q1, float(l1_h_res) * 100, l1, Q2, float(l2_h_res) * 100, l2
profile.subplot(221) strctural.imshow(figure=profile.fig, title="Structural Image") profile.subplot(223) xmcd.imshow(figure=profile.fig, title="XMCD Image") # Make a histogram of the intesity values hist = xmcd.hist(bins=200) hist.column_headers = ["XMCD Signal", "Frequency"] hist.labels = None hist.fig = profile.fig # Construct a two Lorentzian peak model peak1 = LorentzianModel(prefix="peak1_") peak2 = LorentzianModel(prefix="peak2_") params = peak1.make_params() params.update(peak2.make_params()) double_peak = peak1 + peak2 def guess(self, data, **kwargs): """Function to guess the parameters of two Lorentzian peaks.""" x = kwargs.get("x") l = len(data) i1 = np.argmax(data[:l // 2]) # Location of first peak i2 = np.argmax(data[l // 2:]) + l // 2 params = self.make_params() for k, p in zip( params, [
for filename in files: x, y = np.loadtxt(direc + filename, unpack=True) x = 1239.8 / x if counter == 5: filtro_total = filtro_3 * filtro_2 * filtro_1 #*filtro_feno y = (y - a) * filtro_total #Imprimo para llevar un control por la terminal print(filename) #Semillas que se dan iterativamente pars = L0_mod.make_params(center=center[0], amplitude=amplitude[0], sigma=sigma[0]) pars += L1_mod.make_params(center=center[1], amplitude=amplitude[1], sigma=sigma[1]) pars += L2_mod.make_params(center=center[2], amplitude=amplitude[2], sigma=sigma[2]) #pars+=L3_mod.make_params(center=center[3], amplitude= amplitude[3], sigma=sigma[3]) #pars+=L4_mod.make_params(center=center[4], amplitude= amplitude[4], sigma=sigma[4]) #pars+=L5_mod.make_params(center=center[5], amplitude= amplitude[5], sigma=sigma[5]) pars += c_mod.make_params(intercept=c, slope=slope) #pars+=c_mod.make_params(c=c) #Defino funcion
def fitModel(x, y, t1, t2, t3, t4, t5, t6, n, c1, c2, c3, c4, c5, c6, chck1, chck2, chck3): fitType1 = t1 fitType2 = t2 fitType3 = t3 fitType4 = t4 fitType5 = t5 fitType6 = t6 numPk = n cen = (c1, c2, c3, c4, c5, c6) fitstats = chck1 eqWidth = chck2 eqBeta = chck3 Lin1 = LinearModel(prefix='BackG_') pars = Lin1.make_params() pars['BackG_slope'].set(0) #, min=-0.001, max=0.001) pars['BackG_intercept'].set(2e7, min=0) if fitType1 == 'Lorentzian': pk1 = LorentzianModel(prefix='Peak1_') elif fitType1 == 'Gaussian': pk1 = GaussianModel(prefix='Peak1_') elif fitType1 == 'PseudoVoigt': pk1 = PseudoVoigtModel(prefix='Peak1_') elif fitType1 == 'GND': pk1 = gndModel(prefix='Peak1_') if fitType2 == 'Lorentzian': pk2 = LorentzianModel(prefix='Peak2_') elif fitType2 == 'Gaussian': pk2 = GaussianModel(prefix='Peak2_') elif fitType2 == 'PseudoVoigt': pk2 = PseudoVoigtModel(prefix='Peak2_') elif fitType2 == 'GND': pk2 = gndModel(prefix='Peak2_') if fitType3 == 'Lorentzian': pk3 = LorentzianModel(prefix='Peak3_') elif fitType3 == 'Gaussian': pk3 = GaussianModel(prefix='Peak3_') elif fitType3 == 'PseudoVoigt': pk3 = PseudoVoigtModel(prefix='Peak3_') elif fitType3 == 'GND': pk3 = gndModel(prefix='Peak3_') if fitType4 == 'Lorentzian': pk4 = LorentzianModel(prefix='Peak4_') elif fitType4 == 'Gaussian': pk4 = GaussianModel(prefix='Peak4_') elif fitType4 == 'PseudoVoigt': pk4 = PseudoVoigtModel(prefix='Peak4_') elif fitType4 == 'GND': pk4 = gndModel(prefix='Peak4_') if fitType5 == 'Lorentzian': pk5 = LorentzianModel(prefix='Peak5_') elif fitType5 == 'Gaussian': pk5 = GaussianModel(prefix='Peak5_') elif fitType5 == 'PseudoVoigt': pk5 = PseudoVoigtModel(prefix='Peak5_') elif fitType5 == 'GND': pk5 = gndModel(prefix='Peak5_') if fitType6 == 'Lorentzian': pk6 = LorentzianModel(prefix='Peak6_') elif fitType6 == 'Gaussian': pk6 = GaussianModel(prefix='Peak6_') elif fitType6 == 'PseudoVoigt': pk6 = PseudoVoigtModel(prefix='Peak6_') elif fitType6 == 'GND': pk6 = gndModel(prefix='Peak6_') pars.update(pk1.make_params()) pars['Peak1_center'].set(cen[0], min=cen[0] - 10, max=cen[0] + 10) pars['Peak1_sigma'].set(20, min=0.01, max=50) pars['Peak1_amplitude'].set(1e7, min=0) if fitType1 == 'GND': pars['Peak1_beta'].set(1.5, min=1, max=2) if numPk == 2 or numPk == 3 or numPk == 4 or numPk == 5 or numPk == 6: pars.update(pk2.make_params()) pars['Peak2_center'].set(cen[1], min=cen[1] - 10, max=cen[1] + 10) pars['Peak2_amplitude'].set(1e7, min=0) if eqWidth == 1: pars['Peak2_sigma'].set(expr='Peak1_sigma') elif eqWidth == 0: pars['Peak2_sigma'].set(30, min=0.01, max=50) if fitType2 == 'GND': if eqBeta == 1: pars['Peak2_beta'].set(expr='Peak1_beta') elif eqBeta == 0: pars['Peak2_beta'].set(1.5, min=1, max=2) if numPk == 3 or numPk == 4 or numPk == 5 or numPk == 6: pars.update(pk3.make_params()) pars['Peak3_center'].set(cen[2], min=cen[2] - 10, max=cen[2] + 10) pars['Peak3_amplitude'].set(1e7, min=0) if eqWidth == 1: pars['Peak3_sigma'].set(expr='Peak1_sigma') elif eqWidth == 0: pars['Peak3_sigma'].set(30, min=0.01, max=50) if fitType2 == 'GND': if eqBeta == 1: pars['Peak3_beta'].set(expr='Peak1_beta') elif eqBeta == 0: pars['Peak3_beta'].set(1.5, min=1, max=2) if numPk == 4 or numPk == 5 or numPk == 6: pars.update(pk4.make_params()) pars['Peak4_center'].set(cen[3], min=cen[3] - 10, max=cen[3] + 10) pars['Peak4_sigma'].set(15, min=0.01, max=50) pars['Peak4_amplitude'].set(1e7, min=0) if fitType4 == 'GND': pars['Peak4_beta'].set(1.5, min=1, max=2) if numPk == 5 or numPk == 6: pars.update(pk5.make_params()) pars['Peak5_center'].set(cen[4], min=cen[4] - 10, max=cen[4] + 10) pars['Peak5_sigma'].set(15, min=0.01, max=50) pars['Peak5_amplitude'].set(1e7, min=0) if fitType5 == 'GND': pars['Peak5_beta'].set(1.5, min=1, max=2) if numPk == 6: pars.update(pk6.make_params()) pars['Peak6_center'].set(cen[5], min=cen[5] - 10, max=cen[5] + 10) pars['Peak6_sigma'].set(15, min=0.01, max=50) pars['Peak6_amplitude'].set(1e7, min=0) if fitType6 == 'GND': pars['Peak6_beta'].set(1.5, min=1, max=2) #model definition pkModel = Lin1 if numPk == 2: pkModel += pk1 + pk2 elif numPk == 3: pkModel += pk1 + pk2 + pk3 elif numPk == 4: pkModel += pk1 + pk2 + pk3 + pk4 elif numPk == 5: pkModel += pk1 + pk2 + pk3 + pk4 + pk5 elif numPk == 6: pkModel += pk1 + pk2 + pk3 + pk4 + pk5 + pk6 out = pkModel.fit(y, pars, x=x, weights=1.0 / y) if fitstats == 1: print('\n', out.fit_report(show_correl=False)) plt.figure(dpi=150, figsize=(3.5, 2.8)) lwid = 2 #plt.title('Radial Intensity distribution',fontsize=16) plt.plot(x, y, label='data', lw=2) plt.plot(x, out.best_fit, 'r-', lw=lwid, label='fit') plt.xlabel('Angle (\xb0)', fontsize=16) plt.ylabel('Intensity (a.u.)', fontsize=16) plt.xticks([0, 90, 180, 270, 360], fontsize=14) plt.locator_params('y', nbins=6) plt.ticklabel_format(axis='y', style='sci', scilimits=(0, 0)) plt.yticks(fontsize=14) plt.tight_layout() plt.minorticks_on() #plt.legend(fontsize=10) plot_components = True if plot_components: comps = out.eval_components(x=x) plt.plot(x, comps['Peak1_'] + comps['BackG_'], 'c--', lw=lwid) plt.plot(x, comps['Peak2_'] + comps['BackG_'], 'b--', lw=lwid) if numPk == 3: plt.plot(x, comps['Peak3_'] + comps['BackG_'], 'y--', lw=lwid) if numPk == 4: plt.plot(x, comps['Peak3_'] + comps['BackG_'], 'y--', lw=lwid) plt.plot(x, comps['Peak4_'] + comps['BackG_'], 'g--', lw=lwid) if numPk == 5: plt.plot(x, comps['Peak3_'] + comps['BackG_'], 'y--', lw=lwid) plt.plot(x, comps['Peak4_'] + comps['BackG_'], 'g--', lw=lwid) plt.plot(x, comps['Peak5_'] + comps['BackG_'], 'm--', lw=lwid) if numPk == 6: plt.plot(x, comps['Peak3_'] + comps['BackG_'], 'y--', lw=lwid) plt.plot(x, comps['Peak4_'] + comps['BackG_'], 'g--', lw=lwid) plt.plot(x, comps['Peak5_'] + comps['BackG_'], 'm--', lw=lwid) plt.plot(x, comps['Peak6_'] + comps['BackG_'], 'k--', lw=lwid) plt.plot(x, comps['BackG_'], 'r--', lw=lwid) #plt.title('Radial Intensity Distribution', fontsize=14) #plt.xlabel('Angle (\xb0)', fontsize=28) #plt.ylabel('Intensity (a.u.)', fontsize=28) #plt.show() yBestFit = out.best_fit - comps['BackG_'] return out, yBestFit
c = 856.0 for filename in files: x, y = np.loadtxt(direction + filename, unpack=True) inicio = ind = list(abs(x - 805)).index(np.nanmin(abs(x - 805))) ind = list(abs(x - 815)).index(np.nanmin(abs(x - 815))) cavity_y = y[ind:] cavity_x = x[ind:] y = y[inicio:ind] x = x[inicio:ind] #Semillas que se dan iterativamente pars = L0_mod.make_params(center=center, amplitude=amplitude, sigma=sigma) pars += L1_mod.make_params(center=center1, amplitude=amplitude1, sigma=sigma1) pars2 = L2_mod.guess(cavity_y, x=cavity_x) pars += c_mod.make_params(c=c) pars2 += c2_mod.make_params(c=c) #bound_parameters_sigma(pars,2,5) #Defino funcion mod = L0_mod + c_mod + L1_mod #+ L2_mod mod2 = L2_mod + c2_mod #Fiteo out = mod.fit(y, pars, x=x)
center2= 810.5 amplitude= 5000 amplitude1= 300 amplitude2= 300 sigma=0.4 sigma1=0.15 sigma2= 0.4 c=856.0 for filename in files: x,y = np.loadtxt(direction + filename, unpack=True) pars= L0_mod.make_params(center=center+1.0, amplitude=amplitude, sigma=sigma) pars+=L1_mod.make_params(center=center1, amplitude= amplitude1, sigma=sigma1) pars+=L2_mod.make_params(center=center2, amplitude= amplitude2, sigma=sigma2, max=2*sigma2 ) pars+=c_mod.make_params(c=c) mod =L0_mod + c_mod + L1_mod + L2_mod #Aparecen picos extra a partir de estos archivos if float(filename)>=20.50: if float(filename)==20.50: pars+=L3_mod.make_params(center= center1-0.5, amplitude= amplitude1, sigma=sigma1) pars+=L4_mod.make_params(center=center2-1.5, amplitude= amplitude2, sigma=sigma2) else: pars+=L3_mod.make_params(center= center3, amplitude= amplitude3, sigma=sigma3) pars+=L4_mod.make_params(center=center4, amplitude= amplitude4, sigma=sigma4)
def find_grain_diameter(X, Y, min_size, max_size, size_step, return_figure, peaks_params, is_bg_active): """ New parameters are stored in peaks_params. The old ones are still present to provide compatibility with old code. :param X: :param Y: :param min_size: :param max_size: :param size_step: :param center: :param gamma_0: :param peak_height: :param return_figure: :param sample_type: :param peaks_params: [[center, gamma_0, amplitude, from, to, is_visible, is_lorentz, is fano], ...] :return: """ best_d = -1 best_sigma = -1 best_center = -1 best_amplitude = -1 best_q = 5 X_ex = X max_y = max(Y) x_range = (X > 400) * (X < 600) lin_mod = LinearModel(prefix="background_", min=0, max=0.5 * max_y) pars = lin_mod.guess(Y, x=X) final_mod = lin_mod for ii in range(0, len(peaks_params)): if peaks_params[ii][6] == True: mod = LorentzianModel(prefix="l" + str(ii) + '_') pars.update(mod.make_params()) pars['l' + str(ii) + '_center'].set(peaks_params[ii][0], min=peaks_params[ii][3], max=peaks_params[ii][4]) pars['l' + str(ii) + '_sigma'].set(peaks_params[ii][1]) pars['l' + str(ii) + '_amplitude'].set(peaks_params[ii][2], min=0) #, max=max_y) elif peaks_params[ii][7] == True: mod = Model(fano_function) pars.update(mod.make_params()) pars['q'].set( -4, min=-20, max=0 ) #q may be negative as well as positive, the most common values for q: [-1,5] pars['center'].set(peaks_params[ii][0], vary=True) pars['sigma'].set(peaks_params[ii][1], min=0.1, vary=True) pars['amplitude'].set(peaks_params[ii][2], min=0) else: mod = Model( total_intensity_fit_func ) #total_intensity_fit_func(omega, d, N, center, gamma_0, amplitude) pars.update(mod.make_params()) pars['d'].set((max_size - min_size), min=min_size, max=max_size) pars['N'].set(100, vary=False) pars['center'].set(peaks_params[ii][0], vary=False) pars['sigma'].set(peaks_params[ii][1], vary=False) pars['amplitude'].set(peaks_params[ii][2], min=0, max=max_y) final_mod = final_mod + mod ###########PLOT & RETURN###################################### if return_figure: my_figure = plt.Figure() my_plot = my_figure.add_subplot(111) legend_labels = [] for ax in my_figure.axes: ax.set_xlabel(u'\u03C9' + ' [cm^-1]') ax.set_ylabel('Intensity [arb.]') my_plot.plot(X[x_range], Y[x_range], "ro") legend_labels.append('Data') out = final_mod.fit(Y[x_range], pars, x=X[x_range]) if not out.success: print("!!!!!!!!!!!!!FIT HAVE FAILED!!!!!!!!!!!") legend_labels = ['FIT FAILED!'] if return_figure: my_plot.legend(legend_labels) return best_d, best_sigma, best_center, best_amplitude, my_figure else: return best_d, best_sigma, best_center, best_amplitude elif not return_figure: if (peaks_params[0][6] == True): best_sigma = out.best_values['l' + str(0) + '_sigma'] best_center = out.best_values['l' + str(0) + '_center'] best_amplitude = out.best_values['l' + str(0) + '_amplitude'] return 0, best_sigma, best_center, best_amplitude elif (peaks_params[0][7] == True): best_sigma = out.best_values['sigma'] best_center = out.best_values['center'] best_amplitude = out.best_values['amplitude'] best_q = out.best_values['q'] print(best_q) return best_q, best_sigma, best_center, best_amplitude else: best_sigma = out.best_values['sigma'] best_center = out.best_values['center'] best_amplitude = out.best_values['amplitude'] best_d = out.best_values['d'] print(best_d) return best_d, best_sigma, best_center, best_amplitude else: print(out.fit_report(min_correl=0.5)) legend_labels.append('Best fit') my_plot.plot(X[x_range], out.best_fit, "b-") my_plot.plot( X[x_range], out.best_values['background_slope'] * X[x_range] + out.best_values['background_intercept'], '--') legend_labels.append('background') for jj in range(0, len(peaks_params)): if (peaks_params[jj][6] == True): sigma = out.best_values['l' + str(jj) + '_sigma'] center = out.best_values['l' + str(jj) + '_center'] amplitude = out.best_values['l' + str(jj) + '_amplitude'] legend_labels.append('l' + str(jj)) my_plot.plot( X[x_range], lorentzian(X[x_range], center=center, sigma=sigma, amplitude=amplitude), '--') elif (peaks_params[jj][7] == True): sigma = out.best_values['sigma'] center = out.best_values['center'] amplitude = out.best_values['amplitude'] q = out.best_values['q'] legend_labels.append('fano; q=' + str(q)) my_plot.plot( X[x_range], fano_function(X[x_range], q, center, sigma, amplitude), '--') else: sigma = out.best_values['sigma'] center = out.best_values['center'] amplitude = out.best_values['amplitude'] d = out.best_values['d'] N = out.best_values['N'] legend_labels.append('fc; d=' + str(d)) my_plot.plot( X[x_range], total_intensity_fit_func(X[x_range], d, N, center, sigma, amplitude), '--') if (peaks_params[0][7] == True): my_figure.suptitle( "q:{0:.1f}[nm] omega:{1:.4f}[cm^-1] sigma:{2:.4f}[cm^-1] inten:{3:.4}[arb]" .format(float(best_q), float(best_center), float(best_sigma), float(best_amplitude))) else: my_figure.suptitle( "d:{0:.1f}[nm] omega:{1:.4f}[cm^-1] sigma:{2:.4f}[cm^-1] inten:{3:.4}[arb]" .format(float(best_d), float(best_center), float(best_sigma), float(best_amplitude))) my_plot.legend(legend_labels, loc=2) return best_d, best_sigma, best_center, best_amplitude, my_figure
profile.subplot(221) strctural.imshow(figure=profile.fig, title="Structural Image") profile.subplot(223) xmcd.imshow(figure=profile.fig, title="XMCD Image") # Make a histogram of the intesity values hist = xmcd.hist(bins=200) hist.column_headers = ["XMCD Signal", "Frequency"] hist.labels = None hist.fig = profile.fig # Construct a two Lorentzian peak model peak1 = LorentzianModel(prefix="peak1_") peak2 = LorentzianModel(prefix="peak2_") params = peak1.make_params() params.update(peak2.make_params()) double_peak = peak1 + peak2 def guess(self, data, **kwargs): """Function to guess the parameters of two Lorentzian peaks.""" x = kwargs.get("x") l = len(data) i1 = np.argmax(data[: l // 2]) # Location of first peak i2 = np.argmax(data[l // 2 :]) + l // 2 params = self.make_params() for k, p in zip( params, [
def fit_lorentizans(x, y, p1, n=1, make_fit=True): sub_models = [] for i in range(n): prefix = 'l' + str(i + 1) + '_' li = LorentzianModel(prefix=prefix) if i == 0: parameters = li.make_params() else: parameters.update(li.make_params()) A = p1[i] sigma = p1[2 * n + i] center = p1[n + i] sigmap = sigma / 2 Ap = A * pi * sigmap parameters[prefix + 'center'].set(center) parameters[prefix + 'amplitude'].set(Ap) parameters[prefix + 'sigma'].set(sigmap) sub_models += [li] mod = sub_models[0] for i in range(1, n): mod += sub_models[i] init = mod.eval(parameters, x=x) if not make_fit: return p1, [0 for i in range(3 * n)], init out = mod.fit(y, parameters, x=x) #print out.result.params.var_names var_names = out.result.var_names error_bars0 = {} for i in var_names: ii = var_names.index(i) error_bar = sqrt(out.result.covar[ii][ii]) error_bars0.update({i: error_bar}) result = out.values fit = [0 for i in range(3 * n)] error_bars = [0 for i in range(3 * n)] for i in range(n): Ap = result['l' + str(i + 1) + '_amplitude'] sigmap = result['l' + str(i + 1) + '_sigma'] center = result['l' + str(i + 1) + '_center'] Ap_bar = error_bars0['l' + str(i + 1) + '_amplitude'] center_bar = error_bars0['l' + str(i + 1) + '_center'] sigmap_bar = error_bars0['l' + str(i + 1) + '_sigma'] A = Ap / pi / sigmap sigma = 2 * sigmap covar = out.result.covar[n * i][n * i + 2] A_bar = A * sqrt((Ap_bar / Ap)**2 + (sigmap_bar / sigmap)**2 - 2 * covar / Ap / sigmap) / pi sigma_bar = 2 * sigmap_bar fit[i] = A fit[n + i] = center fit[2 * n + i] = sigma error_bars[i] = A_bar error_bars[n + i] = center_bar error_bars[2 * n + i] = sigma_bar fitted_curve = out.best_fit return fit, error_bars, fitted_curve