def fit(les_x_init, les_y_init, remove):
les_x = []
les_y = []
for i in range(len(les_x_init)):
if les_x_init[i] not in remove:
les_x.append(les_x_init[i])
les_y.append(les_y_init[i])
x = scipy.asarray(les_x)
y = scipy.asarray(les_y)
gmod = GaussianModel()
param = gmod.guess(y, x=x)
amplitude = param['amplitude'].value
center = param['center'].value
sigma = param['sigma'].value
the_fit = gmod.fit(y, x=x, amplitude=amplitude, center=center, sigma=sigma)
best_res = the_fit.chisqr
amplitude = the_fit.params['amplitude'].value
center = the_fit.params['center'].value
sigma = the_fit.params['sigma'].value
best_sol = [amplitude, center, sigma]
y_fit = []
for i in range(len(les_x_init)):
y_fit.append(
gmod.eval(x=les_x_init[i],
amplitude=amplitude,
center=center,
sigma=sigma))
return [best_sol, best_res, y_fit]
def label_diff_lmfit(label1,
label2,
bins='auto',
bin_std=3,
plot=False,
emcee=True):
label1 = np.array(label1)
label2 = np.array(label2)
assert label1.shape == label2.shape
n_obs, n_dim = label1.shape
amp = np.zeros((n_dim, ), dtype=float)
bias = np.zeros((n_dim, ), dtype=float)
scatter = np.zeros((n_dim, ), dtype=float)
frs = np.zeros((n_dim, ), dtype=object)
for i_dim in range(n_dim):
data = label2[:, i_dim] - label1[:, i_dim]
theta, frs[i_dim] = \
gfit_bin_lmfit(data, bins=bins, bin_std=bin_std, plot=False)
amp[i_dim], bias[i_dim], scatter[i_dim] = theta
params = [fr.params for fr in frs]
if emcee:
frs = Parallel(n_jobs=-1)(
delayed(run_mcmc)(fr, steps=1000, nwalkers=50, burn=300, workers=1)
for fr in frs)
for i_dim in range(n_dim):
bias[i_dim] = np.median(frs[i_dim].mcmc.flatchain["center"])
scatter[i_dim] = np.median(frs[i_dim].mcmc.flatchain["sigma"])
params = [fr.mcmc.params for fr in frs]
histdata = []
if plot:
gm = GaussianModel()
fig = plt.figure(figsize=(3 * n_dim, 4))
for i_dim in range(n_dim):
ax = fig.add_subplot(1, n_dim, i_dim + 1)
data = label2[:, i_dim] - label1[:, i_dim]
# binned statistics
if bins == 'robust':
bins = np.arange(np.min(data), np.max(data),
np.std(data) / bin_std)
hist, bin_edges = np.histogram(data, bins=bins)
histdata.append((hist, bin_edges, data))
# bin_centers = (bin_edges[:-1] + bin_edges[1:]) / 2
# bin_xx = np.linspace(bin_edges[0], bin_edges[-1], 100)
ax.hist(data, bins=bin_edges, histtype='step')
ax.plot(bin_edges, gm.eval(params[i_dim], x=bin_edges))
ax.set_title("{:5f}+-{:5f}".format(bias[i_dim], scatter[i_dim]))
else:
for i_dim in range(n_dim):
data = label2[:, i_dim] - label1[:, i_dim]
hist, bin_edges = np.histogram(data, bins=bins)
histdata.append((hist, bin_edges, data))
return bias, scatter, frs, histdata
def measure_line_index_recover_spectrum(wave, params, norm=False):
""" recover the fitted line profile from params
Parameters
----------
wave: array-like
the wavelength to which the recovered flux correspond
params: 5-element tuple
the 1 to 5 elements are:
mod_linear_slope
mod_linear_intercept
mod_gauss_amplitude
mod_gauss_center
mod_gauss_sigma
norm: bool
if True, linear model (continuum) is deprecated
else linear + Gaussian model is used
"""
from lmfit.models import LinearModel, GaussianModel
mod_linear = LinearModel(prefix='mod_linear_')
mod_gauss = GaussianModel(prefix='mod_gauss_')
par_linear = mod_linear.make_params()
par_gauss = mod_gauss.make_params()
par_linear['mod_linear_slope'].value = params[0]
par_linear['mod_linear_intercept'].value = params[1]
par_gauss['mod_gauss_amplitude'].value = params[2]
par_gauss['mod_gauss_center'].value = params[3]
par_gauss['mod_gauss_sigma'].value = params[4]
if not norm:
flux = 1 - mod_gauss.eval(params=par_gauss, x=wave)
else:
flux = \
(1 - mod_gauss.eval(params=par_gauss, x=wave)) * \
mod_linear.eval(params=par_linear, x=wave)
return flux
def measure_line_index_recover_spectrum(wave, params, norm=False):
""" recover the fitted line profile from params
Parameters
----------
wave: array-like
the wavelength to which the recovered flux correspond
params: 5-element tuple
the 1 to 5 elements are:
mod_linear_slope
mod_linear_intercept
mod_gauss_amplitude
mod_gauss_center
mod_gauss_sigma
norm: bool
if True, linear model (continuum) is deprecated
else linear + Gaussian model is used
"""
from lmfit.models import LinearModel, GaussianModel
mod_linear = LinearModel(prefix='mod_linear_')
mod_gauss = GaussianModel(prefix='mod_gauss_')
par_linear = mod_linear.make_params()
par_gauss = mod_gauss.make_params()
par_linear['mod_linear_slope'].value = params[0]
par_linear['mod_linear_intercept'].value = params[1]
par_gauss['mod_gauss_amplitude'].value = params[2]
par_gauss['mod_gauss_center'].value = params[3]
par_gauss['mod_gauss_sigma'].value = params[4]
if not norm:
flux = 1 - mod_gauss.eval(params=par_gauss, x=wave)
else:
flux = \
(1 - mod_gauss.eval(params=par_gauss, x=wave)) * \
mod_linear.eval(params=par_linear, x=wave)
return flux
def post_process(Results):
wave_obs = np.linspace(1.43549998, 1.85, 2202)
from lmfit.models import GaussianModel
gmodel = GaussianModel(prefix='o3rn_') + GaussianModel(prefix='o3rw_')
params = gmodel.make_params(o3rn_center=Results[0], o3rn_sigma =Results[1], o3rn_amplitude=Results[2], \
o3rw_center=Results[3], o3rw_sigma =Results[4], o3rw_amplitude=Results[5])
y_eval = gmodel.eval(params, x=wave_obs)
out = gmodel.fit(y_eval, params, x=wave_obs)
fl_nar = IFU.flux_measure_ind(out, wave_obs, 'OIII', use='nar', error=0)
fl_bro = IFU.flux_measure_ind(out, wave_obs, 'OIII', use='bro', error=0)
return fl_nar, fl_bro
def post_process(Results):
# VLT SINFONI Wavelength setup
wave_obs = np.linspace(1.43549998, 1.85, 2202)
# It is a way to create the model and then "fit it" to create the right results class
from lmfit.models import GaussianModel
gmodel = GaussianModel(prefix='o3rn_') + GaussianModel(prefix='o3rw_')
params = gmodel.make_params(o3rn_center=Results[0], o3rn_sigma =Results[1], o3rn_amplitude=Results[2], \
o3rw_center=Results[3], o3rw_sigma =Results[4], o3rw_amplitude=Results[5])
y_eval = gmodel.eval(params, x=wave_obs)
out = gmodel.fit(y_eval, params, x=wave_obs)
# Calculates v10, v90, W80 and v50
w80 = IFU.W80_mes(out, 'OIII', 0)
peak = wave_obs[np.argmax(y_eval)]
flux = sum(y_eval)
return w80[0], w80[1], w80[2], peak, flux, w80[3], y_eval
#Y=np.roll(df_rolled['2.33'], +80) Y=data.values mod = LorentzianModel() pars = mod.guess(Y, x=X) out = mod.fit(Y, pars, x=X) Y_lorenz = mod.eval(pars, x=X) print(out.fit_report(min_correl=0.25)) plt.plot(X, Y_lorenz, 'k--', label='Lorentzian') dec_angle_lorenz = round(out.params['center'].value / 2, 3) mod2 = GaussianModel() pars2 = mod2.guess(Y, x=X) out2 = mod2.fit(Y, pars2, x=X) Y_gauss = mod2.eval(pars2, x=X) print(out2.fit_report(min_correl=0.25)) plt.plot(X, Y_gauss, 'y--', label='Gaussian') dec_angle_gauss = round(out2.params['center'].value / 2, 3) plt.plot(X, Y, 'b-', label='raw') plt.legend() plt.show(block=False) error = ref_angle - dec_angle_lorenz
params['g1_center'].vary = False
params['g2_center'].vary = False
params['g2_amplitude'].min = 0
params['g1_sigma'].vary = False
params['g2_sigma'].vary = False
params['g3_amplitude'].vary = False
params['g3_center'].vary = False
params['g3_sigma'].vary = False
fit_out[ii] = model.fit(ydata[ii, :], params, x=xdata, weights=yerr[ii, :])
params = copy.deepcopy(fit_out[ii].params)
params['g2_amplitude'].value = 0
params['g3_amplitude'].value = 0
g1_fit[ii, :] = model.eval(params, x=xdata)
err_int[ii,0] = np.sqrt(np.pi*params['g1_amplitude'].stderr**2*params['g1_sigma'].value**2 \
+ params['g1_amplitude'].value**2*params['g1_sigma'].stderr**2)
params = copy.deepcopy(fit_out[ii].params)
params['g1_amplitude'].value = 0
params['g3_amplitude'].value = 0
g2_fit[ii, :] = model.eval(params, x=xdata)
err_int[ii,1] = np.sqrt(np.pi*(params['g2_amplitude'].stderr**2*params['g2_sigma'].value**2 \
+ params['g2_amplitude'].value**2*params['g2_sigma'].stderr**2))
params = copy.deepcopy(fit_out[ii].params)
params['g1_amplitude'].value = 0
params['g2_amplitude'].value = 0
g3_fit[ii, :] = model.eval(params, x=xdata)
def gen_spectrum(wl, vwidth): arr = np.arange(W0, W1, DW) gauss = GaussianModel() fl = gauss.eval(x=arr, center=wl, sigma=wl*vwidth/3e5, amplitude=1.) return fl
def compare_labels(X_true,
X_pred,
xlabels=None,
ylabels=None,
reslabels=None,
xlims=None,
reslims=None,
histlim=None,
nxb=30,
cornerlabel="",
figsize=None):
nlabel = X_true.shape[1]
if xlabels is None:
xlabels = ["$X_{{true}}:{}$".format(i) for i in range(nlabel)]
if ylabels is None:
ylabels = ["$X_{{pred}}:{}$".format(i) for i in range(nlabel)]
if reslabels is None:
reslabels = ["$X_{{res}}:{}$".format(i) for i in range(nlabel)]
# default xlim
if xlims is None:
xlim1 = np.min(np.vstack(
(np.percentile(X_true, 1, axis=0), np.percentile(X_pred, 1,
axis=0))),
axis=0)
xlim2 = np.min(np.vstack(
(np.percentile(X_true, 99,
axis=0), np.percentile(X_pred, 99, axis=0))),
axis=0)
xlims = (xlim2 - xlim1).reshape(-1, 1) * 0.4 * np.array(
[-1, 1]) + np.vstack((xlim1, xlim2)).T
if reslims is None:
reslims = np.repeat(np.max(np.abs(
np.percentile(X_pred - X_true, [1, 99], axis=0).T),
axis=1).reshape(-1, 1),
2,
axis=1) * np.array([-1, 1])
reslims = np.abs(np.diff(reslims, axis=1)) * np.array(
[-1, 1]) * 0.2 + reslims
# run MCMC
X_bias, X_scatter, frs, histdata = label_diff_lmfit(X_true,
X_pred,
bins="auto",
plot=False,
emcee=True)
print("bias", X_bias)
print("scatter", X_scatter)
if histlim is None:
histlim = (0, np.max([np.max(histdata_[0]) for histdata_ in histdata]))
histlim = np.array(histlim)
if figsize is None:
figsize = (3 * nlabel, 3 * nlabel)
# draw figure
fig, axs2 = plt.subplots(nlabel + 1, nlabel + 1, figsize=figsize)
# 1. Gaussian
gm = GaussianModel()
for i in range(nlabel):
plt.sca(axs2[i + 1, -1])
fr = frs[i]
hist_, bin_edge_, data_ = histdata[i]
plt.hist(data_,
bins=bin_edge_,
histtype="step",
orientation="horizontal")
axs2[i + 1, -1].plot(gm.eval(fr.mcmc.params, x=bin_edge_), bin_edge_)
axs2[i + 1, -1].tick_params(direction='in', pad=5)
axs2[i + 1, -1].set_xlim(histlim)
axs2[i + 1, -1].set_ylim(reslims[i])
axs2[i + 1, -1].set_ylim(reslims[i])
axs2[i + 1, -1].yaxis.tick_right()
axs2[i + 1, -1].hlines(X_bias[i], *histlim, linestyle='--', color="k")
pos_text_x = np.dot(np.array([[0.9, 0.1]]), histlim.reshape(-1, 1))
pos_text_y = np.dot(np.array([[0.15, 0.85]]),
reslims[i].reshape(-1, 1))
axs2[i + 1, -1].text(pos_text_x, pos_text_y,
"$bias={:.4f}$".format(X_bias[i]))
pos_text_x = np.dot(np.array([[0.9, 0.1]]), histlim.reshape(-1, 1))
pos_text_y = np.dot(np.array([[0.30, 0.70]]),
reslims[i].reshape(-1, 1))
axs2[i + 1, -1].text(pos_text_x, pos_text_y,
"$\\sigma={:.4f}$".format(X_scatter[i]))
axs2[i + 1, -1].yaxis.tick_right()
if i < nlabel - 1:
axs2[i + 1, -1].set_xticklabels([])
axs2[-1, -1].set_xlabel("Counts")
# 2. diagnal
for i in range(nlabel):
image(axs2[0, i], X_true[:, i], X_pred[:, i],
np.linspace(xlims[i][0], xlims[i][1], nxb),
np.linspace(xlims[i][0], xlims[i][1], nxb))
axs2[0, i].set_xlim(*xlims[i])
axs2[0, i].set_ylim(*xlims[i])
axs2[0, i].tick_params(direction='in', pad=5)
axs2[0, i].set_xticklabels([])
axs2[0, i].set_ylabel(ylabels[i])
axs2[0, i].plot(xlims[i], xlims[i], 'k--')
# 3. Xres vs X
X_res = X_pred - X_true
for i in range(nlabel):
for j in range(nlabel):
image(axs2[j + 1, i], X_true[:, i], X_res[:, j],
np.linspace(xlims[i][0], xlims[i][1], nxb),
np.linspace(reslims[j][0], reslims[j][1], nxb))
axs2[j + 1, i].set_xlim(*xlims[i])
axs2[j + 1, i].set_ylim(*reslims[j])
axs2[j + 1, i].tick_params(direction='in', pad=5)
if j != nlabel - 1:
axs2[j + 1, i].set_xticklabels([])
else:
axs2[j + 1, i].set_xlabel(xlabels[i])
if i != 0:
axs2[j + 1, i].set_yticklabels([])
else:
axs2[j + 1, i].set_ylabel(reslabels[j])
axs2[0, -1].set_axis_off()
axs2[0, -1].text(np.mean(axs2[0, -1].get_xlim()),
np.mean(axs2[0, -1].get_ylim()),
cornerlabel,
horizontalalignment='center',
verticalalignment='center')
fig.tight_layout()
plt.subplots_adjust(wspace=0., hspace=0.)
return fig, frs
def MultiPlot(xdata, ydata, fitdata, fullx, fully, key, title):
# plt.rc('text', usetex=True)
# plt.rc('font', family='serif')
# plt.rcParams['text.latex.preamble'] = [
# r'\usepackage{siunitx}', # i need upright \micro symbols, but you need...
# r'\sisetup{detect-all}', # ...this to force siunitx to actually use your fonts
# r'\usepackage{lmodern}', # set the normal font here
# ]
# plt.rcParams['ps.usedistiller'] = 'xpdf'
# plt.rcParams['ps.distiller.res'] = '1600'
labelsize = 14
ticksize = 12
fig = plt.figure(figsize=(8, 5.5))
# fig.subplots_adjust(hspace=0, wspace=0)
ax1 = fig.add_subplot(2, 2, 1)
fig.subplots_adjust(top=0.932,
bottom=0.106,
left=0.118,
right=0.974,
hspace=0.307,
wspace=0.262)
ax1.plot(xdata / 1000, fitdata, antialiased=True, label='Lorentzian fit')
ax1.plot(fullx / 1000,
fully,
'.',
color='#1c1c1c',
label='Sweep data',
zorder=0,
ms=1.5)
dely = sqrt(sqrt(ydata)**2 + 0.5**2)
residuals = ydata - fitdata
ax1.fill_between(xdata / 1000,
fitdata - dely,
fitdata + dely,
color="#ABABAB",
label=r'$1\sigma$',
alpha=0.7)
ax1.grid(color='k', linestyle='--', alpha=0.2)
plt.xlabel('Frequency (KHz)', fontsize=labelsize)
plt.ylabel('Variance (a.u.)', fontsize=labelsize)
plt.tick_params(axis='both', which='major', labelsize=ticksize)
ax1.legend(frameon=True, loc='best')
# plt.title('Peak with 1 sigma error bands')
ax2 = fig.add_subplot(2, 2, 2)
ax2.plot(xdata / 1000,
residuals,
'.',
antialiased=True,
ms=1.5,
color='#1c1c1c')
ax2.grid(color='k', linestyle='--', alpha=0.2)
plt.xlabel('Frequency (KHz)', fontsize=labelsize)
plt.ylabel(r'$y_m - y_f$', fontsize=labelsize)
plt.tick_params(axis='both', which='major', labelsize=ticksize)
# plt.title('Residuals')
ax3 = fig.add_subplot(2, 2, 3)
ax3.plot(xdata / 1000, (residuals**2) / dely**2,
'.',
antialiased=True,
ms=1.5,
color='#1c1c1c')
ax3.grid(color='k', linestyle='--', alpha=0.2)
plt.xlabel('Frequency (KHz)', fontsize=labelsize)
plt.ylabel(r'$\frac{y_m - y_f}{\sigma_y}$', fontsize=labelsize)
plt.tick_params(axis='both', which='major', labelsize=ticksize)
# plt.title('Normalised residuals')
ax4 = fig.add_subplot(2, 2, 4)
n, bins, patches = ax4.hist(residuals,
bins='auto',
label='Residual hist.',
color='#1c1c1c',
alpha=0.9)
mdl = GaussianModel()
bin_centre = []
for t in range(0, len(bins) - 1):
bin_centre.append((bins[t + 1] + bins[t]) / 2)
bin_centre2 = asarray(bin_centre)
pars = mdl.guess(n, x=bin_centre2)
result2 = mdl.fit(n, pars, x=bin_centre2)
xs = linspace(min(bin_centre), max(bin_centre), 1000)
ys = mdl.eval(x=xs, params=result2.params)
corr_coeff = 1 - result2.residual.var() / var(n)
# at = AnchoredText("$R^2 = {:.3f}$".format(corr_coeff),
# prop=dict(size=10), frameon=True,
# loc=2,
# )
# ax4.add_artist(at)
ax4.plot(0,
0,
'.',
color='k',
ms=0,
label="$R^2 = {:.3f}$".format(corr_coeff))
ax4.plot(xs, ys, antialiased=True, label='Lorentzian fit')
ax4.grid(color='k', linestyle='--', alpha=0.2)
ax4.legend(frameon=True, loc='best')
plt.xlabel(r'$y_m - y_f$', fontsize=labelsize)
plt.ylabel('Counts', fontsize=labelsize)
plt.tick_params(axis='both', which='major', labelsize=ticksize)
# plt.title('Residual histogram')
fig.suptitle('Helmholtz coil current: {}'.format(title))
# fig.tight_layout()
# fig.set_size_inches(16.5, 10.5)
# fig_manager = plt.get_current_fig_manager()
# fig_manager.window.showMaximized()
plt.savefig(
"C:\\Users\\Josh\\IdeaProjects\\OpticalPumping\\MatplotlibFigures\\Lorentzian_{}.png"
.format(key),
dpi=600)
# plt.show()
plt.close()
delay,dataii['d2 wl'])
bkg = np.mean(
np.array(dataii['d1 wol'][0:3]) + np.array(dataii['d1 wol'][-3:])) / 2
dataii['d1 wol'] = dataii['d1 wol'] - bkg - fem.halo_correction(dataii['d1 wol'],dataii['d1 wol'], \
delay,dataii['d2 wl'])
""" Fit """
model = GaussianModel()
params = model.make_params()
params['amplitude'].value = 150
params['center'].value = -95
params['sigma'].value = 1
fit_out[ii] = model.fit(dataii['d1 wol'],
params,
x=dataii['top rotation (rbk)'],
weights=np.sqrt(np.abs(dataii['d1 wol'] / 5)))
dataii['fit unpumped'] = model.eval(fit_out[ii].params,
x=dataii['top rotation (rbk)'])
ampl.append([
fit_out[ii].params['amplitude'].value,
fit_out[ii].params['amplitude'].stderr
])
center.append([
fit_out[ii].params['center'].value, fit_out[ii].params['center'].stderr
])
sigma.append([
fit_out[ii].params['sigma'].value, fit_out[ii].params['sigma'].stderr
])
""" integration """
norm = np.trapz(rot_3ps['flu1.0']['d1 wol'],
x=dataii['top rotation (rbk)'])
int[ii] = np.trapz(dataii['d1 wl'] / norm, x=dataii['top rotation (rbk)'])
