def model(fit_range, bin):
nrm_bkg_pdf = Normalized(rename(exp, ['x', 'l%d' % bin]), fit_range)
ext_bkg_pdf = Extended(nrm_bkg_pdf, extname='Ncomb_%d' % bin)
ext_sig_pdf = Extended(rename(gaussian, ['x', 'm%d' % bin, "sigma%d" % bin]), extname='Nsig_%d' % bin)
tot_pdf = AddPdf(ext_bkg_pdf, ext_sig_pdf)
print('pdf: {}'.format(describe(tot_pdf)))
return tot_pdf
def test_extended_binlh_ww_w2(self):
egauss = Extended(gaussian)
_, minuit = fit_binlh(egauss, self.data, bins=100, bound=(1., 9.), quiet=True,
mean=4., sigma=1., N=1000., weights=self.wdown,
print_level=0, extended=True)
assert_allclose(minuit.values['mean'], 5., atol=minuit.errors['mean'])
assert_allclose(minuit.values['sigma'], 2., atol=minuit.errors['sigma'])
assert_allclose(minuit.values['N'], 2000, atol=minuit.errors['N'])
assert minuit.migrad_ok()
_, minuit2 = fit_binlh(egauss, self.data, bins=100, bound=(1., 9.), quiet=True,
mean=4., sigma=1., N=1000., weights=self.wdown,
print_level=-1, extended=True, use_w2=True)
assert_allclose(minuit2.values['mean'], 5., atol=2 * minuit2.errors['mean'])
assert_allclose(minuit2.values['sigma'], 2., atol=2 * minuit2.errors['sigma'])
assert_allclose(minuit2.values['N'], 2000., atol=2 * minuit2.errors['N'])
assert minuit2.migrad_ok()
minuit.minos()
minuit2.minos()
# now error should scale correctly
assert_allclose(minuit.errors['mean'] / sqrt(10),
minuit2.errors['mean'],
atol=minuit.errors['mean'] / sqrt(10) / 100.)
assert_allclose(minuit.errors['sigma'] / sqrt(10),
minuit2.errors['sigma'],
atol=minuit.errors['sigma'] / sqrt(10) / 100.)
assert_allclose(minuit.errors['N'] / sqrt(10),
minuit2.errors['N'],
atol=minuit.errors['N'] / sqrt(10) / 100.)
def test_binx2(self):
egauss = Extended(gaussian)
_, minuit = fit_binx2(egauss, self.data, bins=100, bound=(1., 9.),
quiet=True, mean=4., sigma=1., N=10000., print_level=0)
assert minuit.migrad_ok()
assert_allclose(minuit.values['mean'], 5., atol=3 * minuit.errors['mean'])
assert_allclose(minuit.values['sigma'], 2., atol=3 * minuit.errors['sigma'])
def drift_velocity(dst, plots_dir, opt_dict):
length_demo = 310
run = opt_dict["run"]
fit_z_min = float(opt_dict["fit_z_min"])
fit_z_max = float(opt_dict["fit_z_max"])
fit_z_range = (fit_z_min, fit_z_max)
print(f'fit z range = {fit_z_range}')
Z = dst[in_range(dst.Z, fit_z_min, fit_z_max)].Z
sigmoid = lambda x, A, B, C, D: A / (1 + np.exp((x - B) / C)) + D
mypdf = Extended(sigmoid)
#describe(mypdf)
bx2 = BinnedChi2(mypdf, Z, bins=50,
bound=fit_z_range) #create cost function
#bx2.show(args={'A':1400, 'B':340, 'C':1.1, 'D':43 , 'N':0.1}) #another way to draw it
m = Minuit(bx2, A=1400, B=340, C=1.1, D=43, N=0.1)
m.migrad()
my_parmloc = (0.60, 0.90)
bx2.draw(m, parmloc=my_parmloc)
v = length_demo / m.args[1]
print(v)
v_err = (length_demo - 2) / (m.args[1] - m.errors[1])
v_u = v - v_err
print(f"Drift velocity = {v:.4f} +/- {v_u:.4f} ")
plt.savefig(f'{plots_dir}/fit_drift_vel_{run}.pdf')
print(f'plots saved in {plots_dir}/fit_drift_vel_{run}.pdf')
def test_extended_ulh(self):
eg = Extended(gaussian)
lh = UnbinnedLH(eg, self.data, extended=True, extended_bound=(-20, 20))
minuit = Minuit(lh, mean=4.5, sigma=1.5, N=19000.,
pedantic=False, print_level=0)
minuit.migrad()
assert_allclose(minuit.values['N'], 20000, atol=sqrt(20000.))
assert minuit.migrad_ok()
def test_extended_binlh_ww(self):
egauss = Extended(gaussian)
_, minuit = fit_binlh(egauss, self.data, bins=100, bound=(1., 9.), quiet=True,
mean=4., sigma=1., N=1000., weights=self.wdown,
print_level=0, extended=True)
assert minuit.migrad_ok()
assert_allclose(minuit.values['mean'], 5., atol=minuit.errors['mean'])
assert_allclose(minuit.values['sigma'], 2., atol=minuit.errors['sigma'])
assert_allclose(minuit.values['N'], 2000, atol=minuit.errors['N'])
def drift_velocity(plots_dir, dst, label=''):
"""
Input Z distribution
Return value for the drift velocity
"""
# To do: make plotting of drift velocities as for energy resolution
Z = dst[in_range(dst.Z, 305, 350)].Z
fit_z_range = (305, 350)
fig = plt.figure(figsize=(12, 4))
ax = fig.add_subplot(1, 2, 1)
(_) = hist(dst.DT,
bins=100,
range=(0, 400),
histtype='stepfilled',
color='crimson')
labels('Drit time ($\mu$s)', 'Entries')
plt.legend(loc='upper right')
ax = fig.add_subplot(1, 2, 2)
(_) = hist(Z,
bins=100,
range=fit_z_range,
histtype='stepfilled',
color='crimson')
labels('Drit time ($\mu$s)', 'Entries')
plt.legend(loc='upper right')
plt.show()
sigmoid = lambda x, A, B, C, D: A / (1 + np.exp((x - B) / C)) + D
mypdf = Extended(sigmoid)
#describe(mypdf)
chi2 = BinnedChi2(mypdf, Z, bins=100,
bound=fit_z_range) #create cost function
plt.figure(figsize=(7, 5))
chi2.show(args={
'A': 1400,
'B': 330,
'C': 1.1,
'D': 43,
'N': 1
}) #another way to draw it
m = Minuit(chi2, A=800, B=330, C=1.3, D=100, N=1)
m.migrad()
my_parmloc = (0.60, 0.90)
#chi2.draw(m, parmloc=my_parmloc)
plt.figure(figsize=(7, 5))
chi2.show(m, parmloc=my_parmloc)
plt.savefig(f'{plots_dir}/fit_energy_reso_{label}.png')
print('plots saved in ' + plots_dir)
def test_extended_ulh_2(self):
eg = Extended(gaussian)
lh = UnbinnedLH(eg, self.data, extended=True)
minuit = Minuit(lh,
mean=4.5,
sigma=1.5,
N=19000.,
pedantic=False,
print_level=0)
minuit.migrad()
assert (minuit.migrad_ok())
assert_almost_equal(minuit.values['N'], 20000, delta=sqrt(20000.))
def main():
data, data_ctl = get_data()
signal, bkg, signal_ctl, bkg_ctl = get_templates()
edges = list( data.xedges() )
# print list(data.y())
# data, be = hist_to_numpy(data)
# print data
# data_ctl, _ = hist_to_numpy(data_ctl)
# signal, _ = hist_to_numpy(signal)
# signal_ctl, _ = hist_to_numpy(signal_ctl)
# bkg, _ = hist_to_numpy(bkg)
# bkg_ctl, _ = hist_to_numpy(bkg_ctl)
sig_pdf = hist_to_pdf( signal )
bkg_pdf = hist_to_pdf( bkg )
epsig = Extended( sig_pdf, extname = 'N1' )
epbkg = Extended( bkg_pdf, extname = 'N2' )
pdf = AddPdf( epbkg, epsig )
fitdata = array( list( data.y() ) )
blh = BinnedLH( pdf, fitdata, bins = n_bins, bound = ( min_x, max_x ), extended = True )
m = Minuit( blh, N1 = 2000, N2 = 30000, error_N1 = 44, error_N2 = 200 )
m.migrad()
blh.draw( m, parts = True )
def test_extended():
def f(x, y, z): return x + 2 * y + 3 * z
g = Extended(f)
assert_equal(tuple(describe(g)), ('x', 'y', 'z', 'N'))
assert_equal(g(1, 2, 3, 4), 4 * (f(1, 2, 3)))
# extended should use analytical when available
def ana_int(x, y): return y * x ** 2
ana_int_int = lambda b, n, y: 999. # wrong on purpose
ana_int.integrate = ana_int_int
g = Extended(ana_int)
assert_almost_equal(g.integrate((0, 1), 100, 5., 2.), 999.*2.)
# and not fail when it's not available
def no_ana_int(x, y): return y * x ** 2
g = Extended(no_ana_int)
assert_almost_equal(g.integrate((0, 1), 100, 5., 2.), (1.**3) / 3.*5.*2.)
def test_binx2(self):
egauss = Extended(gaussian)
_, minuit = fit_binx2(
egauss,
self.data,
bins=100,
bound=(1.0, 9.0),
quiet=True,
mean=4.0,
sigma=1.0,
N=10000.0,
print_level=0,
)
assert minuit.migrad_ok()
assert_allclose(minuit.values["mean"],
5.0,
atol=3 * minuit.errors["mean"])
assert_allclose(minuit.values["sigma"],
2.0,
atol=3 * minuit.errors["sigma"])
def test_extended_binlh_ww(self):
egauss = Extended(gaussian)
_, minuit = fit_binlh(
egauss,
self.data,
bins=100,
bound=(1.0, 9.0),
quiet=True,
mean=4.0,
sigma=1.0,
N=1000.0,
weights=self.wdown,
print_level=0,
extended=True,
)
assert minuit.migrad_ok()
assert_allclose(minuit.values["mean"], 5.0, atol=minuit.errors["mean"])
assert_allclose(minuit.values["sigma"],
2.0,
atol=minuit.errors["sigma"])
assert_allclose(minuit.values["N"], 2000, atol=minuit.errors["N"])
def test_extended_binlh(self):
egauss = Extended(gaussian)
_, minuit = fit_binlh(egauss,
self.data,
bins=100,
bound=(1., 9.),
quiet=True,
mean=4.,
sigma=1.,
N=10000.,
print_level=0,
extended=True)
assert (minuit.migrad_ok())
assert_almost_equal(minuit.values['mean'],
5.,
delta=3 * minuit.errors['mean'])
assert_almost_equal(minuit.values['sigma'],
2.,
delta=3 * minuit.errors['sigma'])
assert_almost_equal(minuit.values['N'],
20000,
delta=3 * minuit.errors['N'])
def test_extended():
def f(x, y, z):
return x + 2 * y + 3 * z
g = Extended(f)
assert describe(g) == ["x", "y", "z", "N"]
assert_equal(g(1, 2, 3, 4), 4 * (f(1, 2, 3)))
# extended should use analytical when available
def ana_int(x, y):
return y * x**2
ana_int_int = lambda b, n, y: 999.0 # wrong on purpose
ana_int.integrate = ana_int_int
g = Extended(ana_int)
assert_almost_equal(g.integrate((0, 1), 100, 5.0, 2.0), 999.0 * 2.0)
# and not fail when it's not available
def no_ana_int(x, y):
return y * x**2
g = Extended(no_ana_int)
assert_almost_equal(g.integrate((0, 1), 100, 5.0, 2.0),
(1.0**3) / 3.0 * 5.0 * 2.0)
# -*- coding: utf-8 -*- import numpy as np from iminuit import Minuit from probfit import AddPdf, BinnedLH, Extended, gen_toy from probfit.pdf import HistogramPdf bound = (0, 10) np.random.seed(0) bkg = gen_toy(lambda x: x**2, 100000, bound=bound) # a parabola background sig = np.random.randn(50000) + 5 # a Gaussian signal data = np.concatenate([sig, bkg]) # fill histograms with large statistics hsig, be = np.histogram(sig, bins=40, range=bound) hbkg, be = np.histogram(bkg, bins=be, range=bound) # randomize data data = np.random.permutation(data) fitdata = data[:1000] psig = HistogramPdf(hsig, be) pbkg = HistogramPdf(hbkg, be) epsig = Extended(psig, extname="N1") epbkg = Extended(pbkg, extname="N2") pdf = AddPdf(epbkg, epsig) blh = BinnedLH(pdf, fitdata, bins=40, bound=bound, extended=True) m = Minuit(blh, N1=330, N2=670, error_N1=20, error_N2=30) # m.migrad() blh.draw(m, parts=True)
from matplotlib import pyplot as plt
from numpy.random import randn
import numpy as np
peak1 = randn(1000)*0.5 + 1.
peak2 = randn(500)*0.5 + 0.
#two peaks data with shared width
data = np.concatenate([peak1, peak2])
#Share the width
#If you use Normalized here. Do not reuse the object.
#It will be really slow due to cache miss. Read Normalized doc for more info.
pdf1 = rename(gaussian, ('x', 'm_1', 'sigma'))
pdf2 = rename(gaussian, ('x', 'm_2', 'sigma'))
ext_pdf1 = Extended(pdf1, extname='N_1')
ext_pdf2 = Extended(pdf2, extname='N_2')
compdf = AddPdf(ext_pdf1, ext_pdf2) # merge by name (merge sigma)
ulh = BinnedLH(compdf, data, extended=True)
m = Minuit(ulh, m_1=0.1, m_2=-0.1, sigma=0.1, N_1=900, N_2=480)
plt.figure(figsize=(8, 3))
plt.subplot(121)
ulh.draw(m, parts=True)
plt.title('Before')
m.migrad() # fit
plt.subplot(122)
ulh = UnbinnedLH(gaussian, data)
m = Minuit(ulh, mean=0., sigma=0.5)
plt.figure(figsize=(8, 6))
plt.subplot(221)
ulh.draw(m)
plt.title('Unextended Before')
m.migrad() # fit
plt.subplot(222)
ulh.draw(m)
plt.title('Unextended After')
#Extended
data = randn(2000) * 2 + 1
egauss = Extended(gaussian)
ulh = UnbinnedLH(egauss, data, extended=True, extended_bound=(-10., 10.))
m = Minuit(ulh, mean=0., sigma=0.5, N=1800.)
plt.subplot(223)
ulh.draw(m)
plt.title('Extended Before')
m.migrad() # fit
plt.subplot(224)
ulh.draw(m)
plt.title('Extended After')
#if you wonder what it looks like call describe(blh)
m = Minuit(blh, mean=0., sigma=0.5)
plt.figure(figsize=(8, 6))
plt.subplot(221)
blh.draw(m)
plt.title('Unextended Before')
m.migrad() # fit
plt.subplot(222)
blh.draw(m)
plt.title('Unextended After')
#Extended
ext_gauss = Extended(gaussian)
blh = BinnedLH(ext_gauss, data, extended=True)
m = Minuit(blh, mean=0., sigma=0.5, N=900.)
plt.subplot(223)
blh.draw(m)
plt.title('Extended Before')
m.migrad()
plt.subplot(224)
blh.draw(m)
plt.title('Extended After')
from iminuit import Minuit from probfit import BinnedLH, Extended, AddPdf, gen_toy from probfit.pdf import HistogramPdf from probfit.plotting import draw_pdf import numpy as np bound = (0, 10) np.random.seed(0) bkg = gen_toy(lambda x: x**2, 100000, bound=bound) # a parabola background sig = np.random.randn(50000) + 5 # a Gaussian signal data = np.concatenate([sig, bkg]) # fill histograms with large statistics hsig, be = np.histogram(sig, bins=40, range=bound) hbkg, be = np.histogram(bkg, bins=be, range=bound) # randomize data data = np.random.permutation(data) fitdata = data[:1000] psig = HistogramPdf(hsig, be) pbkg = HistogramPdf(hbkg, be) epsig = Extended(psig, extname='N1') epbkg = Extended(pbkg, extname='N2') pdf = AddPdf(epbkg, epsig) blh = BinnedLH(pdf, fitdata, bins=40, bound=bound, extended=True) m = Minuit(blh, N1=330, N2=670, error_N1=20, error_N2=30) #m.migrad() blh.draw(m, parts=True)
# <markdowncell>
# ####Binned $\chi^2$
# Just a $\chi^2$ with symmetric poisson error assumption. Currently doesn't support unextended fit yet(easy fix, anyone wanna do it?).
# But, binned likelihood support both extended and unextended fit.
# <codecell>
from probfit import Extended, BinnedChi2
seed(0)
gdata = randn(10000)
# <codecell>
mypdf = Extended(gaussian)
describe(mypdf) # just basically N*gaussian(x,mean,sigma)
# <codecell>
bx2 = BinnedChi2(mypdf, gdata, bound=(-3,3))#create cost function
bx2.show(args={'mean':1.0, 'sigma':1.0, 'N':10000}) #another way to draw it
# <codecell>
m = Minuit(bx2, mean=1.0, sigma=1.0, N=1000.)
m.migrad()
bx2.show(m)
# <markdowncell>
# Get run data
run = n_hits_all[i]
run_uncut = n_hits_all_uncut[i]
# Convert to numpy array
run_np = np.zeros(len(run))
for j in range(len(run)):
run_np[j] = run[j]
# Determine number of bins
n_hits_bins_plot = max(run_uncut) - min(run_uncut) + 1
n_hits_bins_fit = max(run) - min(run) + 1
# Make histogram
hist(run_uncut, bins=n_hits_bins_plot, histtype='step')
norm_const = len(run) # Normalization constant
# Get PDF
pdf_nh = Normalized(gaussian, (min(run), max(run)))
pdf_nh = Extended(pdf_nh)
# Do fit
blh_nh = BinnedLH(pdf_nh,
run_np,
bound=(low_fit_bounds[i], high_fit_bounds[i]),
bins=(high_fit_bounds[i] - low_fit_bounds[i] + 1),
extended=True)
m_nh = Minuit(blh_nh,
mean=150.,
sigma=12.,
N=400,
error_mean=10.,
error_sigma=1.,
limit_sigma=(0., 10000.),
error_N=10.,
limit_mean=(0, 800))
from numpy.random import randn
from probfit import AddPdf, BinnedLH, Extended, gaussian, rename
peak1 = randn(1000) * 0.5 + 1.0
peak2 = randn(500) * 0.5 + 0.0
# two peaks data with shared width
data = np.concatenate([peak1, peak2])
# Share the width
# If you use Normalized here. Do not reuse the object.
# It will be really slow due to cache miss. Read Normalized doc for more info.
pdf1 = rename(gaussian, ("x", "m_1", "sigma"))
pdf2 = rename(gaussian, ("x", "m_2", "sigma"))
ext_pdf1 = Extended(pdf1, extname="N_1")
ext_pdf2 = Extended(pdf2, extname="N_2")
compdf = AddPdf(ext_pdf1, ext_pdf2) # merge by name (merge sigma)
ulh = BinnedLH(compdf, data, extended=True)
m = Minuit(ulh, m_1=0.1, m_2=-0.1, sigma=0.1, N_1=900, N_2=480)
plt.figure(figsize=(8, 3))
plt.subplot(121)
ulh.draw(m, parts=True)
plt.title("Before")
m.migrad() # fit
plt.subplot(122)
hist, _ = np.histogram(tree["disc"], weights=tree["weight"], bins=bins)
signal_templates[(yuk, lam)] = (HistogramPdf(hist, bins), np.sum(hist))
print(f"Building asimov data (SM signal + background)...")
nominal = signals[(1.0, 1.0)]
asimov_data = np.concatenate([nominal["disc"], background["disc"]])
asimov_data_weights = np.concatenate([nominal["weight"], background["weight"]])
binned_asimov, _ = np.histogram(asimov_data,
weights=asimov_data_weights,
bins=bins)
binned_asimov_errors = np.sqrt(binned_asimov + syst * binned_asimov**2)
print(f"Running fits...")
results = {}
nominal_template = AddPdf(
Extended(signal_templates[(1.0, 1.0)][0], extname="s"),
Extended(bkg_template[0], extname="b"),
)
nominal_lh = BinnedLH(
nominal_template,
bin_centers,
bins=n_bins,
bound=bounds,
weights=binned_asimov,
weighterrors=binned_asimov_errors,
use_w2=True,
nint_subdiv=3,
extended=True,
)
print(f"{Style.RESET_ALL}", end="")
# careful because the distribution is discrete
n_hits_bins = (max(n_hits_proc_np) - min(n_hits_proc_np) + 1)/300
# Do the same for the full histogram
n_hits_bins_uncut = (max(n_hits_proc_uncut) - min(n_hits_proc_uncut) + 1)/300.
print n_hits_bins_uncut
# Make histogram
hist(n_hits_proc_uncut, bins=n_hits_bins_uncut, histtype='step');
# <codecell>
hist(n_hits_proc_uncut, bins=n_hits_bins_uncut, histtype='step');
# Determine a first guess for the normalization constant
norm_const = len(n_hits_proc_np)
# Get the PDF
pdf_nh = Normalized(gaussian, (min(n_hits_proc_np), max(n_hits_proc_np)))
pdf_nh = Extended(pdf_nh)
# Do the fit
blh_nh = BinnedLH(pdf_nh, n_hits_proc_np, bins=n_hits_bins, extended=True)
m_nh = Minuit(blh_nh, mean=8000., sigma= 1000., N=norm_const, error_mean=100.,
error_sigma=10.,limit_sigma=(0.,10000.), error_N=100., limit_mean=(0,100000))
m_nh.set_up(0.5)
m_nh.migrad()
blh_nh.show(m_nh);
# Generate and save figure for the number of photons
title("Number of photons detected by APD")
xlabel("Number of photons")
ylabel("Number of events")
savefig("n_ph.pdf")
# <codecell>
