def fit_2d():
#variable inizialization
im = ROOT.RooRealVar('im', 'im', 2.42, 2.52)
m23 = ROOT.RooRealVar('m23', 'm23', 0.80, 1.00)
#open and reduce dataset
rfile = ROOT.TFile("../datasets/test_xic_100invpb.root", "READ")
ds = rfile["da_lc"]
ds = ds.reduce("im > 2.42 && im < 2.52 && m23 > 0.8 && m23 < 1.")
dh = (ds.reduce(ROOT.RooArgSet(im, m23), "im>0 && m23>0")).binnedClone()
#model creation
signal_im = Models.Gauss_pdf('Gauss_x',
xvar=im,
mean=(2.45, 2.48),
sigma=(0.001, 0.01))
signal_m23 = Models.Gauss_pdf('Gauss_y',
xvar=m23,
mean=(0.8, 1.),
sigma=(0.001, 0.01))
bkg_poly_im = Models.Bkg_pdf('BkgGauss_x', xvar=im, power=0.)
bkg_poly_m23 = Models.Bkg_pdf('BkgGauss_y', xvar=m23, power=0.)
model_gauss = Models.Fit2D(signal_x=signal_im,
signal_y=signal_m23,
bkg_1x=bkg_poly_im,
bkg_1y=bkg_poly_m23)
#model fitting
result, frame = model_gauss.fitTo(dh)
result, frame = model_gauss.fitTo(ds, draw=True)
result.draw()
def test_morphing1():
logger = getLogger('test_morphing1')
if ROOT.gROOT.GetVersionInt() < 62301:
logger.warning('Test is disabled for ROOT version %s' %
ROOT.gROOT.GetVersion())
return
pdf1 = Models.Gauss_pdf('G1', xvar=mass, mean=10, sigma=1)
pdf2 = Models.Gauss_pdf('G2', xvar=mass, mean=10, sigma=2)
pdf3 = Models.Gauss_pdf('G3', xvar=mass, mean=10, sigma=3)
pdf4 = Models.Gauss_pdf('G4', xvar=mass, mean=10, sigma=4)
pdf = Morphing1D_pdf('M1', {
1.0: pdf1,
2.0: pdf2,
3.0: pdf3,
4.0: pdf4,
},
xvar=mass)
for mu in vrange(1, 3, 6):
pdf.mu = mu
logger.info('Mu= %s' % mu)
pdf.draw()
r, f = pdf.fitHisto(h1, draw=True, nbins=100, silent=True)
logger.info('Morphing: \n%s' % r.table(prefix="# "))
def test_simfit2 ( ) :
# =========================================================================
signal1 = Models.Gauss_pdf ( 'G1' ,
xvar = mass1 ,
mean = (1.5 , 6.5 ) ,
sigma = (0.1 , 2.5 ) )
model1 = Models.Fit1D ( suffix = 'M1' , signal = signal1 , background = -1 )
model1.S = NS1
model1.B = NB1
mean2 = signal1.vars_add ( signal1.mean , 10.0 )
sigma2 = signal1.vars_multiply ( signal1.sigma , 0.5 )
signal2 = Models.Gauss_pdf ( 'G2' ,
xvar = mass2 ,
mean = mean2 ,
sigma = sigma2 )
model2 = Models.Fit1D ( suffix = 'M2' , signal = signal2 , background = -1 )
model2.S = NS2
model2.B = NB2
# =========================================================================
## fit 1
r1 , f1 = model1.fitTo ( dataset1 , draw = True , nbins = 50 , silent = True )
## fit 2
r2 , f2 = model2.fitTo ( dataset2 , draw = True , nbins = 50 , silent = True )
# =========================================================================
## combine data
sample = ROOT.RooCategory ('sample','sample' , 'A' , 'B' )
## combine datasets
from ostap.fitting.simfit import combined_data
vars = ROOT.RooArgSet ( mass1 , mass2 )
dataset = combined_data ( sample , vars , { 'A' : dataset1 , 'B' : dataset2 } )
## combine PDFs
model_sim = Models.SimFit (
sample , { 'A' : model1 , 'B' : model2 } , name = 'X'
)
# =========================================================================
r , f = model_sim.fitTo ( dataset , silent = True )
r , f = model_sim.fitTo ( dataset , silent = True )
fA = model_sim.draw ( 'A' , dataset , nbins = 50 )
fB = model_sim.draw ( 'B' , dataset , nbins = 50 )
fNLL = model_sim.draw_nll ( 'SM2' , dataset , range = (0,1000) )
## significance
wilks = model_sim.wilks ( 'SM2' , dataset )
logger.info ( 'Fit results are: %s ' % r )
def test_simfit2():
logger = getLogger('test_simfit2')
# =========================================================================
signal1 = Models.Gauss_pdf('G1',
xvar=mass1,
mean=(1.5, 6.5),
sigma=(0.1, 2.5))
model1 = Models.Fit1D(suffix='M1', signal=signal1, background=-1)
model1.S = NS1
model1.B = NB1
mean2 = signal1.vars_add(signal1.mean, 10.0)
sigma2 = signal1.vars_multiply(signal1.sigma, 0.5)
signal2 = Models.Gauss_pdf('G2', xvar=mass2, mean=mean2, sigma=sigma2)
model2 = Models.Fit1D(suffix='M2', signal=signal2, background=-1)
model2.S = NS2
model2.B = NB2
with use_canvas('test_simfit2'):
# =========================================================================
## fit 1
with wait(1):
r1, f1 = model1.fitTo(dataset1, draw=True, nbins=50, silent=True)
title = 'Results of fit to dataset1'
logger.info('%s\n%s' % (title, r1.table(title=title, prefix='# ')))
## fit 2
with wait(1):
r2, f2 = model2.fitTo(dataset2, draw=True, nbins=50, silent=True)
title = 'Results of fit to dataset2'
logger.info('%s\n%s' % (title, r2.table(title=title, prefix='# ')))
# =========================================================================
## combine data
sample = ROOT.RooCategory('sample', 'sample', 'A', 'B')
## combine datasets
from ostap.fitting.simfit import combined_data
vars = ROOT.RooArgSet(mass1, mass2)
dataset = combined_data(sample, vars, {'A': dataset1, 'B': dataset2})
## combine PDFs
model_sim = Models.SimFit(sample, {'A': model1, 'B': model2}, name='X')
# =========================================================================
r, f = model_sim.fitTo(dataset, silent=True)
r, f = model_sim.fitTo(dataset, silent=True)
title = 'Results of simultaneous fit'
logger.info('%s\n%s' % (title, r.table(title=title, prefix='# ')))
with use_canvas('test_simfit2'):
with wait(1):
fA = model_sim.draw('A', dataset, nbins=50)
with wait(1):
fB = model_sim.draw('B', dataset, nbins=50)
def test_simfit1():
logger = getLogger('test_simfit1')
signal1 = Models.Gauss_pdf('G1',
xvar=mass,
mean=(0.5, 2.5),
sigma=(0.1, 1.0))
model1 = Models.Fit1D(suffix='M1', signal=signal1, background=-1)
model1.S = NS1
model1.B = NB1
mean2 = signal1.vars_add(signal1.mean, 1.0)
sigma2 = signal1.vars_multiply(signal1.sigma, 0.5)
signal2 = Models.Gauss_pdf('G2', xvar=mass, mean=mean2, sigma=sigma2)
model2 = Models.Fit1D(suffix='M2',
signal=signal2,
background=model1.background)
model2.S = NS2
model2.B = NB2
with use_canvas('test_simfit1'):
# =========================================================================
## fit 1
with wait(1):
r1, f1 = model1.fitTo(dataset1, draw=True, nbins=50, silent=True)
## fit 2
with wait(1):
r2, f2 = model2.fitTo(dataset2, draw=True, nbins=50, silent=True)
# =========================================================================
## combine data
sample = ROOT.RooCategory('sample', 'sample', 'A', 'B')
## combine datasets
from ostap.fitting.simfit import combined_data
vars = ROOT.RooArgSet(mass)
dataset = combined_data(sample, vars, {'A': dataset1, 'B': dataset2})
## combine PDFs
model_sim = Models.SimFit(sample, {'A': model1, 'B': model2}, name='X')
# =========================================================================
r, f = model_sim.fitTo(dataset, silent=True)
r, f = model_sim.fitTo(dataset, silent=True)
with use_canvas('test_simfit1'):
with wait(1):
fA = model_sim.draw('A', dataset, nbins=50)
with wait(1):
fB = model_sim.draw('B', dataset, nbins=50)
logger.info('Fit results are: %s ' % r)
def test_model_13():
logger.info(
'Non-factorizeable fit component: ( Gauss + expo*P1 ) (x) ( Gauss + expo*P1 ) + (Expo*PS)**2'
)
PS = Ostap.Math.PhaseSpaceNL(1.0, 5.0, 2, 5)
model = Models.Fit2D(suffix='_13',
signal_1=Models.Gauss_pdf('Gx',
m_x.getMin(),
m_x.getMax(),
mass=m_x),
signal_2=Models.Gauss_pdf('Gy',
m_y.getMin(),
m_y.getMax(),
mass=m_y),
power1=1,
power2=1,
bkg2D=Models.ExpoPSPol2D_pdf('P2D13',
m_x,
m_y,
psy=PS,
nx=1,
ny=1))
model.signal1.sigma.fix(m.error())
model.signal2.sigma.fix(m.error())
model.signal1.mean.fix(m.value())
model.signal2.mean.fix(m.value())
model.signal1.mean.fix(m.value())
model.signal2.mean.fix(m.value())
model.bkg1.tau.fix(0)
model.bkg2.tau.fix(0)
## fit with fixed mass and sigma
with rooSilent():
result, frame = model.fitTo(dataset)
model.signal1.sigma.release()
model.signal2.sigma.release()
model.signal1.mean.release()
model.signal2.mean.release()
result, frame = model.fitTo(dataset)
if 0 != result.status() or 3 != result.covQual():
logger.warning('Fit is not perfect MIGRAD=%d QUAL=%d ' %
(result.status(), result.covQual()))
print result
else:
logger.info('S1xS2 : %20s' % result(model.ss)[0])
logger.info('S1xB2 : %20s' % result(model.sb)[0])
logger.info('B1xS2 : %20s' % result(model.bs)[0])
logger.info('B1xB2 : %20s' % result(model.bb)[0])
models.add(model)
def test_model_15():
logger.info(
'Non-factorized symmetric background component (spline): ( Gauss + expo*P1 ) (x) ( Gauss + expo*P1 ) + Spline2Dsym'
)
SPLINES = Ostap.Math.Spline2DSym(spline1)
model = Models.Fit2D(suffix='_15',
signal_1=Models.Gauss_pdf('Gx',
m_x.getMin(),
m_x.getMax(),
mass=m_x),
signal_2=Models.Gauss_pdf('Gy',
m_y.getMin(),
m_y.getMax(),
mass=m_y),
power1=1,
power2=1,
bkg2D=Models.Spline2Dsym_pdf('P2D15',
m_x,
m_y,
spline=SPLINES))
model.signal1.sigma.fix(m.error())
model.signal2.sigma.fix(m.error())
model.signal1.mean.fix(m.value())
model.signal2.mean.fix(m.value())
model.signal1.mean.fix(m.value())
model.signal2.mean.fix(m.value())
model.bkg1.tau.fix(0)
model.bkg2.tau.fix(0)
## fit with fixed mass and sigma
with rooSilent():
result, frame = model.fitTo(dataset)
model.signal1.sigma.release()
model.signal2.sigma.release()
model.signal1.mean.release()
model.signal2.mean.release()
result, frame = model.fitTo(dataset)
if 0 != result.status() or 3 != result.covQual():
logger.warning('Fit is not perfect MIGRAD=%d QUAL=%d ' %
(result.status(), result.covQual()))
print result
else:
logger.info('S1xS2 : %20s' % result(model.ss)[0])
logger.info('S1xB2 : %20s' % result(model.sb)[0])
logger.info('B1xS2 : %20s' % result(model.bs)[0])
logger.info('B1xB2 : %20s' % result(model.bb)[0])
models.add(model)
def test_psxps_BBsym():
logger.info(
'Simmetric fit model with non-factorizeable background component: ( Gauss + expo*P1 ) (x) ( Gauss + expo*P1 ) + (PS*P1)**2'
)
PS = Ostap.Math.PhaseSpaceNL(1.0, 5.0, 2, 5)
model = Models.Fit2DSym(suffix='_12',
signal_1=Models.Gauss_pdf('Gx',
m_x.getMin(),
m_x.getMax(),
mass=m_x),
signal_2=Models.Gauss_pdf('Gy',
m_y.getMin(),
m_y.getMax(),
mass=m_y),
bkg1=1,
bkg2D=Models.PSPol2Dsym_pdf('P2D12',
m_x,
m_y,
ps=PS,
n=1))
model.signal1.sigma.fix(m.error())
model.signal2.sigma.fix(m.error())
model.signal1.mean.fix(m.value())
model.signal2.mean.fix(m.value())
model.signal1.mean.fix(m.value())
model.signal2.mean.fix(m.value())
model.bkg1.tau.fix(0)
model.bkg2.tau.fix(0)
## fit with fixed mass and sigma
with rooSilent():
result, frame = model.fitTo(dataset)
model.signal1.sigma.release()
model.signal2.sigma.release()
model.signal1.mean.release()
model.signal2.mean.release()
result, frame = model.fitTo(dataset)
if 0 != result.status() or 3 != result.covQual():
logger.warning('Fit is not perfect MIGRAD=%d QUAL=%d ' %
(result.status(), result.covQual()))
print result
else:
logger.info('S1xS2 : %20s' % result(model.ss)[0])
logger.info('S1xB2 : %20s' % (result(model.sb)[0] / 2))
logger.info('B1xS2 : %20s' % (result(model.bs)[0] / 2))
logger.info('B1xB2 : %20s' % result(model.bb)[0])
models.add(model)
def test_p1xp1_BB():
logger.info(
'Simplest non-factorized fit model: ( Gauss + P1 ) (x) ( Gauss + P1 ) + BB'
)
model = Models.Fit2D(suffix='_3',
signal_1=Models.Gauss_pdf('Gx',
m_x.getMin(),
m_x.getMax(),
mass=m_x),
signal_2=Models.Gauss_pdf('Gy',
m_y.getMin(),
m_y.getMax(),
mass=m_y),
power1=1,
power2=1,
bkg2D=Models.PolyPos2D_pdf('P2D',
m_x,
m_y,
nx=2,
ny=2))
model.signal1.sigma.fix(m.error())
model.signal2.sigma.fix(m.error())
model.signal1.mean.fix(m.value())
model.signal2.mean.fix(m.value())
model.signal1.mean.fix(m.value())
model.signal2.mean.fix(m.value())
model.bkg1.tau.fix(0)
model.bkg2.tau.fix(0)
## fit with fixed mass and sigma
with rooSilent():
result, frame = model.fitTo(dataset)
model.signal1.sigma.release()
model.signal2.sigma.release()
model.signal1.mean.release()
model.signal2.mean.release()
result, frame = model.fitTo(dataset)
if 0 != result.status() or 3 != result.covQual():
logger.warning('Fit is not perfect MIGRAD=%d QUAL=%d ' %
(result.status(), result.covQual()))
print result
else:
logger.info('S1xS2 : %20s' % result(model.ss)[0])
logger.info('S1xB2 : %20s' % result(model.sb)[0])
logger.info('B1xS2 : %20s' % result(model.bs)[0])
logger.info('B1xB2 : %20s' % result(model.bb)[0])
models.add(model)
def test_p1xp1_BBss():
logger.info(
'Symmetrised fit model with non-factorized symmetric background: ( Gauss + P1 ) (x) ( Gauss + P1 ) + BBsym'
)
sb = ROOT.RooRealVar('sb', 'SB', 0, 10000)
model = Models.Fit2D(suffix='_5',
signal_1=Models.Gauss_pdf('Gx',
m_x.getMin(),
m_x.getMax(),
mass=m_x),
signal_2=Models.Gauss_pdf('Gy',
m_y.getMin(),
m_y.getMax(),
mass=m_y),
power1=1,
power2=1,
bkg2D=Models.PolyPos2Dsym_pdf('P2Ds', m_x, m_y, n=2),
sb=sb,
bs=sb)
model.signal1.sigma.fix(m.error())
model.signal2.sigma.fix(m.error())
model.signal1.mean.fix(m.value())
model.signal2.mean.fix(m.value())
model.signal1.mean.fix(m.value())
model.signal2.mean.fix(m.value())
model.bkg1.tau.fix(0)
model.bkg2.tau.fix(0)
## fit with fixed mass and sigma
with rooSilent():
result, frame = model.fitTo(dataset)
model.signal1.sigma.release()
model.signal2.sigma.release()
model.signal1.mean.release()
model.signal2.mean.release()
result, frame = model.fitTo(dataset)
if 0 != result.status() or 3 != result.covQual():
logger.warning('Fit is not perfect MIGRAD=%d QUAL=%d ' %
(result.status(), result.covQual()))
print result
else:
logger.info('S1xS2 : %20s' % result(model.ss)[0])
logger.info('S1xB2 : %20s' % result(model.sb)[0])
logger.info('B1xS2 : %20s' % result(model.bs)[0])
logger.info('B1xB2 : %20s' % result(model.bb)[0])
models.add(model)
def test_pbxpb_BBs():
logger.info(
'Non-factorizeable background component: ( Gauss + expo*P1 ) (x) ( Gauss + expo*P1 ) + Sym(expo*P1)**2'
)
model = Models.Fit2D(suffix='_8',
signal_1=Models.Gauss_pdf('Gx',
m_x.getMin(),
m_x.getMax(),
mass=m_x),
signal_2=Models.Gauss_pdf('Gy',
m_y.getMin(),
m_y.getMax(),
mass=m_y),
power1=1,
power2=1,
bkg2D=Models.ExpoPol2Dsym_pdf('P2D8', m_x, m_y, n=1))
model.signal1.sigma.fix(m.error())
model.signal2.sigma.fix(m.error())
model.signal1.mean.fix(m.value())
model.signal2.mean.fix(m.value())
model.signal1.mean.fix(m.value())
model.signal2.mean.fix(m.value())
model.bkg1.tau.fix(0)
model.bkg2.tau.fix(0)
## fit with fixed mass and sigma
with rooSilent():
result, frame = model.fitTo(dataset)
model.signal1.sigma.release()
model.signal2.sigma.release()
model.signal1.mean.release()
model.signal2.mean.release()
result, frame = model.fitTo(dataset)
if 0 != result.status() or 3 != result.covQual():
logger.warning('Fit is not perfect MIGRAD=%d QUAL=%d ' %
(result.status(), result.covQual()))
print result
else:
logger.info('S1xS2 : %20s' % result(model.ss)[0])
logger.info('S1xB2 : %20s' % result(model.sb)[0])
logger.info('B1xS2 : %20s' % result(model.bs)[0])
logger.info('B1xB2 : %20s' % result(model.bb)[0])
models.add(model)
def test_const():
logger.info(
'Simplest (factorized) fit model: ( Gauss + const ) x ( Gauss + const ) '
)
model = Models.Fit2D(signal_1=Models.Gauss_pdf('Gx',
m_x.getMin(),
m_x.getMax(),
mass=m_x),
signal_2=Models.Gauss_pdf('Gy',
m_y.getMin(),
m_y.getMax(),
mass=m_y))
model.signal1.sigma.fix(m.error())
model.signal2.sigma.fix(m.error())
model.signal1.mean.fix(m.value())
model.signal2.mean.fix(m.value())
model.signal1.mean.fix(m.value())
model.signal2.mean.fix(m.value())
model.bkg1.tau.fix(0)
model.bkg2.tau.fix(0)
model.bkgA.tau.fix(0)
model.bkgB.tau.fix(0)
## fit with fixed mass and sigma
with rooSilent():
result, frame = model.fitTo(dataset)
model.signal1.sigma.release()
model.signal2.sigma.release()
model.signal1.mean.release()
model.signal2.mean.release()
result, frame = model.fitTo(dataset)
if 0 != result.status() or 3 != result.covQual():
logger.warning('Fit is not perfect MIGRAD=%d QUAL=%d ' %
(result.status(), result.covQual()))
print result
else:
logger.info('S1xS2 : %20s' % result(model.ss)[0])
logger.info('S1xB2 : %20s' % result(model.sb)[0])
logger.info('B1xS2 : %20s' % result(model.bs)[0])
logger.info('B1xB2 : %20s' % result(model.bb)[0])
models.add(model)
def test_significance_toys():
"""Perform toy-study for significance of the signal
- generate `nToys` pseudoexperiments using background-only hypothesis
- fit each experiment with signal+background hypothesis
- store fit results
- fill distributions for fit results
"""
logger = getLogger('test_significance_toys')
## only background hypothesis
bkg_only = Models.Bkg_pdf("BKG", xvar=mass, power=0, tau=0)
signal = Models.Gauss_pdf('S', xvar=mass, mean=0.5, sigma=0.1)
signal.mean.fix(0.4)
signal.sigma.fix(0.1)
## signal + background hypothesis
model = Models.Fit1D(signal=signal, background=1)
model.background.tau.fix(0)
results, stats = Toys.make_toys2(
gen_pdf=bkg_only,
fit_pdf=model,
nToys=1000,
data=[mass],
gen_config={
'nEvents': 100,
'sample': True
},
fit_config={'silent': True},
gen_pars={'tau_BKG': 0.}, ## initial values for generation
fit_pars={
'B': 100,
'S': 10,
'phi0_Bkg_S': 0.0
}, ## initial fit values for parameters
silent=True,
progress=True)
for p in stats:
logger.info("Toys: %-20s : %s" % (p, stats[p]))
h_S = ROOT.TH1F(hID(), '#S', 60, 0, 60)
for r in results['S']:
h_S.Fill(r)
for h in (h_S, ):
h.draw()
logger.info("%s :\n%s" % (h.GetTitle(), h.dump(30, 10)))
time.sleep(1)
def test_morphing1():
pdf1 = Models.Gauss_pdf('G1', xvar=mass, mean=10, sigma=1)
pdf2 = Models.Gauss_pdf('G2', xvar=mass, mean=10, sigma=2)
pdf3 = Models.Gauss_pdf('G3', xvar=mass, mean=10, sigma=3)
pdf4 = Models.Gauss_pdf('G4', xvar=mass, mean=10, sigma=4)
pdf = Morphing1D_pdf('M', {
1.0: pdf1,
2.0: pdf2,
3.0: pdf3,
4.0: pdf4,
},
xvar=mass)
for mu in vrange(1, 3, 6):
pdf.mu = mu
logger.info('Mu= %s' % mu)
pdf.draw()
r, f = pdf.fitHisto(h1, draw=True, nbins=100, silent=True)
logger.info('Morphing: \n%s' % r.table(prefix="# "))
def test_transform():
logger = getLogger('test_transform')
if not 62000 <= ROOT.gROOT.GetVersionInt():
logger.info("Not for this version of ROOT")
return
x = ROOT.RooRealVar('x', '', 1, 100000)
mean = 1000
sigma = 1000
## book very simple data set
varset = ROOT.RooArgSet(x)
dataset = ROOT.RooDataSet(dsID(), 'Test Data set', varset)
while len(dataset) < 5000:
v = random.gauss(mean, sigma)
if v in x:
x.value = v
dataset.add(varset)
dataset.add_var('lx', 'log10(x)')
dataset.lx.setMin(0)
dataset.lx.setMax(5)
## original PDF
gauss = Models.Gauss_pdf('G',
xvar=x,
mean=(mean, mean / 2, mean * 2),
sigma=(sigma, sigma / 2, sigma * 2))
with use_canvas('test_transform'), wait(1):
r1, f1 = gauss.fitTo(dataset, draw=True, silent=True)
logger.info('Fit x:\n%s' % r1.table())
lx = dataset.lx
LX = Fun1D(lx, lx)
NX = 10**LX
## transformed PDF
tgauss = TrPDF(pdf=gauss, new_var=NX)
with use_canvas('test_transform'), wait(1):
r2, f2 = tgauss.fitTo(dataset, draw=True, silent=True)
logger.info('Fit log10(x):\n%s' % r2.table())
def fit_gaus():
im = ROOT.RooRealVar('im', 'im', 2.42, 2.52)
sig_ap = Models.Gauss_pdf('Gauss',
xvar=im,
mean=(2.46, 2.47),
sigma=(0.001, 0.01))
bkg0 = Models.Bkg_pdf('bkg0', xvar=im, power=1.)
model = Models.Fit1D(signal=sig_ap, background=bkg0)
rfile = ROOT.TFile("../datasets/test_xic_100invpb.root", "READ")
ds = rfile["da_lc"]
ds = ds.reduce("im > 2.42 && im < 2.52")
dh = (ds.reduce(ROOT.RooArgSet(im), "im>0")).binnedClone()
r, w = model.fitTo(dh)
r, w = model.fitTo(ds, draw=True, nbins=300, ncpu=4)
pull = model.pull(ds)
f, r, pull = model.draw(ds, nbins=100, residual='P', pull='P')
return w, pull
m_x.value = random.uniform(*m_x.minmax())
m_y.value = m.gauss()
dataset.add(varset)
## fill it : 1000 events const * const *Gauss
for i in range(0, N_bb):
m_x.value = random.uniform(*m_x.minmax())
m_y.value = random.uniform(*m_y.minmax())
dataset.add(varset)
logger.info('Dataset: %s' % dataset)
## various fit components
signal_x1 = Models.Gauss_pdf('G1x',
xvar=m_x,
mean=m1.value(),
sigma=m1.error())
signal_y1 = signal_x1.clone(name='G1y', xvar=m_y)
signal_x2 = Models.Gauss_pdf(name='G2x',
xvar=m_x,
mean=m2.value(),
sigma=m2.error())
signal_y2 = signal_x2.clone(name='G2y', xvar=m_y)
bkg_x = make_bkg(-1, 'Bx', m_x)
bkg_y = bkg_x.clone(name='By', xvar=m_y)
# S(x)*S(y) component
ss_cmp = signal_x2 * signal_y2
def test_simfit4():
# =========================================================================
VARS = MakeVar()
## MC/DATA ratio for signal widths
Rs = ROOT.RooRealVar('Rs', 'MC/DATA ratio for signal widths', 1.0, 0.2,
3.0)
## sigma for normalization peak: sigma from MC multiplied by a factor
sigma_N = VARS.vars_multiply(Rs, sigma1, name='sigma_N')
## sigma for signal peak: sigma from MC multiplied by the same factor
sigma_S = VARS.vars_multiply(Rs, sigma2, name='sigma_S')
## Normalization peak:
signal_N = Models.Gauss_pdf('GN', xvar=mass1, mean=(3, 8), sigma=sigma_N)
## mean of low-statistics signal is constrained to the mean of high statistic signal
mean_S = VARS.vars_sum(signal_N.mean, mean2 - mean1)
## low statistic signal :
signal_S = Models.Gauss_pdf('GS', xvar=mass2, mean=mean_S, sigma=sigma_S)
# =========================================================================
## model for fitting of normalization channel
model_N = Models.Fit1D(suffix='N', signal=signal_N,
background=-2) ## 2nd order positive polynomial
model_N.S = NS1
model_N.B = NB1
## model for fitting of low-statistic signal channel
model_S = Models.Fit1D(suffix='S', signal=signal_S,
background=-2) ## 2nd order positive polynomial
model_S.S = NS2
model_S.B = NB2
# =========================================================================
## make fit for thew normalization channel only
# =========================================================================
rN, fN = model_N.fitTo(dataset1, draw=None, silent=True)
rN, fN = model_N.fitTo(dataset1, draw=None, silent=True)
rN, fN = model_N.fitTo(dataset1, draw=True, nbins=50, silent=True)
logger.info('Fit results for normalization sample only: %s' % rN)
# =========================================================================
## make fit for the low-statistic signal channel only
# =========================================================================
rS, fS = model_S.fitTo(dataset2, draw=None, silent=True)
rS, fS = model_S.fitTo(dataset2, draw=None, silent=True)
rS, fS = model_S.fitTo(dataset2, draw=True, nbins=50, silent=True)
logger.info('Fit results for low-statistic signal only: %s' % rS)
# =========================================================================
## combine data for simultaneous fit
# =========================================================================
sample = ROOT.RooCategory('sample', 'sample', 'S', 'N')
## combine datasets
from ostap.fitting.simfit import combined_data
vars = ROOT.RooArgSet(mass1, mass2)
dataset = combined_data(sample, vars, {'N': dataset1, 'S': dataset2})
## combine PDFs
model_sim = Models.SimFit(sample, {'S': model_S, 'N': model_N}, name='X')
# =========================================================================
rC, fC = model_sim.fitTo(dataset, silent=True)
rC, fC = model_sim.fitTo(dataset, silent=True)
rC, fC = model_sim.fitTo(dataset, silent=True)
fN = model_sim.draw('N', dataset, nbins=50)
fS = model_sim.draw('S', dataset, nbins=50)
logger.info('Combined fit results are: %s ' % rC)
logger.info(' Value | Simple fit | Combined fit ')
logger.info(' #N | %25s | %-25s ' % (rS.SS * 1, rC.SS * 1))
logger.info(' mean | %25s | %-25s ' % (rS.mean_GN * 1, rC.mean_GN * 1))
logger.info(' Rs | %25s | %-25s ' % (rS.Rs * 1, rC.Rs * 1))
for i in range(0, 5000):
mass.value = m.gauss()
dataset0.add(varset0)
for i in range(0, 500):
mass.value = random.uniform(mmin, mmax)
dataset0.add(varset0)
logger.info('DATASET\n%s' % dataset0)
models = set()
## signal component
signal_gauss = Models.Gauss_pdf(
name='Gauss', ## the name
xvar=mass, ## the variable
mean=m.value(), ## mean value (fixed)
sigma=m.error()) ## sigma (fixed)
## construct composite model: signal + background
model_gauss = Models.Fit1D(
signal=signal_gauss,
background=Models.Bkg_pdf('BkgGauss', xvar=mass, power=0),
)
S = model_gauss.S
B = model_gauss.B
# =============================================================================
## gauss PDF
def test_fitting_components_3D():
logger = getLogger('test_fitting_components_3D')
## make simple test mass
m_x = ROOT.RooRealVar('mass_x', 'Some test mass(X)', 0, 10)
m_y = ROOT.RooRealVar('mass_y', 'Some test mass(Y)', 0, 10)
m_z = ROOT.RooRealVar('mass_z', 'Some test mass(z)', 0, 10)
## book very simple data set
varset = ROOT.RooArgSet(m_x, m_y, m_z)
dataset = ROOT.RooDataSet(dsID(), 'Test Data set-1', varset)
m1 = VE(3, 0.10**2)
m2 = VE(7, 0.20**2)
## fill it
N_sss = 5000
N_ssb = 500
N_sbs = 500
N_bss = 1000
N_bbs = 500
N_bsb = 100
N_sbb = 100
N_bbb = 250
random.seed(0)
## fill it : 5000 events Gauss * Gauss *Gauss
for m in (m1, m2):
## S x S x S
for i in range(N_sss):
m_x.value = m.gauss()
m_y.value = m.gauss()
m_z.value = m.gauss()
dataset.add(varset)
## S x S x B
for i in range(0, N_bss):
m_x.value = m.gauss()
m_y.value = m.gauss()
m_z.value = random.uniform(*m_z.minmax())
dataset.add(varset)
## S x B x S
for i in range(N_ssb):
m_x.value = m.gauss()
m_y.value = random.uniform(*m_y.minmax())
m_z.value = m.gauss()
dataset.add(varset)
## B x S x S
for i in range(N_sbs):
m_x.value = random.uniform(*m_x.minmax())
m_y.value = m.gauss()
m_z.value = m.gauss()
dataset.add(varset)
## B x B X S
for i in range(N_sbb):
m_x.value = random.uniform(*m_x.minmax())
m_y.value = random.uniform(*m_y.minmax())
m_z.value = m.gauss()
dataset.add(varset)
## B x S x B
for i in range(N_bsb):
m_x.value = random.uniform(*m_x.minmax())
m_y.value = m.gauss()
m_z.value = random.uniform(*m_y.minmax())
dataset.add(varset)
## S x B x B
for i in range(N_sbb):
m_x.value = m.gauss()
m_y.value = random.uniform(*m_y.minmax())
m_z.value = random.uniform(*m_y.minmax())
dataset.add(varset)
## B x B x B
for i in range(N_bbb):
m_x.value = random.uniform(*m_x.minmax())
m_y.value = random.uniform(*m_y.minmax())
m_z.value = random.uniform(*m_y.minmax())
dataset.add(varset)
logger.info('Dataset:\n%s' % dataset.table(prefix='# '))
## various fit components for main fit model :
signal_x1 = Models.Gauss_pdf('G1x',
xvar=m_x,
mean=m1.value(),
sigma=m1.error())
signal_y1 = signal_x1.clone(name='G1y', xvar=m_y)
signal_z1 = signal_x1.clone(name='G1z', xvar=m_z)
bkg_x = make_bkg(-1, 'Bx', m_x)
bkg_y = bkg_x.clone(name='By', xvar=m_y)
bkg_z = bkg_x.clone(name='Bz', xvar=m_z)
## construct other components
signal_x2 = Models.Gauss_pdf(name='G2x',
xvar=m_x,
mean=m2.value(),
sigma=m2.error())
signal_y2 = signal_x2.clone(name='G2y', xvar=m_y)
signal_z2 = signal_x2.clone(name='G2z', xvar=m_z)
## S(x) * S(y) components
ss_cmp = signal_x2 * signal_y2
## S(x) * B(y) component
sb_cmp = signal_x2 * bkg_y
## B(x) * S(y) component
bs_cmp = bkg_x * signal_y2
## B(x) * B(y) component
bb_cmp = bkg_x * bkg_y
## S(x) * S(y) * S(z) component
sss_cmp = ss_cmp * signal_z2
## S(x) * S(y) * B(z) component
ssb_cmp = ss_cmp * bkg_z
## S(x) * B(y) * S(z) component
sbs_cmp = sb_cmp * signal_z2
## S(x) * B(y) * S(z) component
bss_cmp = bs_cmp * signal_z2
## S(x) * B(y) * B(z) component
sbb_cmp = sb_cmp * bkg_z
## B(x) * S(y) * B(z) component
bsb_cmp = bs_cmp * bkg_z
## B(x) * B(y) * S(z) component
bbs_cmp = bs_cmp * signal_z2
model = Models.Fit3D(
name='fit_comp',
signal_x=signal_x1,
signal_y=signal_y1,
signal_z=signal_z1,
bkg_1x=bkg_x,
bkg_1y=bkg_y,
bkg_1z=bkg_z,
suffix="_1",
##
components=[
sss_cmp, ssb_cmp, sbs_cmp, bss_cmp, sbb_cmp, bsb_cmp, bbs_cmp
])
model.SSS = N_sss
model.SSB = N_ssb
model.SBS = N_sbs
model.BSS = N_bss
model.BBS = N_bbs
model.BSB = N_bsb
model.SBB = N_sbb
model.BBB = N_bbb
model.C = N_sss, N_ssb, N_sbs, N_sbb, N_bss, N_sbs, N_bbs
r = model.fitTo(dataset, silent=True)
r = model.fitTo(dataset, silent=True)
with use_canvas('test_fitting_components_3D'):
with wait(2):
model.draw1(dataset)
with wait(2):
model.draw2(dataset)
with wait(2):
model.draw3(dataset)
logger.info('Model %s Fit result\n%s ' %
(model.name, r.table(prefix='# ')))
def test_toys_simfit_1():
## make simple test mass
mass = ROOT.RooRealVar('test_mass', 'Some test mass', 0, 5)
## book very simple data set:
varset1 = ROOT.RooArgSet(mass)
dataset1 = ROOT.RooDataSet(dsID(), 'Test Data set-1', varset1)
## book very simple data set:
varset2 = ROOT.RooArgSet(mass)
dataset2 = ROOT.RooDataSet(dsID(), 'Test Data set-2', varset2)
## high statistic, low-background "control channel"
mean1 = 2.0
sigma1 = 0.50
NS1 = 1000
NB1 = 250
for i in range(NS1):
v1 = random.gauss(mean1, sigma1)
if v1 in mass:
mass.setVal(v1)
dataset1.add(varset1)
for i in range(NB1):
v1 = random.uniform(0, 5)
if v1 in mass:
mass.setVal(v1)
dataset1.add(varset1)
## low statistic, high-background "control channel"
NS2 = 250
NB2 = 1000
mean2 = mean1 + 1.0
sigma2 = sigma1 * 0.5
for i in range(NS2):
v2 = random.gauss(mean2, sigma2)
if v2 in mass:
mass.setVal(v2)
dataset2.add(varset2)
for i in range(NB2):
v2 = random.uniform(0, 5)
if v2 in mass:
mass.setVal(v2)
dataset2.add(varset2)
signal1 = Models.Gauss_pdf('G1',
xvar=mass,
mean=(0.5, 2.5),
sigma=(0.1, 1.0))
model1 = Models.Fit1D(suffix='M1', signal=signal1, background=-1)
model1.S = NS1
model1.B = NB1
mean2 = signal1.vars_add(signal1.mean, 1.0)
sigma2 = signal1.vars_multiply(signal1.sigma, 0.5)
signal2 = Models.Gauss_pdf('G2', xvar=mass, mean=mean2, sigma=sigma2)
model2 = Models.Fit1D(suffix='M2',
signal=signal2,
background=model1.background)
model2.S = NS2
model2.B = NB2
# =========================================================================
## fit 1
r1, f1 = model1.fitTo(dataset1, draw=True, nbins=50, silent=True)
## fit 2
r2, f2 = model2.fitTo(dataset2, draw=True, nbins=50, silent=True)
# =========================================================================
## combine data
sample = ROOT.RooCategory('sample', 'sample', 'A', 'B')
## combine datasets
from ostap.fitting.simfit import combined_data
vars = ROOT.RooArgSet(mass)
dataset = combined_data(sample, vars, {'A': dataset1, 'B': dataset2})
## combine PDFs
model_sim = Models.SimFit(sample, {'A': model1, 'B': model2}, name='X')
# =========================================================================
r, f = model_sim.fitTo(dataset, silent=True)
r, f = model_sim.fitTo(dataset, silent=True)
fA = model_sim.draw('A', dataset, nbins=50)
fB = model_sim.draw('B', dataset, nbins=50)
logger.info('Fit results are: %s ' % r.table(prefix="# "))
## Make toys
results, stats = Toys.make_toys(pdf=model_sim,
nToys=100,
data=[mass],
gen_config={
'nEvents': (NS1 + NB1, NS2 + NB2),
'sample': True
},
fit_config={'silent': True},
init_pars={
'mean_G1': mean1,
'BM1': NB1,
'BM2': NB2,
'sigma_G1': sigma1,
'SM1': NS1,
'SM2': NS2,
'phi0_Bkg_FitG1_M1': 0
},
silent=True,
progress=True)
# =============================================================================
# logging
# =============================================================================
from ostap.logger.logger import getLogger
if '__main__' == __name__ or '__builtin__' == __name__:
logger = getLogger('test_fitting_toys')
else:
logger = getLogger(__name__)
# =============================================================================
import ROOT, time
from ostap.core.pyrouts import hID
import ostap.fitting.models as Models
import ostap.parallel.parallel_toys as Toys
mass = ROOT.RooRealVar('mass', '', 0, 1)
gen_gauss = Models.Gauss_pdf('GG', xvar=mass)
fit_gauss = Models.Gauss_pdf('FG', xvar=mass)
gen_gauss.mean = 0.4
gen_gauss.sigma = 0.1
# ==============================================================================
## Perform toy-study for possible fit bias and correct uncertainty evaluation
# - generate <code>nToys</code> pseudoexperiments with some PDF <code>pdf</code>
# - fit teach experiment with the same PDF
# - store fit results
# - calculate staistics of pulls
# - fill distributions for fit results
# - fill distribution of pulls
def test_parallel_toys():
"""Perform toys-study for possible fit bias and correct uncertainty evaluation
def test_simfit4():
logger = getLogger('test_simfit4')
# =========================================================================
VARS = MakeVar()
## MC/DATA ratio for signal widths
Rs = ROOT.RooRealVar('Rs', 'MC/DATA ratio for signal widths', 1.0, 0.2,
3.0)
## sigma for normalization peak: sigma from MC multiplied by a factor
sigma_N = VARS.vars_multiply(Rs, sigma1, name='sigma_N')
## sigma for signal peak: sigma from MC multiplied by the same factor
sigma_S = VARS.vars_multiply(Rs, sigma2, name='sigma_S')
## Normalization peak:
signal_N = Models.Gauss_pdf('GN', xvar=mass1, mean=(3, 8), sigma=sigma_N)
## mean of low-statistics signal is constrained to the mean of high statistic signal
mean_S = VARS.vars_sum(signal_N.mean, mean2 - mean1)
## low statistic signal :
signal_S = Models.Gauss_pdf('GS', xvar=mass2, mean=mean_S, sigma=sigma_S)
# =========================================================================
## 3rd order positive polynomial
bkg_N = Models.make_bkg(-3, 'Bkg_N', mass1)
## model for fitting of normalization channel
model_N = Models.Fit1D(suffix='N', signal=signal_N, background=bkg_N)
model_N.S = NS1
model_N.B = NB1
## 3rd order positive polynomial
bkg_S = Models.make_bkg(-3, 'Bkg_S', mass2)
## model for fitting of low-statistic signal channel
model_S = Models.Fit1D(suffix='S', signal=signal_S, background=bkg_S)
model_S.S = NS2
model_S.B = NB2
# =========================================================================
## make fit for thew normalization channel only
# =========================================================================
with use_canvas('test_simfit4'):
rN, fN = model_N.fitTo(dataset1, draw=None, silent=True)
rN, fN = model_N.fitTo(dataset1, draw=None, silent=True)
rN, fN = model_N.fitTo(dataset1, draw=True, nbins=50, silent=True)
title = 'Fit to high-statistic normalisation sample'
logger.info('Fit results for normalization sample only: %s' %
rN.table(title=title, prefix='# '))
# =========================================================================
## make fit for the low-statistic signal channel only
# =========================================================================
with use_canvas('test_simfit4'):
rS, fS = model_S.fitTo(dataset2, draw=None, silent=True)
rS, fS = model_S.fitTo(dataset2, draw=None, silent=True)
rS, fS = model_S.fitTo(dataset2, draw=True, nbins=50, silent=True)
title = 'Fit to low-statistics sample'
logger.info('Fit results for low-statistic signal only:\n%s' %
rS.table(title=title, prefix='# '))
# =========================================================================
## combine data for simultaneous fit
# =========================================================================
sample = ROOT.RooCategory('sample', 'sample', 'S', 'N')
## combine datasets
from ostap.fitting.simfit import combined_data
vars = ROOT.RooArgSet(mass1, mass2)
dataset = combined_data(sample, vars, {'N': dataset1, 'S': dataset2})
## combine PDFs
model_sim = Models.SimFit(sample, {'S': model_S, 'N': model_N}, name='X')
# =========================================================================
rC, fC = model_sim.fitTo(dataset, silent=True)
rC, fC = model_sim.fitTo(dataset, silent=True)
rC, fC = model_sim.fitTo(dataset, silent=True)
rC, fC = model_sim.fitTo(dataset, silent=True)
with use_canvas('test_simfit4'):
with wait(1):
fN = model_sim.draw('N', dataset, nbins=50)
with wait(1):
fS = model_sim.draw('S', dataset, nbins=50)
title = 'Simultaneous fit'
logger.info('Combined fit results are:\n%s ' %
rC.table(title=title, prefix='#'))
def test_splot():
logger = getLogger('test_splot')
## make simple test mass
mass = ROOT.RooRealVar('test_mass', 'Some test mass', 0, 10)
tau = ROOT.RooRealVar('test_tau', 'Some test tau', 0, 10)
## book very simple data set
varset = ROOT.RooArgSet(mass, tau)
dataset = ROOT.RooDataSet(dsID(), 'Test Data set', varset)
mmin, mmax = mass.minmax()
tmin, tmax = tau.minmax()
m0 = VE(3, 0.2**2)
taus = 6
taub = 0.4
NS = 5000
NB = 5000
## generate signal
for i in range(0, NS):
m = m0.gauss()
while not mmin < m < mmax:
m = m0.gauss()
t = random.expovariate(1. / taus)
while not tmin < t < tmax:
t = random.expovariate(1. / taus)
mass.value = m
tau.value = t
dataset.add(varset)
## generate background
for i in range(0, NB):
m = random.expovariate(1. / 5)
while not mmin < m < mmax:
m = random.expovariate(1. / 3)
t = random.expovariate(1. / taub)
while not tmin < t < tmax:
t = random.expovariate(1. / taus)
mass.value = m
tau.value = t
dataset.add(varset)
logger.info("Original dataset\n%s" % dataset.table(prefix='# '))
signal = Models.Gauss_pdf('G',
xvar=mass,
mean=(3, 2, 4),
sigma=(0.2, 0.1, 0.5))
model = Models.Fit1D(signal=signal, background=1)
model.S = NS
model.B = NB
signal.mean.fix(m0.value())
signal.sigma.fix(m0.error())
model.fitTo(dataset, silent=True)
signal.mean.release()
signal.sigma.release()
model.fitTo(dataset, silent=True)
with use_canvas('test_splot'):
r, f = model.fitTo(dataset, silent=True, draw=True, nbins=50)
logger.info("Mass fit : fit results\n%s" %
r.table(title='Mass fit', prefix='# '))
## make splot analysis
model.sPlot(dataset)
logger.info("Dataset after sPlot\n%s" % dataset.table(prefix='# '))
## make signal-weighted dataset
ds_signal = dataset.makeWeighted('S_sw')
## make background-weighted dataset
ds_bkg = dataset.makeWeighted('B_sw')
logger.info("Signal-weighted dataset\n%s" % ds_signal.table(prefix='# '))
logger.info("Background-weighted dataset\n%s" % ds_bkg.table(prefix='# '))
## make exponential fits fot signal and background samples
TS = Models.Bkg_pdf('TS', xvar=tau, power=0)
TB = Models.Bkg_pdf('TB', xvar=tau, power=0)
TS.fitTo(ds_signal, silent=True)
TS.fitTo(ds_signal, silent=True)
with use_canvas('test_splot'):
rS, f = TS.fitTo(ds_signal, silent=True, draw=True, nbins=100)
logger.info("Tau/signal fit : fit results\n%s" %
rS.table(title='Tau signal fit', prefix='# '))
TB.fitTo(ds_bkg, silent=True)
TB.fitTo(ds_bkg, silent=True)
with use_canvas('test_splot'):
rB, f = TB.fitTo(ds_bkg, silent=True, draw=True, nbins=100)
logger.info("Tau/bkg fit : fit results\n%s" %
rB.table(title='Tau bkg fit', prefix='# '))
logger.info("Tau/signal : %28s vs %s" % (abs(1.0 / rS.tau_TS), taus))
logger.info("Tau/bkg : %28s vs %s" % (abs(1.0 / rB.tau_TB), taub))
from ostap.logger.logger import getLogger
if '__main__' == __name__ : logger = getLogger ( 'ostap.test_math_interpolation2' )
else : logger = getLogger ( __name__ )
# =============================================================================
# =============================================================================
## def test_fitresults () :
if 1 < 2 :
sigma = lambda x : 5 * math.exp ( x / 100.0 )
logger = getLogger ( 'test_fitresults' )
logger.info ( 'Test interpolation for fit results' )
g1 = M.Gauss_pdf ( 'G' ,
xvar = ( 0 , 100 ) ,
mean = ( 50 , 1 , 99 ) ,
sigma = ( 10 , 1 , 20 ) )
g1.mean.fix ( 50 )
results = {}
low, high, N = 0 , 100 , 8
gr = ROOT.TGraphErrors ( N + 1 )
## for i , m in enumerate ( vrange ( low , high , N ) ) :
## for i , m in enumerate ( chebyshev_abscissas ( low , high , N ) ) :
for i , m in enumerate ( lobatto_abscissas ( low , high , N ) ) :
g1.sigma.fix ( sigma ( m ) )
g1.mean.fix ( 50 )
ds = g1.generate ( 5000 )
# Prepare dataset and datahist
# Prepare a composite model
import ostap.fitting.models as Models
x = ROOT.RooRealVar("x","x",-12,12)
#
sig = Models.Gauss_pdf( 'sig', xvar=x,
mean = (0, -1, 1) ,
sigma = (1,0.001, 3.) )
#
bkg = Models.Gauss_pdf( 'bkg', xvar=x,
mean = (0, -1, 1) ,
sigma = (4,3.5, 10.) )
#
model = Models.Fit1D ( signal = sig , background = bkg , extended = False )
#
ds = sig.generate(100)
ds = ds + bkg.generate(150)
# Fit
r, w = model.fitTo( ds , draw=True, silent=True)
print(r)
w.Draw()
canvas >> "TEMP"
nll , f1 = model.draw_nll ( 'sigma_sig' , ds )
f1.Draw()
canvas >> "TEMP"
nllp , f2 = model.draw_nll ( 'sigma_sig' , ds, profile = True )
f1.Draw()
f2.Draw("same")
canvas >> "TEMP"
m_y.value = m.gauss()
dataset.add(varset)
## fill it : 5000 events const * const
for i in range(0, N_bb):
m_x.value = random.uniform(*m_x.minmax())
m_y.value = random.uniform(*m_y.minmax())
dataset.add(varset)
logger.info('Dataset:%s ' % dataset)
models = set()
# =============================================================================
signal1 = Models.Gauss_pdf('Gx', xvar=m_x)
signal2 = Models.Gauss_pdf('Gy', xvar=m_y)
signal2s = signal1.clone(name='GyS', xvar=m_y)
signal1.mean = m.value()
signal1.sigma = m.error()
signal2.mean = m.value()
signal2.sigma = m.error()
knots = std.vector('double')()
knots.push_back(m_x.xmin())
knots.push_back(0.5 * (m_x.xmin() + m_x.xmax()))
knots.push_back(m_x.xmax())
spline1 = Ostap.Math.BSpline(knots, 2)
from ostap.core.core import VE
from ostap.utils.timing import timing
from ostap.plotting.canvas import use_canvas
from ostap.utils.utils import wait
# =============================================================================
# logging
# =============================================================================
from ostap.logger.logger import getLogger
if '__main__' == __name__ or '__builtin__' == __name__:
logger = getLogger('test_fitting_constraints')
else:
logger = getLogger(__name__)
# =============================================================================
## make
x = ROOT.RooRealVar('x', 'test', 0, 10)
signal = Models.Gauss_pdf('Gauss', xvar=x, mean=(5, 2, 8), sigma=(1, 0.01, 5))
background = Models.Bkg_pdf('Bkg', xvar=x, power=1)
background.tau.fix(0)
model = Models.Fit1D(signal=signal, background=background)
model.S = 100
model.B = 1000
data = model.generate(4 * 1100)
# =============================================================================
# use some functions to parameterize efficiciency
def test_constraint():
logger = getLogger('test_constraint')
w2 = VE(6.0, 4**2)
n1 = VE(2.0, 1**2)
n2 = VE(4.0, 1**2)
for i in xrange(1000):
for w in (w1, w2, n1, n2):
v = w.gauss()
if v in mass:
mass.value = v
dataset.add(varset)
logger.info('Dataset: %s' % dataset)
## various fit components
signal_1 = Models.Gauss_pdf('G1', xvar=mass, mean=m1.value(), sigma=m1.error())
signal_2 = Models.Gauss_pdf('G2', xvar=mass, mean=m2.value(), sigma=m2.error())
signal_3 = Models.Gauss_pdf('G3', xvar=mass, mean=m3.value(), sigma=m3.error())
wide_1 = Models.Gauss_pdf('GW1', xvar=mass, mean=4.0, sigma=4)
wide_2 = Models.Gauss_pdf('GW2', xvar=mass, mean=6.0, sigma=4)
narrow_1 = Models.Gauss_pdf('GN1', xvar=mass, mean=2.0, sigma=1)
narrow_2 = Models.Gauss_pdf('GN2', xvar=mass, mean=4.0, sigma=1)
# =============================================================================
## Test extended multi-component fit'
def test_extended1():
logger.info('Test extended multi-component fit')
from ostap.logger.logger import getLogger
if '__main__' == __name__ or '__builtin__' == __name__:
logger = getLogger('test_fitting_jackknife')
else:
logger = getLogger(__name__)
# =============================================================================
from ostap.core.pyrouts import hID, VE
import ostap.fitting.models as Models
import ostap.fitting.toys as Toys
import ostap.histos.histos
from ostap.utils.timing import timing
from ostap.plotting.canvas import use_canvas
from ostap.utils.utils import wait
# =============================================================================
mass = ROOT.RooRealVar('mass', '', 0, 1)
gauss = Models.Gauss_pdf('G', xvar=mass)
gauss.mean = 0.4
gauss.sigma = 0.1
## model = Models.Fit1D ( signal = gauss )
## model.S = 100
## model.B = 100
model = gauss
# ==============================================================================
## Perform jackknife study for possible fit bias and correct uncertainty evaluation
def test_jackknife():
"""Perform toys-study for possible fit bias and correct uncertainty evaluation
- generate `nToys` pseudoexperiments with some PDF `pdf`
- fit teach experiment with the same PDF
- store fit results