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$)')
