def __init__(self): #Configuration fitter_conf = None #Ready fitter self.fitter_lmfitLineal = models.LinearModel(prefix='lineal_')
def plot_ff(nfig, x, y, sigma_x, sigma_y, y0, sigma_y0, pcov, output_file=None): """ Plots strain. Parameters ---------- nfig : int x, y : array_like sigma_x, sigma_y : array_like y0 : float simga_y0 : array_like pov : numpy.array output_file : str or None, optional """ # compute fF f = (((y0 / y)**(2.0 / 3.0)) - 1.0) / 2.0 F = x / (3.0 * f * (1.0 + (2.0 * f))**(5.0 / 2.0)) sigma_vo = sigma_y0 eta = y / y0 sigeta = numpy.abs(eta) * ((((sigma_y / y)**2.0) + ((sigma_vo / y0)**2))**(1.0 / 2.0)) sigprime = ((7.0 * (eta**(-2.0 / 3.0)) - 5.0) * sigeta) / (2.0 * (1.0 - (eta**-2.0 / 3.0)) * eta) sigF = F * numpy.sqrt(((sigma_x / x)**2.0) + (sigprime**2)) # fit line to fF line_mod = models.LinearModel() pars = line_mod.guess(f) outf = line_mod.fit(F, pars, x=f) ff_slope = uct.ufloat(outf.params["slope"], outf.params["slope"].stderr) ff_inter = uct.ufloat(outf.params["intercept"], outf.params["intercept"].stderr) k_p = ((2.0 * ff_slope) / (3 * ff_inter)) + 4 # compute confidence ellipses n_params = len(pcov[0]) plt.figure(nfig) plt.plot(f, outf.best_fit, '-', color='black') plt.errorbar(f, F, fmt='ko', xerr=0, yerr=sigF, alpha=1.0, capsize=3.) plt.xlabel("Eulerian strain $\mathit{f_E}$", fontweight="bold") plt.ylabel("Normalized pressure $\mathbf{F_E}$ (GPa)", fontweight="bold") plt.tick_params(direction="in", bottom=1, top=1, left=1, right=1) plt.title("$\mathit{f_E}$-F", fontweight="bold") if output_file: plt.savefig(output_file, dpi=1800, bbox_inches="tight") plt.close()
def eval_local_baseline(peak): local_baseline_model = lmfit_models.LinearModel() params = local_baseline_model.make_params() params['intercept'].set(value = peak.params['intercept']) params['slope'].set(value = peak.params['slope']) return local_baseline_model.eval(params, x=peak.xxx)
def fit_linear_model(self): """Fit a linear model to the data.""" if self.data is not None: data = self.data model = models.LinearModel() fit = model.fit(data.y, x=data.x, weights=1 / data.yerr) self.text.setPlainText(fit.fit_report()) x = np.linspace(data.x.min(), data.x.max()) self.plot.plot(x, fit.eval(x=x), pen={'color': 'r'})
def linear(X, y): """ Sub-method to fit a Linear regression model. """ inds = np.argsort(X) X = X[inds] y = y[inds] model = models.LinearModel(independent_vars=['x'], nan_policy='propagate') fitted = model.fit(y, x=X) return fitted
def test_hints_for_peakmodels(self): # test that height/fwhm do not cause asteval errors. x = np.linspace(-10, 10, 101) y = np.sin(x / 3) + x/100. m1 = models.LinearModel(prefix='m1_') params = m1.guess(y, x=x) m2 = models.GaussianModel(prefix='m2_') params.update(m2.make_params()) _m = m1 + m2 # noqa: F841 param_values = {name: p.value for name, p in params.items()} self.assertTrue(param_values['m1_intercept'] < -0.0) self.assertEqual(param_values['m2_amplitude'], 1)
def get_model(model_name, model_prefix=''): if model_name == 'voigt': mdl = models.VoigtModel(prefix=model_prefix) elif model_name == 'gauss': mdl = models.GaussianModel(prefix=model_prefix) elif model_name == 'constant': mdl = models.ConstantModel(prefix=model_prefix) elif model_name == 'linear': mdl = models.LinearModel(prefix=model_prefix) elif model_name == 'exp': mdl = models.ExponentialModel(prefix=model_prefix) elif model_name == 'logistic': mdl = models.StepModel(prefix=model_prefix, form='logistic') elif model_name == 'sine': mdl = models.SineModel(prefix=model_prefix) else: raise ValueError('Model name not recognized.') return mdl
def find_peaks(data_ranges, settings, fev_per_epoch = 16, nepochs = 4, nmipmap=1): peak_model = make_peak_model(settings) local_baseline_model = lmfit_models.LinearModel() biased_peak_model = peak_model + local_baseline_model nslices = data_ranges.nslices(*step_and_span(settings), nmipmap=nmipmap) slices = data_ranges.slices(*step_and_span(settings), nmipmap=nmipmap) peaklist = [] #est_max_height = 1e-30 print('Searching for peaks...') for i, d in enumerate(slices): if settings.flag_verbose: print("%3.1f%%" % (float(i) / float(nslices) * 100.0), end='\r') sys.stdout.flush() if len(d) == 0 or len(d[:, 0]) == 0: continue offset = d[0, 0] xxx = d[:, 0] - offset yyy = d[:, 1] # initital peak guess params = peak_model.guess(yyy, x=xxx) params.add('slope', value=0.0) params.add('intercept', value=np.mean(yyy)) # peak fitting loop scipy_leastsq_sett = { 'maxfev': fev_per_epoch, 'ftol': 1e-5, 'xtol': 1e-5, } for n in range(0, nepochs): try: fit_out = biased_peak_model.fit(yyy, params, x = xxx, fit_kws = scipy_leastsq_sett) except: fit_out = None break params = fit_out.params fit_out.xxx = xxx fit_out.yyy = yyy fit_out.offset = offset if converged_peak(fit_out): break if not accept_peak(fit_out, settings): break if fit_out is None: continue # result of peak guess and fit if accept_peak(fit_out, settings): peaklist.append(fit_out) #if fit_out.params['height'] > est_max_height: # est_max_height = fit_out.params['height'] return peaklist
lEnergy = np.array([]) lPicked = np.array([]) scanNo = 6386 date = 20 picked = 0 #marcroFilename = "C:\\Users\\wvx67826\\Desktop\\beam8 data\\MapNight2.txt" energyCalFilename = "C:\\Users\\wvx67826\\Desktop\\beam8 data\\energycalibration_Ru.dat" backgroundFilename = "C:\\Users\\wvx67826\\Desktop\\beam8 data\\backgound_Flux.dat" folderName = "C:\\Users\\wvx67826\\Desktop\\beam8 data\\2019 12 %s\\" %date metaFilename = folderName +"CCD Scan %i\\C_%i-AI.txt" %(scanNo,scanNo) Rd.read_file(metaFilename, metaStopKey = str(scanNo)) metaData = Rd.get_data() from lmfit import models model_1 = models.GaussianModel(prefix='peak_') model_2 = models.LinearModel(prefix='background_') model = model_1 + model_2 #print np.full((1,50),macroData["BL 8 Energy"][0]) def onpick(event): thisline = event.artist xdata = thisline.get_xdata() ydata = thisline.get_ydata() ind = event.ind points = np.array([xdata[ind]]) global lPicked global picked
# # fit_results[ii] = model.fit(splitdata[ii], params, x=splitx[ii]) # plt.plot(splitx[ii],fit_results[ii].best_fit) # plt.plot(splitx[ii],fit_results[ii].best_fit) # # diff = np.abs(fit_results[ii].best_fit - splitdata[ii]) # maxdiff = np.max(diff) # # if maxdiff > threshold: # line_nb +=1 # idx = np.where(diff==maxdiff) # split_idx = np.append(split_idx,idx) # # maxdiff2 = 2 model = models.LinearModel() params = model.make_params() output1 = model.fit(pumped[-4:], params, x=fluence[-4:]) yfit1 = model.eval(output1.params, x=fluence) output2 = model.fit(pumped[14:17], params, x=fluence[14:17]) yfit2 = model.eval(output2.params, x=fluence) output3 = model.fit(pumped[:8], params, x=fluence[:8]) yfit3 = model.eval(output3.params, x=fluence) plt.figure() plt.errorbar(fluence, pumped, yerr=np.sqrt(unpumped / 10), fmt='o') plt.plot(fluence, yfit1) plt.plot(fluence, yfit2)
def fitData(x, y): peaks, _ = signal.find_peaks(y, height=0.01, width=5) print peaks model_1 = models.GaussianModel(prefix='m1_') model_2 = models.GaussianModel(prefix='m2_') model_3 = models.GaussianModel(prefix='m3_') model_4 = models.LinearModel(prefix='l3_') model_5 = models.LorentzianModel(prefix='m4_') model = model_1 + model_2 + model_3 + model_4 + model_5 model_1.set_param_hint("amplitude", min=0.002, max=0.1) model_1.set_param_hint("sigma", min=0.00, max=0.025) model_1.set_param_hint("center", min=x[peaks[1]] - 0.05, max=x[peaks[1]] + 0.05) params_1 = model_1.make_params(amplitude=0.05, center=x[peaks[1]], sigma=0.01) model_2.set_param_hint("amplitude", min=1e-5, max=1e-3) model_2.set_param_hint("sigma", min=0.0005, max=0.08) model_2.set_param_hint("center", min=x[peaks[2]] - 0.075, max=x[peaks[2]] + 0.075) params_2 = model_2.make_params(amplitude=0.005, center=x[peaks[2]], sigma=0.03) model_3.set_param_hint("amplitude", min=1e-6, max=1e-2) model_3.set_param_hint("sigma", min=0.005, max=0.08) model_3.set_param_hint("center", min=x[peaks[1]] - 0.05, max=x[peaks[1]] + 0.1) params_3 = model_3.make_params(amplitude=1e-3, center=x[peaks[1]] + 0.040, sigma=0.04) """ model_4.set_param_hint("intercept", min = 1e-15, max = np.min(y)*1.5) model_4.set_param_hint("slope", min = 1e-16)""" params_4 = model_4.make_params(slope=1e-9, intercept=np.min(y)) model_5.set_param_hint("amplitude", min=1e-6, max=0.06) model_5.set_param_hint("sigma", min=0.00, max=0.025) model_5.set_param_hint("center", min=x[peaks[0]] - 0.05, max=x[peaks[0]] + 0.05) params_5 = model_5.make_params(amplitude=0.05, center=x[peaks[0]], sigma=0.01) params_1.update(params_2) params_1.update(params_3) params_1.update(params_4) params_1.update(params_5) params = params_1 output = model.fit(y, params, x=x) print output.fit_report() output.plot(data_kws={'markersize': 1}) plt.plot(x, y) plt.semilogy() plt.show(block=False) return output
import pandas as pd import numpy as np import matplotlib.pyplot as plt from lmfit import models spectrum_cs = pd.read_csv('Cs137_spectrum.csv') spectrum_cs['y_err'] = np.sqrt(spectrum_cs['counts']) sel1 = spectrum_cs.query('pulseheight >= 1000 and pulseheight <= 1500') model = models.GaussianModel() + models.LinearModel() fit = model.fit(sel1['counts'], x=sel1['pulseheight'], weights=1/sel1['y_err'], center=1200, slope=0) # fit.plot(numpoints=100) center_cs = fit.params['center'] # print(center_cs.value, center_cs.stderr) spectrum_na = pd.read_csv('Na22_spectrum.csv') spectrum_na['y_err'] = np.sqrt(spectrum_na['counts']) sel2 = spectrum_na.query('pulseheight >= 800 and pulseheight <= 1200') fit2 = model.fit(sel2['counts'], x=sel2['pulseheight'], weights=1/sel2['y_err'], center=980, sigma=40, amplitude=1000, slope=0) # fit2.plot(numpoints=100) center_na_1 = fit2.params['center'] # print(center_na_1.value, center_na_1.stderr) sel3 = spectrum_na.query('pulseheight >= 2200 and pulseheight <= 2700') fit3 = model.fit(sel3['counts'], x=sel3['pulseheight'], weights=1/sel3['y_err'], center=2400, sigma=40, amplitude=110, slope=0) # fit3.plot(numpoints=100) center_na_2 = fit3.params['center']
def fit_peak(self, roi=None, xpeak=None, sigma_guess=None, model_name='gauss-erf-const', **kwargs): """ Main routine """ # Exit if no roi if roi is None: self.fit = None self.model_name = None else: self.model_name = model_name # Start timer tic = time.time() # --------- # Setup ROI # --------- self.set_roi(roi) x = self.get_x_roi() y = self.get_y_roi() y_sig = self.get_y_sig_roi() x_widths = self.get_x_widths_roi() # --------------------------- # Guesses based on input data # --------------------------- # Set peak center to center of ROI if not given if xpeak is None: xpeak = (x[0] + x[-1]) / 2. # Guess sigma if not provided if sigma_guess is None: fwhm_guess = self.guess_fwhm(xpeak) sigma_guess = fwhm_guess / FWHM_SIG_RATIO # Heights at the sides of the ROI left_shelf_height = y[0] right_shelf_height = y[-1] # Line guess lin_slope = (y[-1] - y[0]) / (x[-1] - x[0]) lin_intercept = y[0] - lin_slope * x[0] # Two peaks guess (33 and 66 percent through ROI) xpeak0 = x[0] + (x[-1] - x[0]) * 0.33 xpeak1 = x[0] + (x[-1] - x[0]) * 0.66 # Index of at the ROI center ix_half = int(round(float(len(x)) / 2.)) # ------------------- # Setup fitting model # ------------------- if model_name == 'gauss-erf-const': # Models erf_mod = models.StepModel(form='erf', prefix='erf_') gauss_mod = models.GaussianModel(prefix='gauss_') bk_mod = models.ConstantModel(prefix='bk_') # Initialize parameters pars = erf_mod.make_params() pars.update(gauss_mod.make_params()) pars.update(bk_mod.make_params()) # Erfc (sigma and center are locked to gauss below) pars['erf_amplitude'].set(right_shelf_height - left_shelf_height, max=0.) # Gauss pars['gauss_center'].set( xpeak ) # , min=xpeak - 2 * fwhm_guess, max=xpeak + 2 * fwhm_guess) pars['gauss_sigma'].set(sigma_guess) pars['gauss_amplitude'].set(np.sum(y * x_widths), min=0) # Background pars['bk_c'].set(left_shelf_height, min=0.) # Same center and sigma pars.add('erf_center', expr='gauss_center') pars.add('erf_sigma', expr='gauss_sigma * {}'.format(FWHM_SIG_RATIO)) self.model = gauss_mod + erf_mod + bk_mod elif model_name == 'double-gauss-line': # Models lin_mod = models.LinearModel(prefix='lin_') g0_mod = models.GaussianModel(prefix='gauss0_') g1_mod = models.GaussianModel(prefix='gauss1_') # Initialize parameters pars = lin_mod.make_params() pars.update(g0_mod.make_params()) pars.update(g1_mod.make_params()) # Line (background) pars['lin_slope'].set(lin_slope, max=0.) pars['lin_intercept'].set(lin_intercept) # Gauss 0 (left) pars['gauss0_center'].set( xpeak0 ) # , min=xpeak - 2 * fwhm_guess, max=xpeak + 2 * fwhm_guess) pars['gauss0_sigma'].set(sigma_guess) pars['gauss0_amplitude'].set(np.sum(y[:ix_half] * x_widths[:ix_half]), min=0) # Gauss 1 (right) pars['gauss1_center'].set( xpeak1 ) # , min=xpeak - 2 * fwhm_guess, max=xpeak + 2 * fwhm_guess) pars['gauss1_sigma'].set(sigma_guess) pars['gauss1_amplitude'].set(np.sum(y[ix_half:] * x_widths[ix_half:]), min=0) self.model = lin_mod + g0_mod + g1_mod else: raise NotImplementedError( 'Model ({}) not recognized'.format(model_name)) # ----------- # Perform fit # ----------- try: self.fit = self.model.fit(y, pars, x=x, weights=1. / y_sig) except: print("[ERROR] Couldn't fit peak") self.fit = None if self.verbosity > 0: print('Fit time: {:.3f} seconds'.format(time.time() - tic))
df['inv_U'] = 1 / df['U'] df['inv_R'] = 1 / df['R'] df['err_inv_U'] = df['err_U'] / df['U'] * df['inv_U'] df['err_inv_R'] = df['err_R'] / df['R'] * df['inv_R'] df['I'] = df['U'] / df['R'] df['err_I'] = df['I'] * np.sqrt((df['err_U'] / df['U']) ** 2 + (df['err_R'] / df['R']) ** 2) print(df.head()) f = lambda R, R_u, U_0: R / (R_u + R) * U_0 mod_spanning = models.Model(f, name="Spanningsdeler") mod_linear = models.LinearModel() fit = mod_linear.fit(df['I'], x=df['U'], weights=1/df['err_I']) #fit = mod_linear.fit(df['inv_U'], x=df['inv_R'], weights=1/df['err_inv_U']) #fit = mod_spanning.fit(df['U'], R=df['R'], weights=1/df['err_U'], R_u=1, U_0=1) #df.plot.scatter('R', 'U', xerr='err_R', yerr='err_U') #fit.plot(ylabel='U (V)', xlabel='R ($\Omega$)') #plt.xlim(0, 350) #plt.ylim(0, 0.7) #plt.xlabel('R ($\Omega$)') #plt.ylabel('U (V)') df.plot.scatter('inv_R', 'inv_U', xerr='err_inv_R', yerr='err_inv_U') #fit.plot(ylabel='1/U (1/V)', xlabel='1/R (1/$\Omega$)') #plt.xlabel('1/R (1/$\Omega$)')