def pyfxcor(inspec, template, vmin=-200., vmax=200., res=3, rej=1000): rv, cc = pyasl.crosscorrRV(inspec[0], inspec[1], template[0], template[1], vmin, vmax, res, skipedge=rej) cen_gs = np.argmax(cc) perfx, perfy = rv[cen_gs - 5:cen_gs + 6], cc[cen_gs - 5:cen_gs + 6] try: gauss = ConstantModel() + GaussianModel() pars = gauss.make_params() pars['center'].set(value=rv[np.argmax(cc)], vary=True) pars['amplitude'].set(value=max(cc), vary=True) pars['sigma'].set(vary=True) pars['c'].set(value=0, vary=True) out = gauss.fit(perfy, pars, x=perfx) ct = out.best_values['center'] cterr = out.params['center'].stderr except: return 'error', '' return ct, cterr
def fit_peaks( x, y, peak_pos, bg="constant", sigma_guess=2, center_pm=20, sigma_min=0.5, amplitude_max_m=3.0, bg_pm=100, ): mod = ConstantModel() for i, p in enumerate(peak_pos): mod += LorentzianModel(prefix="p%s_" % i) pars = mod.make_params() for i, p in enumerate(peak_pos): pars["p%s_center" % i].set(p, min=p - center_pm, max=p + center_pm) pars["p%s_sigma" % i].set(sigma_guess, min=sigma_min) # pars['p%s_amplitude' % i].set(10**2, min=0.0) pars["p%s_amplitude" % i].set( amplitude_max_m * y[find_nearest_index(x, p)], min=0.0 ) pars["c"].set(0, min=-1 * bg_pm, max=bg_pm) out = mod.fit(y, pars, x=x, method="leastsq") out.peak_pos = peak_pos return out
def fitgaussian_sample(sample, components, svg, verbose, center, cmin, cmax, amp, amin, sigma, smin): '''Fits gaussian curve to dyad coverage for a single sample.''' print('Fits gaussian curve to dyad coverage of sample {}'.format(sample)) input = sample + '-dyad.txt' dyads = pd.read_csv(input, sep='\t', index_col=0, comment='#') x = dyads.index.values y = dyads['Relative Frequency'].values if not amp: amp = dyads['Relative Frequency'].max() * 100 if not center: center = 0.0 if not sigma: sigma = dyads.index.max() / 2 plt.figure() plt.title(sample) plt.xlabel('Position relative to dyad (bp)') plt.ylabel('Relative Frequency') plt.xlim(x[0], x[len(x) - 1]) plt.xticks(list(range(x[0], x[len(x) - 1] + 1, 25))) plt.plot(dyads.index.values, dyads['Relative Frequency'].values, color='red') plot_output = sample + '-dyad-gaussian.png' try: constant = ConstantModel(prefix='c_') pars = constant.make_params() pars['c_c'].set(value=dyads['Relative Frequency'].min(), min=0.0, max=dyads['Relative Frequency'].max()) gauss = GaussianModel(prefix='g_') pars.update(gauss.make_params()) pars['g_center'].set(value=center, min=cmin, max=cmax) pars['g_sigma'].set(value=sigma, min=smin) pars['g_amplitude'].set(value=amp, min=amin) mod = constant + gauss init = mod.eval(pars, x=x) out = mod.fit(y, pars, x=x) if components: plt.plot(x, init, 'b--', label='Initial fit') if verbose: print(out.fit_report(min_correl=0.5)) plt.plot(x, out.best_fit, 'b-', label='Best fit') if components: comps = out.eval_components(x=x) plt.plot(x, np.repeat(comps['c_'], len(x)), 'g--', label='Constant component') plt.plot(x, comps['g_'], 'm--', label='Gaussian component') except Exception as e: logging.warning( 'could not fit gaussian curve to sample {}'.format(sample), e) if components: plt.legend(loc='lower right') plt.savefig(plot_output) if svg: plot_svg_output = sample + '-dyad-gaussian.svg' plt.savefig(plot_svg_output, transparent=True) plt.close()
def fit_s21mag(x_val, y_val): peak = GaussianModel() offset = ConstantModel() model = peak + offset pars = offset.make_params(c=np.median(y_val)) pars += peak.guess(y_val, x=x_val, amplitude=-0.5) result = model.fit(y_val, pars, x=x_val) return result
def model(self): """Returns the sum of all peak models.""" model = ConstantModel(prefix="BASE_") model.set_param_hint("c", vary=False, value=0) self.params += model.make_params() for peak in self._peaks: model += peak.model return model
def fit_s21mag(x_val, y_val): x_val_midpoint = int(np.round(len(x_val) / 2)) peak = GaussianModel() offset = ConstantModel() model = peak + offset pars = offset.make_params(c=np.median(y_val)) pars += peak.guess(y_val, x=x_val, amplitude=-0.05, center=x_val[x_val_midpoint]) result = model.fit(y_val, pars, x=x_val) return result
def FitSpectrumInit(self, label): """ Fit the spectrum with the fit params of another spectrum (given by label) as initial values. Useful when you fit big number of similar spectra. """ borders = np.genfromtxt(label + '/spectrumborders_' + label + '.txt', unpack=True) np.savetxt(self.label + '/spectrumborders_' + self.label + '.txt', borders) self.y = self.y[(self.x > borders[0]) & (self.x < borders[-1])] self.x = self.x[(self.x > borders[0]) & (self.x < borders[-1])] FitData = np.load(label + '/fitparams_' + label + '.npz') baseline = FitData['c'] / self.maxyvalue ctr = FitData['x0'] sigma = FitData['sigma'] gamma = FitData['gamma'] ramanmodel = ConstantModel() ramanmodel.set_param_hint('c', value=baseline[0], min=0) for i in range(len(sigma)): prefix = 'p' + str(i + 1) tempvoigt = Model(func=voigt, prefix=prefix) tempvoigt.set_param_hint(prefix + 'x0', value=ctr[i], min=0) tempvoigt.set_param_hint(prefix + 'sigma', value=sigma[i], min=0) tempvoigt.set_param_hint(prefix + 'gamma', value=gamma[i], min=0) tempvoigt.set_param_hint(prefix + 'height', expr='wofz(((0) + 1j*' + prefix + 'gamma) / ' + prefix + 'sigma / sqrt(2)).real') tempvoigt.set_param_hint(prefix + 'fwhm', expr='0.5346 * 2 *' + prefix + 'gamma + sqrt(0.2166 * (2*' + prefix + 'gamma)**2 + (2 * ' + prefix + 'sigma * sqrt(2 * log(2) ) )**2 )') ramanmodel += tempvoigt pars = ramanmodel.make_params() fitresult = ramanmodel.fit(self.y, pars, x=self.x, scale_covar=True) plt.clf() comps = fitresult.eval_components() xplot = np.linspace(self.x[0], self.x[-1], 1000) plt.plot(self.x, self.y * self.maxyvalue, 'r-') plt.plot(self.x, fitresult.best_fit * self.maxyvalue) for i in range(0, len(sigma)): plt.plot( self.x, comps['p' + str(i + 1)] * self.maxyvalue + comps['constant'] * self.maxyvalue, 'k-') plt.savefig(self.label + '/rawplot_' + self.label + '.pdf') save_modelresult(fitresult, self.label + '/modelresult_' + self.label + '.sav') plt.clf()
class CModel(Model): """docstring for CModel""" def __init__(self, nexp=0, moddef=" "): self.definition = moddef self.model = ConstantModel() self.nexp = 0 self.errors = None self.params = None self.res = None for _ in range(nexp): self.add_exp() def add_exp(self): self.nexp += 1 self.model += ExponentialModel(prefix=Prefixes[self.nexp]) def prep_params(self): amp = '{}amplitude' dec = '{}decay' cntrl_expr = 'c' self.model.set_param_hint('c', value=1.0, min=0) for i in range(1, self.nexp + 1): currA = amp.format(Prefixes[i]) currT = dec.format(Prefixes[i]) self.model.set_param_hint(currA, value=1.0, min=0) self.model.set_param_hint(currT, value=1.0, min=0) cntrl_expr += ' + ' + currA self.params = self.model.make_params() self.params.add('cntrl', value=1, min=1 - 1e-5, max=1 + 1e-5) self.params['cntrl'].vary = True self.params['cntrl'].expr = cntrl_expr def fit(self, *args, **kwargs): try: self.prep_params() self.res = self.model.fit(params=self.params, *args, **kwargs) except Exception as e: print("Undefined exception while fit: {} {}".format(type(e), e), file=sys.stderr) raise return self.res def has_covar(self): covar = self.res.covar if covar is None or np.isnan(np.sum(covar)): return False else: return True def report(self): return self.res.fit_report(), self.res.covar
def FitSpectrum(self): """ Fit Spectrum with initial values provided by SelectBaseline() and SelectPeaks() """ polyparams = self.Fitbaseline(self) base = polyparams[0].n ramanmodel = ConstantModel() ramanmodel.set_param_hint('c', value=base, min=0) globwidth = 1 xpeak, ypeak = np.genfromtxt(self.peakfile, unpack=True) if type(xpeak) == np.float64: xpeak = [xpeak] ypeak = [ypeak] for i in range(0, len(xpeak)): prefix = 'p' + str(i + 1) tempvoigt = Model(func=voigt, prefix=prefix) tempvoigt.set_param_hint(prefix + 'x0', value=xpeak[i], min=0) tempvoigt.set_param_hint(prefix + 'sigma', value=globwidth, min=0) tempvoigt.set_param_hint(prefix + 'gamma', value=globwidth, min=0) tempvoigt.set_param_hint(prefix + 'height', value=ypeak[i], expr='wofz(((0) + 1j*' + prefix + 'gamma) / ' + prefix + 'sigma / sqrt(2)).real') tempvoigt.set_param_hint(prefix + 'fwhm', expr='0.5346 * 2 *' + prefix + 'gamma + sqrt(0.2166 * (2*' + prefix + 'gamma)**2 + (2 * ' + prefix + 'sigma * sqrt(2 * log(2) ) )**2 )') ramanmodel += tempvoigt pars = ramanmodel.make_params() fitresult = ramanmodel.fit(self.y, pars, x=self.x, scale_covar=True) print(fitresult.fit_report(min_correl=0.5)) comps = fitresult.eval_components() xplot = np.linspace(self.x[0], self.x[-1], 1000) plt.plot(self.x, self.y * self.maxyvalue, 'rx') plt.plot(self.x, fitresult.best_fit * self.maxyvalue) for i in range(0, len(xpeak)): plt.plot( self.x, comps['p' + str(i + 1)] * self.maxyvalue + comps['constant'] * self.maxyvalue, 'k-') plt.show() plt.savefig(self.label + '/rawplot_' + self.label + '.pdf') save_modelresult(fitresult, self.label + '/modelresult_' + self.label + '.sav')
def fit_peak_df(df, model=GaussianModel, params=None, fit_range=(-np.inf, np.inf), x_field=None, fit_field='nphe2_mean', out_field='peak_fit'): """ Fits DataFrame with selected peak model. Appends residuals column to DataFrame. """ # Data fit_min, fit_max = fit_range df_ranged = df[(df.index > fit_min) & (df.index < fit_max)] if x_field: x = np.array(df_ranged[x_field]) full_x = np.array(df[x_field]) else: x = np.array(df_ranged.index.get_values()) full_x = np.array(df.index.get_values()) y = np.array(df_ranged[fit_field].values) full_y = np.array(df[fit_field].values) # Models if isinstance(model, str): try: model = PEAK_MODELS[model] except KeyError: print("Undefined model: {}, using default".format(model)) peak_mod = model(prefix='peak_') const_mod = ConstantModel(prefix='const_') result_model = const_mod + peak_mod # Parameters if not params: pars = const_mod.make_params(c=y.min()) pars += peak_mod.guess(y, x=x, center=0) else: pars = params # Fitting result = result_model.fit(y, params=pars, x=x) peak_eval = result.eval(x=full_x) y_res = full_y - peak_eval df[out_field] = pd.Series(peak_eval, index=df.index) df[out_field + '_res'] = pd.Series(y_res, index=df.index) return df, result
def gaussian_fit(self, x, y, paras=None, method=None): g1model = GaussianModel(prefix='g1_') g2model = GaussianModel(prefix='g2_') g3model = GaussianModel(prefix='g3_') cmodel = ConstantModel() paras_fit = g1model.guess(data=y, x=x) paras_fit.update(g2model.make_params()) paras_fit.update(g3model.make_params()) paras_fit['g1_amplitude'].set(min=0.) paras_fit['g2_amplitude'].set(min=0.) paras_fit['g3_amplitude'].set(min=0.) paras_fit['g1_center'].set(min=paras['g1_center'] - 300., value=paras['g1_center'], max=paras['g1_center'] + 300.) paras_fit['g2_center'].set(min=paras['g2_center'] - 300., value=paras['g2_center'], max=paras['g2_center'] + 300.) paras_fit['g3_center'].set(min=paras['g3_center'] - 300., value=paras['g3_center'], max=paras['g3_center'] + 300.) paras_fit['g1_sigma'].set(min=100, value=paras['g1_sigma'], max=paras['g1_sigma'] + 50.) paras_fit['g2_sigma'].set(min=100, value=paras['g2_sigma'], max=paras['g2_sigma'] + 50.) paras_fit['g3_sigma'].set(min=100, value=paras['g3_sigma'], max=paras['g3_sigma'] + 50.) paras_fit.update(cmodel.make_params()) model = g1model + g2model + g3model + cmodel result = model.fit(y, x=x, params=paras_fit, mothod=method) yfit = result.best_fit y_para = result.best_values residual = y - yfit return yfit, y_para, result, residual
def test_stepmodel_erf(): x, y = get_data() stepmod = StepModel(form='linear') const = ConstantModel() pars = stepmod.guess(y, x) pars = pars + const.make_params(c=3 * y.min()) mod = stepmod + const out = mod.fit(y, pars, x=x) assert (out.nfev > 5) assert (out.nvarys == 4) assert (out.chisqr > 1) assert (out.params['c'].value > 3) assert (out.params['center'].value > 1) assert (out.params['center'].value < 4) assert (out.params['amplitude'].value > 50) assert (out.params['sigma'].value > 0.2) assert (out.params['sigma'].value < 1.5)
def test_stepmodel_erf(): x, y = get_data() stepmod = StepModel(form='linear') const = ConstantModel() pars = stepmod.guess(y, x) pars = pars + const.make_params(c=3*y.min()) mod = stepmod + const out = mod.fit(y, pars, x=x) assert(out.nfev > 5) assert(out.nvarys == 4) assert(out.chisqr > 1) assert(out.params['c'].value > 3) assert(out.params['center'].value > 1) assert(out.params['center'].value < 4) assert(out.params['amplitude'].value > 50) assert(out.params['sigma'].value > 0.2) assert(out.params['sigma'].value < 1.5)
def make_multiplegaussian_model(self, no_of_gauss=None): """ This method creates a model of multiple gaussians 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 lmfit.parameter.Parameters params: Returns an object of the class Parameters with all parameters for the lorentzian model. """ model = ConstantModel() for ii in range(no_of_gauss): model += GaussianModel(prefix='gaussian{0}_'.format(ii)) params = model.make_params() return model, params
def pyfxcor(inspec, template, obj, vmin=-400., vmax=400., res=3, rej=200): rv, cc = pyasl.crosscorrRV(inspec[0], inspec[1], template[0], template[1], vmin, vmax, res, skipedge=rej) cen_gs = np.argmax(cc) perfx, perfy = rv[cen_gs-5:cen_gs+6], cc[cen_gs-5:cen_gs+6] try: gauss = ConstantModel() + GaussianModel() pars = gauss.make_params() pars['center'].set(value=rv[np.argmax(cc)], vary=True) pars['amplitude'].set(value=max(cc), vary=True) pars['sigma'].set(vary=True) pars['c'].set(value=0, vary=True) out = gauss.fit(perfy, pars, x=perfx) ct = out.best_values['center'] cterr = out.params['center'].stderr except: plt.plot(inspec[0], inspec[1]) plt.savefig(obj+'.png', dpi=300) pl.clf() return 'error', '' plt.subplot(311) plt.plot(rv, cc) curraxlim = plt.axis() out.plot_fit(numpoints=100) plt.axis(curraxlim) plt.subplot(312) plt.plot(obj[1][0], obj[1][1], 'r-', linewidth=0.5) plt.subplot(313) plt.plot(inspec[0], inspec[1], 'b-', linewidth=0.5) plt.savefig(obj[0]+'.png', dpi=300) plt.clf() return ct, cterr
def BuiltInModels(self) : FitInfo = self.FitInfo ModelString = list() for key in FitInfo['Models'] : ModelString.append((key,FitInfo['Models'][key]['model'])) for Model in ModelString : try : FitModel except : if Model[1] == 'Constant' : FitModel = ConstantModel(prefix=Model[0]+'_') if Model[1] == 'Linear' : FitModel = LinearModel(prefix=Model[0]+'_') if Model[1] == 'Gaussian' : FitModel = GaussianModel(prefix=Model[0]+'_') if Model[1] == 'SkewedGaussian' : FitModel = SkewedGaussianModel(prefix=Model[0]+'_') if Model[1] == 'Voigt' : FitModel = VoigtModel(prefix=Model[0]+'_') else : if Model[1] == 'Constant' : FitModel = FitModel + ConstantModel(prefix=Model[0]+'_') if Model[1] == 'Linear' : FitModel = FitModel + LinearModel(prefix=Model[0]+'_') if Model[1] == 'Gaussian' : FitModel = FitModel + GaussianModel(prefix=Model[0]+'_') if Model[1] == 'SkewedGaussian' : FitModel = FitModel + SkewedGaussianModel(prefix=Model[0]+'_') if Model[1] == 'Voigt' : FitModel = FitModel + VoigtModel(prefix=Model[0]+'_') self.FitModel = FitModel self.ModelParameters = FitModel.make_params()
def fit_double_gaussian_sample(sample, absolute=False, components=False, gaussian=False, svg=False, verbose=False, center1=None, cmin1=None, cmax1=None, amp1=None, amin1=None, sigma1=None, smin1=None, center2=None, cmin2=None, cmax2=None, amp2=None, amin2=None, sigma2=None, smin2=None, suffix=None): '''Fits double gaussian curve to dyad coverage for a single sample.''' print('Fits double gaussian curve to dyad coverage of sample {}'.format( sample)) input = sample + (suffix if suffix else '') + '-dyad.txt' dyads = pd.read_csv(input, sep='\t', index_col=0, comment='#') x = dyads.index.values yheader = 'Frequency' if absolute else 'Relative Frequency' y = dyads[yheader].values if not amp1: amp1 = dyads[yheader].max() * 50 if not center1: center1 = -dyads.index.max() / 4 if not sigma1: sigma1 = dyads.index.max() / 5 if not amp2: amp2 = dyads[yheader].max() * 50 if not center2: center2 = dyads.index.max() / 4 if not sigma2: sigma2 = dyads.index.max() / 5 plt.figure() plt.title(sample) plt.xlabel('Position relative to dyad (bp)') plt.ylabel('Frequency' if absolute else 'Relative Frequency') plt.xlim(x[0], x[len(x) - 1]) plt.xticks(list(range(x[0], x[len(x) - 1] + 1, 25))) plt.plot(x, y, color='red') plot_output = sample + (suffix if suffix else '') + '-dyad-double-gaussian.png' try: constant = ConstantModel(prefix='c_') pars = constant.make_params() pars['c_c'].set(value=dyads[yheader].min(), min=0.0, max=dyads[yheader].max()) gauss1 = GaussianModel(prefix='g1_') pars.update(gauss1.make_params()) pars['g1_center'].set(value=center1, min=cmin1, max=cmax1) pars['g1_sigma'].set(value=sigma1, min=smin1) pars['g1_amplitude'].set(value=amp1, min=amin1) gauss2 = GaussianModel(prefix='g2_') pars.update(gauss2.make_params()) pars['g2_center'].set(value=center2, min=cmin2, max=cmax2) pars['g2_sigma'].set(value=sigma2, min=smin2) pars['g2_amplitude'].set(value=amp2, min=amin2) mod = constant + gauss1 + gauss2 init = mod.eval(pars, x=x) out = mod.fit(y, pars, x=x) if components: plt.plot(x, init, 'b--', label='Initial fit') if verbose: print(out.fit_report(min_correl=0.5)) plt.plot(x, out.best_fit, 'b-', label='Best fit') if gaussian: comps = out.eval_components(x=x) constant_y = comps['c_'] plt.plot(x, [yv + constant_y for yv in comps['g1_']], 'm--', label='Gaussian 1') plt.plot(x, [yv + constant_y for yv in comps['g2_']], 'y--', label='Gaussian 2') if components: comps = out.eval_components(x=x) plt.plot(x, np.repeat(comps['c_'], len(x)), 'g--', label='Constant component') plt.plot(x, comps['g1_'], 'm--', label='Gaussian component 1') plt.plot(x, comps['g2_'], 'k--', label='Gaussian component 2') except Exception as e: logging.warning( 'could not fit double gaussian curve to sample {}'.format(sample), e) if components: plt.legend(loc='lower right') plt.savefig(plot_output) if svg: plot_svg_output = sample + (suffix if suffix else '') + '-dyad-double-gaussian.svg' plt.savefig(plot_svg_output, transparent=True) plt.close()
for j, d in enumerate(data): sigma = d[2] / 2 if sigma == np.nan: continue y = d[3:] x = arange(len(y)) y0 = np.mean([y[:200], y[-200:]]) x0 = ((y - y0) * x).sum() / (y - y0).sum() mod = GaussianModel() pars = mod.guess(y, x=x) pars['sigma'].set(sigma, min=5, max=4000) pars['center'].set(x0, min=200, max=6500) #pars['amplitude'].set(y.max()/sigma,min=1,max=60536) bg = ConstantModel() pars.update(bg.make_params()) pars['c'].set(y.min()) model = mod + bg try: out = model.fit(y, pars, x=x) except: continue print(out.fit_report(min_correl=0.25)) ax = subplot(n, m, j + 1) ax.tick_params(labelbottom='off') ax.tick_params(labelleft='off') plot(x, y, 'ob') plot(x, out.best_fit, '-r') res.append(out.params)
def lmfit_mngauss(x,y, *params): """ Fit multiple gaussians from two spectra that are multiplied together INPUT: x - is the wavelength array y - is the normalized flux params - is a tuple of 2 list/arrays of initial guess values for the each spectras parameters (this controls the number of gaussians to be fitted number of gaussians: len(params)/3 - 3 parameters per Gaussian) OUTPUT: mod - the lmfit model object used for the fit out - the lmfit fit object that contains all the results of the fit init- array with the initial guess model (usefull to see the initial guess when plotting) """ m_params = params[0] m_mods = [] prefixes = [] for i in range(0, len(m_params), 3): pref = "gm%02i_" % (i/3) gauss_i = GaussianModel(prefix=pref) if i == 0: pars = gauss_i.guess(y, x=x) else: pars.update(gauss_i.make_params()) A = m_params[i] l_cen = m_params[i+1] sigma = m_params[i+2] pars[pref+'amplitude'].set(A) pars[pref+'center'].set(l_cen) pars[pref+'sigma'].set(sigma) m_mods.append(gauss_i) prefixes.append(pref) m_mod = m_mods[0] if len(m_mods) > 1: for m in m_mods[1:]: m_mod += m m_one = ConstantModel(prefix="m_one_") prefixes.append("m_one_") pars.update(m_one.make_params()) pars['m_one_c'].set(value=1, vary=False) try: n_params = params[1] n_mods = [] #prefixes = [] for j in range(0, len(n_params), 3): pref = "gn%02i_" % (j/3) gauss_j = GaussianModel(prefix=pref) pars.update(gauss_j.make_params()) A = n_params[j] l_cen = n_params[j+1] sigma = n_params[j+2] pars[pref+'amplitude'].set(A) pars[pref+'center'].set(l_cen) pars[pref+'sigma'].set(sigma) n_mods.append(gauss_j) prefixes.append(pref) n_mod = n_mods[0] if len(n_mods) > 1: for n in n_mods[1:]: n_mod += n n_one = ConstantModel(prefix="n_one_") prefixes.append("n_one_") pars.update(n_one.make_params()) pars['n_one_c'].set(value=1, vary=False) mod = (m_one + m_mod) * (n_one + n_mod) except: print("Error with second spectra, only fitting first") mod = m_one + m_mod init = mod.eval(pars, x=x) out = mod.fit(y, pars, x=x) print("Printed prefixes", prefixes) #print(init) return mod, out, init
from qcodes.plots.qcmatplotlib import MatPlot from qcodes.plots.pyqtgraph import QtPlot from scipy.optimize import curve_fit import scipy.integrate as integrate import pandas as pd import matplotlib.pyplot as plt from lmfit.models import LorentzianModel, ConstantModel, GaussianModel pd_dat = pd.read_csv( 'Scripts and PPT Summary/CryoRX/2020-06-22/18-15-29_qtt_scan1D/RP1.dat', skiprows=[0, 2], delimiter='\t') xval = pd_dat['# "RP1"'] yval = pd_dat['S21mag'] peak = GaussianModel() offset = ConstantModel() model = peak + offset pars = offset.make_params(c=np.median(yval)) pars += peak.guess(yval, x=xval, amplitude=-0.5) result = model.fit(yval, pars, x=xval) x = [[1 + 1.j * 1], [1 + 1.j * 100]] print(np.mean(x)) print(abs(result.values['height'])) plt.plot(xval, yval) plt.plot(xval, result.best_fit, 'b--') plt.show()
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) mod +=L3_mod + L4_mod pass
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) out_cavity = mod2.fit(cavity_y, pars2, x=cavity_x) #Imprimo el archivo fit log fit_log.write("\n\n\n\n\n\n Fitted from: %s%s \n" % (direction, filename)) now = datetime.datetime.now() fit_log.write(
class CModel(Model): """docstring for CModel""" def __init__(self, nexp=0, sum_one=False): self.sum_one_flag = sum_one self.model = ConstantModel() self.nexp = 0 self.errors = None self.params = None self.res = None for _ in range(nexp): self.add_exp() def add_exp(self): self.nexp += 1 self.model += ExponentialModel(prefix=Prefixes[self.nexp]) def prep_params(self, tcf_type): if tcf_type == 'acf': self.prep_acfParams() elif tcf_type == 'ccf': self.prep_ccfParams() def prep_ccfParams(self): amp = '{}amplitude' dec = '{}decay' self.model.set_param_hint('c', value=1.0) for i in range(1, self.nexp + 1): currA = amp.format(Prefixes[i]) currT = dec.format(Prefixes[i]) self.model.set_param_hint(currA, value=1, min=-1.5, max=1.5) self.model.set_param_hint(currT, value=1, min=0) self.params = self.model.make_params() def prep_acfParams(self): amp = '{}amplitude' dec = '{}decay' cntrl_expr = ' ' if self.sum_one_flag: cntrl_expr = 'c' self.model.set_param_hint('c', value=1.0, min=0) for i in range(1, self.nexp + 1): currA = amp.format(Prefixes[i]) currT = dec.format(Prefixes[i]) self.model.set_param_hint(currA, value=1.0, min=0.0) self.model.set_param_hint(currT, value=1.0, min=0.0) if self.sum_one_flag: cntrl_expr += ' + ' + currA self.params = self.model.make_params() if self.sum_one_flag: self.params.add('cntrl', value= 1, max= 1+1e-5, min= 1-1e-5) self.params['cntrl'].vary = True self.params['cntrl'].expr = cntrl_expr def fit(self, tcf_type='acf', *args, **kwargs): try: self.prep_params(tcf_type) self.res = self.model.fit(params=self.params, *args, **kwargs) except Exception as e: print("Undefined exception while fit: {} {}".format(type(e), e), file=sys.stderr) raise return self.res def has_covar(self): covar = self.res.covar if covar is None or np.isnan(np.sum(covar)): return False else: return True def check_errors(self): for ivar, name in enumerate(self.res.var_names): par = self.res.params[name] if par.stderr / par.value > 1: return False return True def report(self): return self.res.fit_report(), self.res.covar