def init_fitting(self):
"""
Setup peak fitting parameters and arrays.
Returns
-------
None.
"""
sig = self.channel_data.par['sig']
# set values for the peak shape (should have been determined in peak_sampling)
self.alpha = B.Parameter(1./self.channel_data.par['decay_time'], 'alpha')
self.beta = B.Parameter(1./self.channel_data.par['rise_time'], 'beta')
# set boundary values
self.n_sig_low = self.channel_data.par['n_sig_low']
self.n_sig_boundary = self.channel_data.par['n_sig_boundary']
# determine lower (and upper) edges
self.dt_l = self.n_sig_low*sig # in us
self.dl = int(self.dt_l/self.channel_data.dt) # in channels
self.boundary = self.n_sig_boundary*sig # boundary reagion in terms of sigma (peak width)
self.in_boundary = np.zeros_like(self.tp, dtype = 'bool') # array of logicals indicating if a peak in a boundary region
# number of bkg parameters
self.bkg_len=self.channel_data.var['bkg_len']
self.vary_codes_bkg=self.channel_data.var['vary_codes_bkg']
self.poly_order=self.channel_data.par['poly_order']
return
def fit_shape(self, ts, Vt):
# fit function
# initialize fit function parameters
alpha = B.Parameter(1. / self.par['decay_time'], 'alpha')
beta = B.Parameter(1. / self.par['rise_time'], 'beta')
x0 = B.Parameter(ts[np.argmax(Vt)], 'x0')
#x0 = B.Parameter(self.par['position'], 'x0')
H = B.Parameter(1., 'H')
offset = B.Parameter(0., 'offset') #self.offset
# shift peak shape
def signal(x):
sig, y = fu.peak(x - x0(), alpha(), beta())
return y * H() + offset()
F = B.genfit(signal, [alpha, beta, x0, H, offset], x=ts, y=Vt)
return F, alpha(), beta(), H(), offset(), x0()
def fit_shape(self, ts, Vt):
"""
Fit standard peak shape to data ts, Vt
Parameters
----------
ts : numpy array (float)
times
Vt : numpy array (float)
Voltages
Returns
-------
F : genfit opject
fit results.
alpha: float
fit parameter (1/rise_time)
beta: float
fit parameter. (1/decay_time)
H: float
fit parameter. (signal height)
offset: float
fit parameter (constant background)
x0: float
fit parameter (peak position)
"""
alpha = B.Parameter(1. / self.decay_time, 'alpha')
beta = B.Parameter(1. / self.rise_time, 'beta')
x0 = B.Parameter(ts[np.argmax(Vt)], 'x0')
H = B.Parameter(1., 'H')
offset = B.Parameter(0., 'offset')
# shift peak shape
def signal(x):
sig, y = UT.peak(x - x0(), alpha(), beta())
return y * H() + offset()
F = B.genfit(signal, [alpha, beta, x0, H, offset],
x=ts,
y=Vt,
plot_fit=False)
return F, alpha(), beta(), H(), offset(), x0()
"""
Created on Thu Apr 8 20:11:52 2021
@author: rupeshdotel
"""
#qfactors with least square fitting
import numpy as np
import matplotlib.pyplot as plt
import LT.box as B
import scipy.spatial as SP
#%%
A = B.Parameter(50., 'A')
x0 = B.Parameter(0.956, 'x0')
sigma = B.Parameter(.005, 'sigma')
def gaus(x):
return A() * np.exp(-(x - x0())**2 / (2. * sigma()**2))
a0 = B.Parameter(1., 'a0')
a1 = B.Parameter(1., 'a1')
def lin_bkg(x):
return a0() + a1() * x
def fit_interval(self, tmin=None, tmax=None, plot=None, save=None):
sl = fu.get_window_slice(tmin * us, self.td, tmax * us)
V = self.Vps[sl]
td = self.td[sl]
dt = self.dt
# check that not too many point as requested for plotting
if len(V) > 1000000:
print('Too much to plot, will skip plotting.')
plot = False
plot_s = False #do not plot if interval is not specified
#-------------------------------------
# setup peak finding
#-------------------------------------
Vstep = self.par['Vstep']
Vth = self.par['Vth']
sig = self.par['sig']
if sig == None:
dtmin = self.par['dtmin']
n_samp = self.par['n_samp']
ts = td[0:n_samp] - dtmin
sig = fu.peak(ts, 1 / self.par['decay_time'],
1 / self.par['rise_time'])[0]
bkg_len = self.var['bkg_len']
vary_codes_bkg = self.var['vary_codes_bkg']
poly_order = self.par['poly_order']
def lish(x): #''' Vectorize the line shape'''
return lfitm1.LF.line_shape(x)
line_shape = np.vectorize(lish)
# set values for the peak shape (should have been determined in peak_sampling)
alpha = B.Parameter(1. / self.par['decay_time'], 'alpha')
beta = B.Parameter(1. / self.par['rise_time'], 'beta')
# create arrays for peak locations
results = np.zeros((2, ), dtype='int32')
pmin = np.zeros((len(V) / 5, ), dtype='int32')
pmax = np.zeros((len(V) / 5, ), dtype='int32')
FP.find_peaks(len(V), Vstep, V, results, pmin, pmax)
## number of maxima
n_max = results[1]
print(" found : ", n_max, " maxima")
imax = pmax[:n_max]
## number of minima
nmin = results[0]
print(" found : ", nmin, " minima")
imin = pmin[:nmin]
## get the indices of peaks higher then threshold
ipeak_tr = np.where(V[imax] > Vth)[0]
#choose minimums close to previous maximum (to filter out electrical switching noise peaks)
# reject of time difference < 0.5 us
close_time = np.where((td[imin][ipeak_tr] - td[imax][ipeak_tr]) < 0.5)[0]
# check if next minimum is not too negative (removing switching noize)
neg_V_min = np.where(V[imin][ipeak_tr][close_time] < -0.3)[0]
ipeak_ok = np.delete(ipeak_tr, close_time[neg_V_min])
# good peak locations after electrical switching noise filtering
Vp = V[imax][ipeak_ok]
tp = td[imax][ipeak_ok]
imax_fit = imax[ipeak_ok] #indices of peaks to fit in raw data array
# loop over the peaks
Np = Vp.shape[0]
t_start = time.clock()
# forming fit groups using peak width to determine boundaries
n_sig_low = self.par['n_sig_low']
n_sig_boundary = self.par['n_sig_boundary']
n_peaks_to_fit = self.par['n_peaks_to_fit']
#--------------------------------
# define window edges for fitting
#--------------------------------
# lower edge
dt_l = n_sig_low * sig
dl = int(dt_l / dt)
boundary = n_sig_boundary * sig # boundary reagion in terms of sigma (peak width)
in_boundary = np.zeros_like(
tp, dtype='bool'
) # array of logicals indicating if a peak in a boundary region
# determine the fit groups
fg, fw = fu.get_fit_groups_new(n_peaks_to_fit, imax_fit, 0., td)
fg_shift, fw = fu.get_fit_groups_new(n_peaks_to_fit, imax_fit, fw / 2., td)
#if interval is specified for fitting
if tmin and tmax:
if (tmin * us >= self.par['dtmin']) and (
tmax * us <= self.par['dtmax']) and tmin < tmax:
#find fit groups covering the interval
inmin = np.where(td[imax_fit] >= tmin * us)[0][
0] #index of first peak in fitting interval in time data
in_max = np.where(
td[imax_fit] <= tmax * us)[0][-1] #index of tmax in time data
gtf = np.empty((0, 2), int) #list of groups in interval to fit
gtfs = np.empty((0, 2), int)
for f in fg:
if f[0] > in_max and f[1] > in_max:
break
if f[0] > inmin or f[1] > inmin:
gtf = np.vstack([gtf, f])
for f in fg_shift:
if f[0] > in_max and f[1] > in_max:
break
if f[0] > inmin or f[1] > inmin:
gtfs = np.vstack([gtfs, f])
fg = gtf
fg_shift = gtfs #to fit only specified groups
else:
print("Interval out of range or incorrect.",
self.par['dtmin'] / us, self.par['dtmax'] / us)
return
# the number of peaks in each fit group
fg_n_peaks = fg[:, 1] - fg[:, 0] + 1
fg_shift_n_peaks = fg_shift[:, 1] - fg_shift[:, 0] + 1
# loop over fit groups and define peaks in the boundary area
# arrays for storing fit results
A_fit = np.zeros_like(tp)
sig_A_fit = np.zeros_like(tp)
# bkg fit parameters
bkg_par = np.zeros(shape=(len(tp), bkg_len))
#-------------------------------------
# loop over fit groups for fitting
#-------------------------------------
N_fitted = 0
lims = []
ifailed = 0
# setup plotting if desired
if plot:
B.pl.xlabel('t(us)')
B.pl.ylabel('V')
B.pl.title('Not shifted fitting groups')
# do the fitting
for i, ff in enumerate(fg[:]):
# print information on the current status of fitting
N_fitted += fg_n_peaks[i]
if (i % 10 == 0) & (i != 0):
t_current = time.clock()
a_rate = 0.
t_diff = (t_current - t_start)
if (t_diff != 0.):
a_rate = float(N_fitted) / t_diff
print("Fit ", i,
float(N_fitted) / Np * 100., "% completed, time ", t_current,
' rate =', a_rate)
# form a slice for the current peaks
sl = slice(ff[0], ff[1] + 1)
# times for the peaks
tp_fit = tp[sl]
# amplitudes for the peaks
Vp_fit = Vp[sl]
# array indices into full data arrays for the peaks
ipos_fit = imax_fit[sl]
# first peak to be fitted is at 0.
tpk = tp_fit[0]
# get full range data for fitting
# index of peak into the data array
first_peak_ind = ipos_fit[0]
last_peak_ind = ipos_fit[-1]
# slice for data range for fitting into the full array, extended by the number of sigmas selected
i_start_data = max(0, first_peak_ind - dl)
i_stop_data = min(last_peak_ind + dl, td.shape[0])
it_fit = slice(i_start_data, i_stop_data)
# find which peaks are in a boundary area
if (it_fit.start == it_fit.stop):
# nothing to fit continue
continue
start_fit_time = td[it_fit][0]
end_fit_time = td[it_fit][-1]
lims.append([start_fit_time, end_fit_time, tpk, it_fit])
# determine of the peaks are in a boundar region
in_boundary[sl] = ((tp_fit - start_fit_time) < boundary) | (
(end_fit_time - tp_fit) < boundary)
# place first peak at 0
tt = td[it_fit] - tpk
Vt = V[it_fit]
# initialize fortran fit
t_peaks = tp_fit - tp_fit[0]
n_peaks = Vp_fit.shape[0]
# initialize vary codes array
vc = np.array(vary_codes_bkg + [1 for v in Vp_fit])
# initalize fit
lfitm1.LF.init_all(alpha(), beta(), t_peaks, n_peaks, poly_order, vc)
# do the fit
chisq = lfitm1.LF.peak_fit(tt, Vt, np.ones_like(Vt), Vt.shape[0])
if (chisq < 0.):
# failed fit
print(' fit ', i, 'failed, chisq = ', chisq)
ifailed += 1
lfitm1.LF.free_all()
continue
if plot and len(tt) != 0:
B.pl.plot(tt + tpk, Vt, '.', color='b')
B.pl.plot(tt + tpk, line_shape(tt), color='m')
# get the amplitudes the first bkg_len parameters are the bkg.
fitted_A = np.copy(lfitm1.LF.a[bkg_len:])
# get background parameters
bkg = np.copy(lfitm1.LF.a[:bkg_len])
# get covariance matrix
cov = np.copy(lfitm1.LF.covar)
# calculate the error of the amplitudes
sig_fitted_A = np.sqrt(cov.diagonal()[bkg_len:] * chisq)
# get the relevant fit parameters
if (chisq > 0.):
# its_shift.append((tp_fit, sl, Vp_fit, chisq, np.copy(LF.a), np.copy(LF.covar)))
# same the values
A_fit[sl] = fitted_A
sig_A_fit[sl] = sig_fitted_A
bkg_par[sl] = bkg
# free the arrays
lfitm1.LF.free_all()
print(ifailed, ' fits failed out of', i)
#--------------------------------
# get second pass for boundary fit
#--------------------------------
# loop over the peaks
lims_s = []
t_start = time.clock()
N_fitted = 0
# arrays for storing fit results
A_fit_s = np.zeros_like(tp)
sig_A_fit_s = np.zeros_like(tp)
# fit parameters
bkg_par_s = np.zeros(shape=(len(tp), bkg_len))
print('new start time: ', t_start)
# fit shifted set
ifailed1 = 0
for i, ff in enumerate(fg_shift[:]):
N_fitted += fg_shift_n_peaks[i]
if (i % 10 == 0) & (i != 0):
t_current = time.clock()
a_rate = 0.
t_diff = (t_current - t_start)
if (t_diff != 0.):
a_rate = float(N_fitted) / t_diff
print("Fit ", i,
float(N_fitted) / Np * 100., "% completed, time ", t_current,
' rate =', a_rate)
# form a slice for the current peaks
sl = slice(ff[0], ff[1] + 1)
# times for the peaks
tp_fit = tp[sl]
# amplitudes for the peaks
Vp_fit = Vp[sl]
# array indices into full data arrays for the peaks
ipos_fit = imax_fit[sl]
# first peak to be fitted is at 0.
tpk = tp_fit[0]
# get full range data for fitting
# index of peak into the data array
first_peak_ind = ipos_fit[0]
last_peak_ind = ipos_fit[-1]
# slice for data range for fitting into the full array
i_start_data = max(0, first_peak_ind - dl)
i_stop_data = min(last_peak_ind + dl, td.shape[0])
it_fit = slice(i_start_data, i_stop_data)
# find which peaks are in a boundary area
if (it_fit.start == it_fit.stop):
# nothing to fit continue
continue
start_fit_time = td[it_fit][0]
end_fit_time = td[it_fit][-1]
lims_s.append([start_fit_time, end_fit_time, tpk, it_fit])
# place first peak at 0
tt = td[it_fit] - tpk
Vt = V[it_fit]
# initialize fortran fit
t_peaks = tp_fit - tp_fit[0]
n_peaks = Vp_fit.shape[0]
# initialize vary codes array
vc = np.array(vary_codes_bkg + [1 for v in Vp_fit])
# initalize fit
lfitm1.LF.init_all(alpha(), beta(), t_peaks, n_peaks, poly_order, vc)
# do the fit
chisq = lfitm1.LF.peak_fit(tt, Vt, np.ones_like(Vt), Vt.shape[0])
if (chisq < 0.):
# failed fit
print(' fit ', i, 'failed, chisq = ', chisq)
ifailed1 += 1
lfitm1.LF.free_all()
continue
# plot result if interval specified
if plot_s:
B.pl.figure()
if len(tt) != 0:
B.pl.plot(tt + tpk, Vt, '.', color='b')
B.pl.plot(tt + tpk, line_shape(tt), color='m')
B.pl.title('Shifted fitting groups')
# save the parameters
# get the amplitudes the first 3 parameters are the bkg.
fitted_A = np.copy(lfitm1.LF.a[bkg_len:])
# get background parameters
bkg = np.copy(lfitm1.LF.a[:bkg_len])
# get covariance matrix
cov = np.copy(lfitm1.LF.covar)
# calculate the error of the amplitudes
sig_fitted_A = np.sqrt(cov.diagonal()[bkg_len:] * chisq)
# get the relevant fit parameters
if (chisq > 0.):
# its_shift.append((tp_fit, sl, Vp_fit, chisq, np.copy(LF.a), np.copy(LF.covar)))
# same the values
A_fit_s[sl] = fitted_A
sig_A_fit_s[sl] = sig_fitted_A
bkg_par_s[sl] = bkg
# free the arrays
lfitm1.LF.free_all()
print(ifailed1, ' fits failed out of', i)
#--------------------------------
# copy results of those peaks that are in the boundaryregion from the 2nd fit
# in_boundary is try for all peaks that lie in a boundary region
# need to get the fit results from the shifted fit for those peaks e.g. for the indices
#--------------------------------
A_fit[in_boundary] = A_fit_s[in_boundary]
sig_A_fit[in_boundary] = sig_A_fit_s[in_boundary]
bkg_par[in_boundary] = bkg_par_s[in_boundary]
#---------------------------------------------
# save the data as numpy compressed data files
#---------------------------------------------
if not save:
print('no results saved!')
else:
# save the fitted data
o_file = self.var['res_dir'] + "fit_results_" + str(
self.par['shot']) + "_{0:5.3f}_{1:5.3f}_{2:d}.npz".format(
tmin, tmax, self.par['channel'])
if not os.path.exists(os.path.dirname(o_file)):
os.makedirs(os.path.dirname(o_file))
if os.path.isfile(o_file):
o_file = self.var['res_dir'] + "fit_results_" + str(
self.par['shot']) + "_{0:5.3f}_{1:5.3f}_{2:d}".format(
tmin, tmax, self.par['channel']) + time.strftime(
'%d_%m_%Y_%H_%M_%S') + ".npz"
n_lines = tp.shape[0]
np.savez_compressed(o_file,
t=tp,
V=Vp,
A=A_fit,
sig_A=sig_A_fit,
bkg=bkg_par)
print("Wrote : ", n_lines, " lines to the output file")
alpha = 2.e5
lam = 10.
A1 = 0.1
# alpha = B.Parameter(cd.get_value('alpha') , 'alpha')
# lam = B.Parameter(cd.get_value('lam') , 'lam')
# A1 = B.Parameter(cd.get_value('A1') , 'A1')
use_all_variables = True
Em_func = Em_pow_mod
Em_func_der = Em_pow_mod_der
print('initial parameters :', alpha(), lam(), A1())
current_fit_par = [alpha, lam, A1]
elif model == 'pow_mods':
# modulated power law sine
alpha = B.Parameter(cd.get_value('alpha'), 'alpha')
lam = B.Parameter(cd.get_value('lam'), 'lam')
A1 = B.Parameter(cd.get_value('A1'), 'A1')
use_all_variables = True
Em_func = Em_pow_mods
Em_func_der = Em_pow_mods_der
print('initial parameters :', alpha(), lam(), A1())
current_fit_par = [alpha, lam, A1]
elif model == 'simple_gauss':
A = B.Parameter(0.1, 'A')
pos = B.Parameter(1.2, 'r0')
sig = B.Parameter(0.5, 'sig')
#A = B.Parameter(cd.get_value('A') , 'A')
#pos = B.Parameter(cd.get_value('r0') ,'r0')
#sig = B.Parameter(cd.get_value('sig') ,'sig')
#orbit_dir = './nml_orb_p8_upper_position_high_B/'
orbit_dir = './nml_orb_p8_lower_position_high_B/'
#orbit_dir = './nml_orb_p7_lower_position_high_B/'
#orbit_dir = './nml_orb_p7_bundle_lower_position_high_B/'
#orbit_dir = './nml_orb_p7_mid_position_high_B/'
#orbit_dir = './nml_orb_p6_lower_position/'
#orbit_dir = './orb_ppro_5/'
#orbit_dir = './orb_ppro_8/'
# orbit_dir = './orb_ppro_6/'
# fit parameters
A = B.Parameter(1.16704568137)
r0 = B.Parameter(1.06498326579)
sig_r = B.Parameter(0.116676453845)
z0 = B.Parameter(0.0653756066516)
sig_z = B.Parameter(0.191893739805)
orbit_output = open(orbit_dir + '/orbit_output').readlines()
# find the EQ file used:
eq_file = 'generic'
for d in orbit_output:
if (d.find('--> EQ File unit, name') >= 0.):
eq_file = d.split()[-1:][0]
# flux
print 'reading flux data'
fl = gf.flux(orbit_dir + 'flux.data')
# get the bin width
#dM = d.par.get_value('dx')
# get the histogram data
#M = d['xb']
#C = d['cont']
#dC = d['dcont']
#dC = np.sqrt(C)
# plot the data
B.plot_exp(M, C, dC)
# setup
# simple gaussian
A = B.Parameter(C.max(), 'A')
#x0 = B.Parameter(0.135, 'x0')
#x0 = B.Parameter(0.135, 'x0')
x0 = B.Parameter(0.956, 'x0')
#x01 = B.Parameter(0.545, 'x01')
sig = B.Parameter(.005, 'sigma')
def gaus(x):
return A() * np.exp(-(x - x0())**2 / (2. * sig()**2))
# second gauss for a doublegauss
D = B.Parameter(100., 'D')
sig1 = B.Parameter(.005, 'sigma1')
def __init__(self,
A_min=10.,
A=10000.,
A_max=1e9,
x0_min=0.94,
x0=0.956,
x0_max=0.98,
sigma_min=0.005,
sigma=0.01,
sigma_max=0.30,
c0_min=10,
c0=1e4,
c0_max=5e4,
b0_min=10,
b0=0.14,
b0_max=0.20,
db0=0.50,
k0_min=10,
k0=100.,
k0_max=500.,
k1_min=10,
k1=100.,
k1_max=500.,
m0=0.86,
m1=1.05):
# peak parameters
self.A_min = B.Parameter(A_min, 'A_min')
self.A = B.Parameter(A, 'A')
self.A_max = B.Parameter(A_max, 'A_max')
self.x0_min = B.Parameter(x0_min, 'x0_min')
self.x0 = B.Parameter(x0, 'x0')
self.x0_max = B.Parameter(x0_max, 'x0_max')
self.sigma_min = B.Parameter(sigma_min, 'sigma_min')
self.sigma = B.Parameter(sigma, 'sigma')
self.sigma_max = B.Parameter(sigma_max, 'sigma_max')
# back ground parameters
self.c0_min = B.Parameter(c0_min, 'c0_min')
self.c0 = B.Parameter(c0, 'c0')
self.c0_max = B.Parameter(c0_max, 'c0_max')
self.b0_min = B.Parameter(b0_min, 'b0_min')
self.b0 = B.Parameter(b0, 'b0')
self.b0_max = B.Parameter(b0_max, 'b0_max')
self.db0 = B.Parameter(db0, 'db0')
self.k0_min = B.Parameter(k0_min, 'k0_min')
self.k0 = B.Parameter(k0, 'k0')
self.k0_max = B.Parameter(k0_max, 'k0_max')
self.k1_min = B.Parameter(k1_min, 'k1_min')
self.k1 = B.Parameter(k1, 'k1')
self.k1_max = B.Parameter(k1_max, 'k1_max')
self.m0 = B.Parameter(m0, 'm0')
self.m1 = B.Parameter(m1, 'm1')
#self.b1 = B.Parameter(b1, 'b1')
# fit list, which parameters are to be varied
self.fit_par = {
"A" : self.A,
"x0" : self.x0, \
"sigma": self.sigma, \
"c0" : self.c0, \
"b0" : self.b0, \
"k0" : self.k0, \
"k1" : self.k1 }
self.set_fit_list()
self.fit_list = [
self.A, self.x0, self.sigma, self.c0, self.b0, self.k0, self.k1
]
model = 'pow'
model = 'zer'
model = 'pow_mod'
model = 'zer2d'
model = 'pol'
model = 'cheb'
model = 'two_gauss'
use_data_set = '2gauss'
use_data_set = 'p8'
if model == 'pow':
# simple power law
lam = B.Parameter(11., 'lam')
alpha = B.Parameter(1., 'alpha')
Em_func = Em_pow
Em_func_der = Em_pow_der
current_fit_par = [alpha, lam]
print('initial parameters :', alpha, '\n', lam, '\n')
elif model == 'pol':
# polynomial
p0 = B.Parameter(.0)
p1 = B.Parameter(0.1)
p2 = B.Parameter(0.1)
p3 = B.Parameter(1)
# p4 = B.Parameter(.1)
# p5 = B.Parameter(.1)
# Em_func = Em_pol
# Em_func_der = Em_pol_der
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Tue Mar 23 16:44:29 2021
@author: rupeshdotel
"""
import numpy as np
import LT.box as B
import matplotlib.pyplot as plt
#%%
A = B.Parameter(500., 'A')
x0 = B.Parameter(0.956, 'x0')
sig = B.Parameter(.005, 'sigma')
def gaus(x):
return A() * np.exp(-(x - x0())**2 / (2. * sig()**2))
a0 = B.Parameter(1., 'a0')
a1 = B.Parameter(1., 'a1')
def lin_bkg(x):
return a0() + a1() * x
def signal(x):
use_all_variables = False
model = 'zer'
model = 'cheb'
model = 'pol'
model = 'pow'
model = 'two_gauss'
model = 'pow_mod'
model = 'pow'
use_data_set = 'p7'
if model == 'pow':
# simple power law
lam = B.Parameter(11., 'lam')
alpha = B.Parameter(1., 'alpha')
Em_func = Em_pow
Em_func_der = Em_pow_der
print('initial parameters :', alpha, '\n', lam, '\n')
current_fit_par = [alpha, lam]
elif model == 'pol':
# polynomial
p0 = B.Parameter(.0)
p1 = B.Parameter(0.1)
p2 = B.Parameter(0.1)
p3 = B.Parameter(1)
# p4 = B.Parameter(.1)
# p5 = B.Parameter(.1)
# Em_func = Em_pol
# Em_func_der = Em_pol_der
#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Sat Sep 26 12:40:43 2020 @author: rupeshdotel """ from mpl_toolkits import mplot3d import numpy as np import LT.box as B import matplotlib.pyplot as plt #%% Ae = B.Parameter(2500., 'Ae') x0e = B.Parameter(0.956, 'x0e') se = B.Parameter(.01, 'se') alpha = B.Parameter(10000., 'alpha') beta = B.Parameter(10000., 'beta') gamma = B.Parameter(10., 'gamma') delta = B.Parameter(1., 'delta') '''#S17 Ae = B.Parameter(150., 'Ae') x0e = B.Parameter(0.956, 'x0e') se = B.Parameter(.01, 'se') alpha = B.Parameter(50., 'alpha') beta = B.Parameter(100., 'beta') gamma = B.Parameter(10., 'gamma') delta = B.Parameter(1., 'delta')'''
@author: rupeshdotel
"""
#qfactors with least square fitting
import numpy as np
import matplotlib.pyplot as plt
import LT.box as B
import scipy.spatial as SP
from root_numpy import array2tree, array2root, tree2array
import ROOT as R
from root_numpy import tree2array
#%%
A = B.Parameter(50., 'A')
x0 = B.Parameter(0.956, 'x0')
sigma = B.Parameter(.005, 'sigma')
def gaus(x):
return A() * np.exp(-(x - x0())**2 / (2. * sigma()**2))
a0 = B.Parameter(1., 'a0')
a1 = B.Parameter(1., 'a1')
def lin_bkg(x):
return a0() + a1() * x
qs = s/t
qb = 1 - qs
return qs, qb
qse, qbe = qeta_bkg(meta[sel])
hse = B.histo(meta[sel], bins = 40, weights = qs_sel*qse, title = '$\eta$', xlabel = 'M($\gamma\gamma$)')
plt.figure();he.plot_exp(); hse.plot_exp(); he_ws2d.plot_exp() #
#%%
hep = B.histo(metap[sel], bins = 30, title = "$\eta^{'}$" , xlabel = "$M(\pi^{+}\pi^{-}\eta)$")
A = B.Parameter(17500., 'A') #gluexI
#A = B.Parameter(2500., 'A')
x0 = B.Parameter(0.955, 'x0')
s = B.Parameter(.01, 's')
def gaus_peak(x):
return A() * np.exp(-(x - x0())**2/(2.*s()**2))
alpha = B.Parameter(3000., 'alpha')
beta = B.Parameter(3000., 'beta')
gamma = B.Parameter(10., 'gamma')
delta = B.Parameter(1., 'delta')
