def test_custom_independentvar():
"""Tests using a non-trivial object as an independent variable."""
npts = 501
xmin = 1
xmax = 21
cen = 8
obj = Stepper(xmin, xmax, npts)
y = gaussian(obj.get_x(), amplitude=3.0, center=cen, sigma=2.5)
y += np.random.normal(scale=0.2, size=npts)
gmod = Model(gaussian_mod)
params = gmod.make_params(amplitude=2, center=5, sigma=8)
out = gmod.fit(y, params, obj=obj)
assert (out.nvarys == 3)
assert (out.nfev > 10)
assert (out.chisqr > 1)
assert (out.chisqr < 100)
assert (out.params['sigma'].value < 3)
assert (out.params['sigma'].value > 2)
assert (out.params['center'].value > xmin)
assert (out.params['center'].value < xmax)
assert (out.params['amplitude'].value > 1)
assert (out.params['amplitude'].value < 5)
def test_custom_independentvar():
"""Tests using a non-trivial object as an independent variable."""
npts = 501
xmin = 1
xmax = 21
cen = 8
obj = Stepper(xmin, xmax, npts)
y = gaussian(obj.get_x(), amplitude=3.0, center=cen, sigma=2.5)
y += np.random.normal(scale=0.2, size=npts)
gmod = Model(gaussian_mod)
params = gmod.make_params(amplitude=2, center=5, sigma=8)
out = gmod.fit(y, params, obj=obj)
assert(out.nvarys == 3)
assert(out.nfev > 10)
assert(out.chisqr > 1)
assert(out.chisqr < 100)
assert(out.params['sigma'].value < 3)
assert(out.params['sigma'].value > 2)
assert(out.params['center'].value > xmin)
assert(out.params['center'].value < xmax)
assert(out.params['amplitude'].value > 1)
assert(out.params['amplitude'].value < 5)
def fitGompertz(x, y, dias): # fit a logistic function~
def Gompertz(a, b, c, x):
return a * np.exp(-1 * np.exp(-b * (x - c)))
model = Model(Gompertz, independent_vars=["x"])
params = model.make_params()
params["a"].value = 10000
params["b"].value = 0.05
params["c"].value = 100
output = model.fit(y, params, x=x)
amplitude = output.params["a"].value
amplitude = math.floor(amplitude)
center = output.params["c"].value
sigma = output.params["b"].value
fit = []
xfit = []
cumulative = []
for i in range(61, dias):
if i == 61:
xfit.append(i)
value = amplitude * np.exp(-1 * np.exp(-sigma * (i - center)))
fit.append(value)
cumulative.append(0)
else:
xfit.append(i)
value = amplitude * np.exp(-1 * np.exp(-sigma * (i - center)))
fit.append(value)
c = value - fit[i - 62]
cumulative.append(c)
return amplitude, center, sigma, xfit, fit, cumulative, output.fit_report()
def _fit_echo(self):
fit_start, fit_end = self._get_region()
df = self.data_in_range[(self.data_in_range.index > fit_start)
& (self.data_in_range.index < fit_end)]
# Fit arrays
fit_variable = self._graph_select.currentText() + '_mean'
x = np.array(df.index.get_values())
if self._fit_res_checkbox.isChecked():
y = df['peak_fit_res'] + self.c.best_val
else:
y = df[fit_variable]
params = Parameters()
params.add_many(
('y0', self.y0.param.value, self.y0.param.vary, self.y0.param.min,
self.y0.param.max),
('A', self.A.param.value, self.A.param.vary, self.A.param.min,
self.center.param.max),
('t2', self.t2.param.value, self.t2.param.vary, self.t2.param.min,
self.t2.param.max),
)
model = Model(echo_decay_curve, independent_vars=['x'])
result = model.fit(y, x=x, params=params)
all_time = np.linspace(0.1,
self.data_in_range.index.get_values().max(),
2000)
# plot data
self.echo_fit_line.set_data(x, echo_decay_curve(x=x, **result.values))
self.echo_fit_extended_line.set_data(
all_time, echo_decay_curve(x=all_time, **result.values))
# Подсчитываем данные
t2 = result.values['t2']
t2_stderr = result.params.get('t2').stderr
# Ширина линии в MHz
delta_f = 10**6 / (np.pi * result.values['t2'])
delta_f_stderr = delta_f * t2_stderr / t2
self._ax.set_title(
"$T_2$: {:0.2f} $\pm$ {:0.2f} $ps$ ({:0.2f} $\pm$ {:0.2f} $MHz$ )".
format(t2, t2_stderr, delta_f, delta_f_stderr))
# refresh canvas and rescale
self._ax.relim()
self._ax.autoscale_view()
# update plot
self._fitting_figure.canvas.draw()
self._fitting_figure.canvas.flush_events()
# Populating report
self.fit_report_text.append(result.fit_report())
# Populating spinboxes
self.y0.from_res(result)
self.A.from_res(result)
self.t2.from_res(result)
def fit_signal(signal,l):
x1=np.linspace(0,1,len(signal))
piecewiseModel=Model(piecewise_prob)
piecewiseModel.set_param_hint('l', value=1,vary=False)
piecewiseModel.set_param_hint('C', vary=True, value=.1,min=0,max=1)
piecewiseModel.make_params()
res=piecewiseModel.fit(signal,x=x1,weights=np.sin(1.5*x1)+1.5)
return res
def lmfit_gaussian(x_array, y_array, err_array, x_boundarys):
# Find indeces for six points in spectrum
idcsW = np.searchsorted(x_array, x_boundarys)
# Emission region
idcsEmis = (x_array[idcsW[2]] <= x_array) & (x_array <= x_array[idcsW[3]])
# Return left and right continua merged in one array
idcsCont = (((x_array[idcsW[0]] <= x_array) &
(x_array <= x_array[idcsW[1]])) |
((x_array[idcsW[4]] <= x_array) &
(x_array <= x_array[idcsW[5]]))).squeeze()
emisWave, emisFlux = x_array[idcsEmis], y_array[idcsEmis]
contWave, contFlux = x_array[idcsCont], y_array[idcsCont]
idx_peak = np.argmax(emisFlux)
fit_model = Model(linear_model, prefix=f'{lineLabel}_cont_')
fit_model.set_param_hint(f'{lineLabel}_cont_slope', **{
'value': 0,
'vary': False
})
fit_model.set_param_hint(f'{lineLabel}_cont_intercept', **{
'value': contFlux.mean(),
'vary': False
})
fit_model += Model(gaussian_model, prefix=f'{lineLabel}_')
fit_model.set_param_hint(f'{lineLabel}_amp',
value=emisFlux[idx_peak] - contFlux.mean())
fit_model.set_param_hint(f'{lineLabel}_center', value=emisWave[idx_peak])
fit_model.set_param_hint(f'{lineLabel}_sigma', value=1.0)
x_fit = x_array[idcsEmis + idcsCont]
y_fit = y_array[idcsEmis + idcsCont]
w_fit = 1.0 / err_array[idcsEmis + idcsCont]
fit_params = fit_model.make_params()
obs_fit_output = fit_model.fit(y_fit, fit_params, x=x_fit, weights=w_fit)
# amp = obs_fit_output.params[f"{lineLabel}_amp"].value
mu = obs_fit_output.params[f"{lineLabel}_center"].value
sigma = obs_fit_output.params[f"{lineLabel}_sigma"].value
mu_err = obs_fit_output.params[f"{lineLabel}_center"].stderr
sigma_err = obs_fit_output.params[f"{lineLabel}_sigma"].stderr
x_obs, y_obs = obs_fit_output.userkws['x'], obs_fit_output.data
wave_obs = np.linspace(x_obs[0], x_obs[-1], 500)
flux_comps_obs = obs_fit_output.eval_components(x=wave_obs)
flux_obs = flux_comps_obs.get(f'{lineLabel}_cont_',
0.0) + flux_comps_obs[f'{lineLabel}_']
return x_fit, y_fit, wave_obs, flux_obs, mu, sigma, mu_err, sigma_err
def fitgaussian_lmfit(x,
y,
weights,
return_fit=True,
return_uncertainties=False):
try:
# noinspection PyUnresolvedReferences
from lmfit.models import Model, GaussianModel
except ImportError:
print(' Need module lmfit to use fitgauss_lmfit')
# calculate guess
mod = GaussianModel()
params = mod.guess(y, x=x)
guess = np.array([
params['height'].value, params['center'].value, params['sigma'].value,
0.0
])
# set up model fit
gmodel = Model(gauss_function)
# run model fit
out = gmodel.fit(y,
x=x,
a=guess[0],
x0=guess[1],
sigma=guess[2],
dc=guess[3],
params=None,
weights=weights)
# extract out parameters
pfit = [
out.values['a'], out.values['x0'], out.values['sigma'],
out.values['dc']
]
# extract out standard errors
siga = [
out.params['a'].stderr, out.params['x0'].stderr,
out.params['sigma'].stderr, out.params['dc'].stderr
]
# return
if return_fit and return_uncertainties:
return np.array(pfit), np.array(siga), out.best_fit
elif return_uncertainties:
return np.array(pfit), np.array(siga)
elif return_fit:
return np.array(pfit), out.best_fit
else:
return np.array(pfit)
def _calc_fit_start_dep_curve(self):
t2_array = []
t2_var_array = []
x_array = []
# Fit value
fit_variable_name = self._graph_select.currentText()
for start_fit_from in self.means[DELAY_TITLE]:
start_fit_from = float(start_fit_from)
fit_means = self.means[start_fit_from < self.means[DELAY_TITLE]]
fit_std = self.std[start_fit_from < self.std[DELAY_TITLE]]
params = self._init_params()
model = Model(echo_decay_curve, independent_vars=['x'])
try:
result = model.fit(fit_means[fit_variable_name],
x=fit_means[DELAY_TITLE],
params=params,
weights=1 / fit_std[LASER_TITLE]**2)
t2_array.append(result.params.get('t2').value)
t2_var_array.append(result.params.get('t2').stderr)
x_array.append(start_fit_from)
except TypeError:
break
ax = self._fitting_stats_figure.add_subplot(111)
ax.errorbar(x_array,
t2_array,
yerr=t2_var_array,
fmt='--bo',
capthick=2,
ecolor='b',
alpha=0.9)
ax.set_xlim([-10, 100])
ax.set_ylim([0, 2000])
ax.set_title("Зависимость $T_2$ от точки старта фитирования")
# refresh canvas and tight layout
self._fitting_stats_canvas.draw()
self._fitting_stats_figure.tight_layout()
self._fit_stats = True
# Adding to fit report
self.fit_report_text.append(
"Зависимость t2 от точки старта фитирования:\n")
self.fit_report_text.append(" ".join(
"{:.4f}: {:.2f}".format(x, y) for x, y in zip(x_array, t2_array)))
self.fit_report_text.append("\n")
def fit_residuals(df, start_fit_from=0.4, fit_field='fit_lorenz_res', init_params=None):
"""
Fits residuals with EchoDecay curve
"""
x = np.array(df[df.index > start_fit_from].index.get_values())
y = np.array(df[df.index > start_fit_from][fit_field].values)
echo_model = Model(echo_decay_curve, independent_vars=['x'])
if init_params:
params = init_params
else:
params = _init_echo_params(0, 500, 50)
result = echo_model.fit(y, x=x, params=params)
full_x = np.array(df.index.get_values())
res_fit_eval = result.eval(x=full_x)
df['res_echo_fit'] = pd.Series(res_fit_eval, index=df.index)
return df, result
### Korem fit
# fit piecewise using least squares (LM)
piecewiseModel=Model(piecewiseLinear)
piecewiseModel.set_param_hint('Ol', value=0.5*genomeLen,vary=True,min=0,max=genomeLen)
#piecewiseModel.set_param_hint('Tl', value=0.6*genomeLen,vary=True,min=0,max=genomeLen)
piecewiseModel.set_param_hint('Tc', value = np.median(np.log2(y1)), vary=True)
piecewiseModel.set_param_hint('Oc', value = np.median(np.log2(y1)), vary=True)
piecewiseModel.set_param_hint('delta', value = 0.545*genomeLen, min=0.45*genomeLen, max=0.55*genomeLen, vary=True)#,expr='Tl-Ol if Tl-Ol > 0 else Ol-Tl')
#piecewiseModel.set_param_hint('Tl', value=0.6*genomeLen,vary=True,min=0,max=genomeLen,expr='mod(Ol+delta,genLen)')
piecewiseModel.set_param_hint('genLen', vary=False, value=genomeLen)
piecewiseModel.make_params()
result=piecewiseModel.fit(np.log2(y1),x=x1)
resR2=R2(result.best_fit,y1)
# var=np.var(abs(np.log2(y1)-result.best_fit), dtype=np.float64)
#med=np.median(np.log2(y1))
# y1=[value for value in y1 if (np.log2(value) < med+1.45*np.sqrt(var)) & (np.log2(value)>med-1.45*np.sqrt(var))]
# x1=np.linspace(0,genomeLen-1,len(y1))
# piecewiseModel=Model(piecewiseLinear)
# piecewiseModel.set_param_hint('Ol', value=0.3*genomeLen,vary=True,min=0,max=genomeLen)
# piecewiseModel.set_param_hint('Tl', value=0.6*genomeLen,vary=True,min=0,max=genomeLen)
# piecewiseModel.set_param_hint('Tc', value = np.median(np.log2(y1)), vary=True)
# piecewiseModel.set_param_hint('Oc', value = np.median(np.log2(y1)), vary=True)
# #piecewiseModel.set_param_hint('delta', value = 0.5*genomeLen, min=0.45*genomeLen, max=0.55*genomeLen, vary=True,expr='fabs(Tl-Ol)')
# piecewiseModel.set_param_hint('delta', value = 0.5*genomeLen,expr='fabs(Tl-Ol)')
'vary': False
})
fit_model += Model(gaussian_model, prefix=f'{lineLabel}_')
fit_model.set_param_hint(f'{lineLabel}_amplitude',
value=obsLm.peak_flux - obsLm.cont)
fit_model.set_param_hint(f'{lineLabel}_center', value=obsLm.peak_wave)
fit_model.set_param_hint(f'{lineLabel}_sigma', value=1.0)
x_array = wave[idcsEmis + idcsCont]
y_array = flux_voxel_norm[idcsEmis + idcsCont]
w_array = 1.0 / np.sqrt(err_voxel_norm[idcsEmis + idcsCont])
fit_params = fit_model.make_params()
obs_fit_output = fit_model.fit(y_array,
fit_params,
x=x_array,
weights=w_array)
amp = obs_fit_output.params[f"{lineLabel}_amplitude"].value
mu = obs_fit_output.params[f"{lineLabel}_center"].value
sigma = obs_fit_output.params[f"{lineLabel}_sigma"].value
vr = c_KMpS * (mu - obsLm.peak_wave) / obsLm.peak_wave
sigma_vel = c_KMpS * sigma / obsLm.peak_wave
# print(f'intg flux ({obsLm.intg_flux:.3e}); intg err ({obsLm.intg_err:.3e})')
output_message = f'Observed frame: amp ({amp:0.2f}); mu ({mu:0.2f}); sigma ({sigma:0.2f}); vr ({vr:0.2f}); sigma_vel ({sigma_vel:0.2f})'
print(output_message)
x_obs, y_obs = obs_fit_output.userkws['x'], obs_fit_output.data
wave_obs = np.linspace(x_obs[0], x_obs[-1], 500)
ydata[35:100] = 20 * xdata[35:100]**0.6
ydata = ydata + np.random.normal(0, 0, 100)
plt.plot(ydata)
# In[39]:
max(xdata)
# In[40]:
ydata
# In[25]:
pw_model = Model(piecewise_linear)
fitted_model = pw_model.fit(ydata, x=xdata)
fitted_model.plot()
# In[21]:
def pw_linear(x, x0, y0, k1, k2):
if x < x0:
return (x - x0) * k1 + y0
else:
return (x - x0) * k2_y0
# In[23]:
((2 * K4) / Ms)))**0.5)
if Anisotropy == "IP":
Kit = Model(KittelIP)
ntira = 0 # numero de pontos a tirar
newfields = fields[ntira:]
newpeak1 = peak[ntira:]
paramK = Kit.make_params()
paramK.add("Hintrinsic", value=Hintrinsic)
paramK.add("G", value=G, min=2.8e6, max=3.1e6)
Kittelfit = Kit.fit(newpeak1, paramK, field=newfields)
print(Kittelfit.fit_report())
elif Anisotropy == "OP":
Kit = Model(KittelOP)
ntira = 0 # numero de pontos a tirar
newfields = fields[ntira:]
newpeak1 = peak[ntira:]
paramK = Kit.make_params()
paramK.add("Hintrinsic", value=Hintrinsic)
paramK.add("G", value=G, min=2.8e6, max=3.1e6)
