logger = getLogger(__name__)
# =============================================================================
## make simple test mass
mass = ROOT.RooRealVar('test_mass', 'Some test mass', -3, 3)
## book very simple data set
varset0 = ROOT.RooArgSet(mass)
dataset0 = ROOT.RooDataSet(dsID(), 'Test Data set-0', varset0)
mmin = mass.getMin()
mmax = mass.getMax()
## fill it
m1 = VE(0, 0.1**2)
for i in range(0, 20000):
mass.setVal(m1.gauss())
dataset0.add(varset0)
m2 = VE(0, 0.2**2)
for i in range(0, 10000):
mass.setVal(m2.gauss())
dataset0.add(varset0)
logger.info('DATASET %s' % dataset0)
models = set()
# =============================================================================
## Single gauss
# =============================================================================
## book very simple data set
varset = ROOT.RooArgSet(m_x, m_y)
dataset = ROOT.RooDataSet(dsID(), 'Test Data set-1', varset)
m = VE(3.100, 0.015**2)
N_ss = 5000
N_sb = 500
N_bs = 500
N_bb = 1000
random.seed(0)
## fill it : 5000 events Gauss * Gauss
for i in range(0, N_ss):
m_x.value = m.gauss()
m_y.value = m.gauss()
dataset.add(varset)
## fill it : 2500 events Gauss * const
for i in range(0, N_sb):
m_x.value = m.gauss()
m_y.value = random.uniform(*m_y.minmax())
dataset.add(varset)
## fill it : 2500 events const * Gauss
for i in range(0, N_bs):
m_x.value = random.uniform(*m_x.minmax())
m_y.value = m.gauss()
dataset.add(varset)
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))
else :
logger = getLogger ( __name__ )
# =============================================================================
## make simple test mass
mass = ROOT.RooRealVar ( 'test_mass' , 'Some test mass' , 3.0 , 3.2 )
## book very simple data set
varset0 = ROOT.RooArgSet ( mass )
dataset = ROOT.RooDataSet ( dsID() , 'Test Data set-0' , varset0 )
mmin , mmax = mass.minmax()
## fill it
m = VE(3.100,0.015**2)
for i in range(0,1000) :
mass.value = m.gauss ()
dataset.add ( varset0 )
for i in range(0,100) :
mass.value = random.uniform ( *mass.minmax() )
dataset.add ( varset0 )
logger.info ('DATASET\n%s' % dataset )
NORM = 1.0 / math.sqrt ( 2.0 * math.pi )
CDF = Ostap.Math.gauss_cdf
from ostap.fitting.models import Gauss_pdf
pdf = Gauss_pdf( "G" ,
xvar = mass ,
mean = ( 3.080 , 3.05 , 3.15 ) ,
sigma = ( 0.010 , 0.005 , 0.020 ) )
logger = getLogger(__name__)
# =============================================================================
## make simple test mass
mass = ROOT.RooRealVar('test_mass', 'Some test mass', 3.0, 3.2)
## book very simple data set
varset0 = ROOT.RooArgSet(mass)
dataset0 = ROOT.RooDataSet(dsID(), 'Test Data set-0', varset0)
mmin = mass.getMin()
mmax = mass.getMax()
## fill it
m = VE(3.100, 0.015**2)
for i in xrange(0, 5000):
mass.setVal(m.gauss())
dataset0.add(varset0)
for i in xrange(0, 500):
mass.setVal(random.uniform(mass.getMin(), mass.getMax()))
dataset0.add(varset0)
logger.info('DATASET %s' % dataset0)
models = set()
## signal component
signal_gauss = Models.Gauss_pdf(
name='Gauss', ## the name
mass=mass, ## the variable
mean=m.value(), ## mean value (fixed)
def test_minuit_weighted () :
logger = getLogger ( "test_minuit_weighted" )
## make simple test variable
xvar = ROOT.RooRealVar ( 'test_x' , 'Some test x' , 0 , 10 )
yvar = ROOT.RooRealVar ( 'test_y' , 'Some test y' , 0 , 1 )
## book very simple data set
varset = ROOT.RooArgSet ( xvar , yvar )
dataset = ROOT.RooDataSet ( dsID() , 'Test Data set-0' , varset )
NS = 10000
NB = 10000
xmin , xmax = xvar.minmax()
ymin , ymax = yvar.minmax()
## fill it
x = VE(5.0,1**2)
for i in range(0,NS) :
xvar.value = x.gauss ()
y = -1
while not ymin <= y <= ymax : y = random.expovariate ( 1/0.1 )
yvar.value = y
dataset.add ( varset )
for i in range(0,NB) :
xvar.value = random.uniform ( xmin , xmax )
y = -1
while not ymin <= y <= ymax : y = random.expovariate ( 1/0.9 )
yvar.value = y
dataset.add ( varset )
logger.info ('DATASET\n%s' % dataset )
signal = Models.Gauss_pdf ('G' , xvar = xvar , mean = ( 4, 6 ) , sigma = ( 0.5 , 1.5 ) )
model = Models.Fit1D ( signal = signal , background = 0 )
model.S = NS
model.B = NB
with use_canvas ( "test_minuit_weighted" ) , wait ( 2 ) :
r0 , _ = model.fitTo ( dataset , silent = True , draw = False )
r0 , f0 = model.fitTo ( dataset , silent = True , draw = True , nbins = 100 )
logger.info ('Fit result\n%s' % r0.table () )
## make splot
model.sPlot ( dataset )
dsw = dataset.makeWeighted ( "S_sw" )
logger.info ('Weighted DATASET\n%s' % dsw )
## fitting function for the exponential stuff
expf = Models.Bkg_pdf ( 'E' , xvar = yvar , power = 0 )
# ==============================================================================
## ROOT/RooFit "feature" @see https://sft.its.cern.ch/jira/browse/ROOT-10668
if (6,19) <= root_info < (6,20,6) :
expf.tau.SetTitle ( expf.tau.GetName() )
rw , fw = expf.fitTo ( dsw , silent = True , draw = False )
rw , fw = expf.fitTo ( dsw , silent = True , draw = True , nbins = 50 )
logger.info ('Weighted fit result (incorrect)\n%s' % rw.table ( title = 'incorrect') )
r2 , f2 = expf.fitTo ( dsw , silent = True , sumw2 = True , draw = False )
r2 , f2 = expf.fitTo ( dsw , silent = True , sumw2 = True , draw = True , nbins = 50 )
r2.Print('vvv')
logger.info ('Weighted fit result (SumW2=True)\n%s' % r2.table ( 'SumW2=True') )
if (6,19) <= root_info :
with use_canvas ( "test_minuit_weighted" ) , wait ( 2 ) :
ra , fa = expf.fitTo ( dsw , asymptotic = True , draw = False , silent = True )
ra , fa = expf.fitTo ( dsw , asymptotic = True , draw = True , silent = True , nbins = 50 )
logger.info ('Weighted fit result (asymptotic=True)\n%s' % ra.table ( 'Asymptotic=True') )
m = expf.minuit ( dataset = dsw , scale = False , silent = True )
m.migrad ( 5 )
rm = m.save()
logger.info ('MiNUIT fit result (incorrect) \n%s' % rm.table ( title = 'incorrect') )
ms = expf.minuit ( dataset = dsw , scale = True , silent = True )
ms.migrad ( 5 )
rs = ms.save()
logger.info ('MiNUIT (scale=True) fit result\n%s' % rs.table ( title = 'scaled') )
def test_components_2 () :
## make simple test mass
mass = ROOT.RooRealVar ( 'test_mass' , 'Some test mass' , 0 , 10 )
## book very simple data set
varset = ROOT.RooArgSet ( mass )
dataset = ROOT.RooDataSet ( dsID() , 'Test Data set' , varset )
mmin, mmax = mass.minmax()
## two gaussinan signal cmppnent
N1 = 5000
m1 = VE(5,0.2**2)
N2 = 5000
m2 = VE(3,0.3**2)
## background exponential components
taub = 5.0
NB = 5000
## generate 1st signal
for i in range(0,N1) :
m = m1.gauss ()
while not mmin < m < mmax : m = m1.gauss()
mass.value = m
dataset.add ( varset )
## generate 2nd signal
for i in range(0,N2) :
m = m2.gauss ()
while not mmin < m < mmax : m = m2.gauss()
mass.value = m
dataset.add ( varset )
## generate background
for i in range ( 0,NB) :
m = random.expovariate ( 1./ taub )
while not mmin < m < mmax : m = random.expovariate ( 1./ taub )
mass.value = m
dataset.add ( varset )
logger.info ( "Original dataset\n%s" % dataset.table ( prefix = '# ' ) )
signal1 = Models.Gauss_pdf ( 'G1' , xvar = mass , mean = ( 5 , 4, 6 ) , sigma = ( 0.2 , 0.1 , 0.3 ) )
signal2 = Models.Gauss_pdf ( 'G2' , xvar = mass , mean = ( 3 , 2, 4 ) , sigma = ( 0.3 , 0.2 , 0.4 ) )
S1 = ROOT.RooRealVar ( 'S1' , '1st signal yeild' , N1 , 1 , 10000 )
ratio = ROOT.RooRealVar ( 'R' , 'ratio of S2 to S1' , 1.0*N2 / N1 , 0.05 , 100 )
S2 = signal1.vars_multiply ( S1 , ratio , name = 'S2' , title = '2ns signal yield' )
model = Models.Fit1D( signals = [ signal1 , signal2 ] , background = 1 , S = ( S1 , S2 ) )
model.B = NB
signal1.mean .fix ( m1.value () )
signal1.sigma.fix ( m1.error () )
signal2.mean .fix ( m2.value () )
signal2.sigma.fix ( m2.error () )
model.fitTo ( dataset , silent = True )
signal1.mean .release()
signal1.sigma.release()
signal2.mean .release()
signal2.sigma.release()
model.fitTo ( dataset , silent = True )
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 = '# ' ) )
r , f = model.fitTo ( dataset , silent = True , draw = True , nbins = 50 , minos = ('R','S1') )
logger.info ( "Mass fit : fit results\n%s" % r.table ( title = 'Mass fit' , prefix = '# ' ) )
## book very simple data set
varset = ROOT.RooArgSet(m_x, m_y)
dataset = ROOT.RooDataSet(dsID(), 'Test Data set-1', varset)
m = VE(3.100, 0.015**2)
N_ss = 5000
N_sb = 2500
N_bs = 2500
N_bb = 5000
random.seed(0)
## fill it : 5000 events Gauss * Gauss
for i in xrange(0, N_ss):
m_x.setVal(m.gauss())
m_y.setVal(m.gauss())
dataset.add(varset)
## fill it : 2500 events Gauss * const
for i in xrange(0, N_sb):
m_x.setVal(m.gauss())
m_y.setVal(random.uniform(m_y.getMin(), m_y.getMax()))
dataset.add(varset)
## fill it : 2500 events const * Gauss
for i in xrange(0, N_bs):
m_x.setVal(random.uniform(m_x.getMin(), m_x.getMax()))
m_y.setVal(m.gauss())
dataset.add(varset)
def test_fitting_in_range_2d():
logger = getLogger('test_fitting_in_range_2d')
## make simple test mass
m_x = ROOT.RooRealVar('m_x', 'Some test mass(X)', 0, 5)
m_y = ROOT.RooRealVar('m_y', 'Some test mass(Y)', 6, 10)
## book very simple data set
varset = ROOT.RooArgSet(m_x, m_y)
dataset = ROOT.RooDataSet(dsID(), 'Test Data set-1', varset)
m1 = VE(3, 0.10**2)
m2 = VE(7, 0.10**2)
## fill it with three gausissians, 5k events each
N_ss = 5000
N_sb = 1000
N_bs = 500
N_bb = 100
random.seed(0)
## S x S
for i in range(N_ss):
m_x.value = m1.gauss()
m_y.value = m2.gauss()
dataset.add(varset)
## S x B
for i in range(N_sb):
m_x.value = m1.gauss()
m_y.value = random.uniform(*m_y.minmax())
dataset.add(varset)
## B x S
for i in range(N_bs):
m_x.value = random.uniform(*m_x.minmax())
m_y.value = m2.gauss()
dataset.add(varset)
## B x B
for i in range(N_bb):
m_x.value = random.uniform(*m_x.minmax())
m_y.value = random.uniform(*m_y.minmax())
dataset.add(varset)
logger.info('Dataset:\n%s' % dataset.table(prefix='# '))
## various fit components
signal_x1 = Models.Gauss_pdf('G1x',
xvar=m_x,
mean=m1.value(),
sigma=m1.error())
signal_y1 = Models.Gauss_pdf(name='G1y',
xvar=m_y,
mean=m2.value(),
sigma=m2.error())
bkg_x = make_bkg(-1, 'Bx', m_x)
bkg_y = make_bkg(-1, name='By', xvar=m_y)
## build fit model
model = Models.Fit2D(name='fit_comp',
signal_x=signal_x1,
signal_y=signal_y1,
bkg_1x=bkg_x,
bkg_1y=bkg_y)
model.SS = N_ss
model.SB = N_sb
model.BS = N_bs
model.BB = N_bb
r = model.fitTo(dataset, silent=True)
r = model.fitTo(dataset, silent=True)
dataset.m_y.setRange('fit', 8, 10.)
model.yvar.setRange('fit', 8, 10.)
with use_canvas('test_fitting_in_range_2d'):
with wait(2):
model.draw1(dataset, nbins=200, in_range=(6, 8))
with wait(2):
model.draw1(dataset, nbins=200, in_range='fit')
dataset.m_x.setRange('fit2', 0, 2.5)
model.xvar.setRange('fit2', 0, 2.5)
with use_canvas('test_fitting_in_range_2d'):
with wait(2):
model.draw2(dataset, nbins=200, in_range=(2.5, 5))
with wait(2):
model.draw2(dataset, nbins=200, in_range='fit2')
## fill it with three gausissians, 5k events each
N_sss = 5000
N_ssb = 5000
N_sbs = 5000
N_sbb = 1000
N_bss = 500
N_bsb = 100
N_bbs = 100
N_bbb = 250
random.seed(0)
## fill it : 5000 events Gauss * Gauss *Gauss
for i in range(0, N_sss):
m_x.value = m1.gauss()
m_y.value = m2.gauss()
m_z.value = m3.gauss()
dataset.add(varset)
## fill it : 500 events Gauss * const * Gauss
for i in range(0, N_ssb):
m_x.value = m1.gauss()
m_y.value = random.uniform(*m_y.minmax())
m_z.value = m3.gauss()
dataset.add(varset)
## fill it : 500 events const * Gauss * Gauss
for i in range(0, N_sbs):
m_x.value = random.uniform(*m_x.minmax())
def test_fitting_in_range_3d():
logger = getLogger('test_fitting_in_range_3d')
## make simple test mass
m_x = ROOT.RooRealVar('m_x', 'Some test mass(X)', 0, 5)
m_y = ROOT.RooRealVar('m_y', 'Some test mass(Y)', 6, 10)
m_z = ROOT.RooRealVar('m_z', 'Some test mass(z)', 10, 15)
## 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.10**2)
m3 = VE(12, 0.10**2)
N_sss = 5000
N_ssb = 5000
N_sbs = 5000
N_sbb = 1000
N_bss = 500
N_bsb = 100
N_bbs = 100
N_bbb = 250
random.seed(0)
## S x S x S
for i in range(N_sss):
m_x.value = m1.gauss()
m_y.value = m2.gauss()
m_z.value = m3.gauss()
dataset.add(varset)
## S x S x B
for i in range(N_ssb):
m_x.value = m1.gauss()
m_y.value = m2.gauss()
m_z.value = random.uniform(*m_z.minmax())
dataset.add(varset)
## S x B x S
for i in range(N_sbs):
m_x.value = m1.gauss()
m_y.value = random.uniform(*m_y.minmax())
m_z.value = m3.gauss()
dataset.add(varset)
## B x S x S
for i in range(N_bss):
m_x.value = random.uniform(*m_x.minmax())
m_y.value = m2.gauss()
m_z.value = m3.gauss()
dataset.add(varset)
## S x B x B
for i in range(N_sbb):
m_x.value = m1.gauss()
m_y.value = random.uniform(*m_y.minmax())
m_z.value = random.uniform(*m_z.minmax())
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 = m2.gauss()
m_z.value = random.uniform(*m_z.minmax())
dataset.add(varset)
## B x B x S
for i in range(N_bbs):
m_x.value = random.uniform(*m_x.minmax())
m_y.value = random.uniform(*m_y.minmax())
m_z.value = m3.gauss()
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_z.minmax())
dataset.add(varset)
logger.info('Dataset:\n%s' % dataset.table(prefix='# '))
signal_x1 = Models.Gauss_pdf('G1x',
xvar=m_x,
mean=m1.value(),
sigma=m1.error())
signal_y1 = Models.Gauss_pdf(name='G1y',
xvar=m_y,
mean=m2.value(),
sigma=m2.error())
signal_z1 = Models.Gauss_pdf(name='G1z',
xvar=m_z,
mean=m3.value(),
sigma=m3.error())
bkg_x = make_bkg(-1, 'Bx', m_x)
bkg_y = make_bkg(-1, name='By', xvar=m_y)
bkg_z = make_bkg(-1, name='Bz', xvar=m_z)
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,
)
model.SSS = N_sss
model.SSB = N_ssb
model.SBS = N_sbs
model.BSS = N_bss
model.SBB = N_sbb
model.BSB = N_bsb
model.BBS = N_bbs
model.BBB = N_bbb
r = model.fitTo(dataset, silent=True)
r = model.fitTo(dataset, silent=True)
dataset.m_y.setRange('fit', 6, 8.)
model.yvar.setRange('fit', 6, 8.)
t = 1.0
with use_canvas('test_fitting_in_range_3d'):
with wait(t):
model.draw1(dataset,
nbins=200,
in_range3=(11, 12),
in_range2=(8, 10))
with wait(t):
model.draw1(dataset,
nbins=200,
in_range3=(11, 12),
in_range2='fit')
with wait(t):
model.draw1(dataset, nbins=200, in_range3=(11, 12))
with wait(t):
model.draw1(dataset, nbins=200, in_range2='fit')
dataset.m_x.setRange('fit2', 2.5, 3.)
model.xvar.setRange('fit2', 2.5, 3.)
with use_canvas('test_fitting_in_range_3d'):
with wait(t):
model.draw2(dataset,
nbins=200,
in_range3=(11, 12),
in_range1=(0, 3))
with wait(t):
model.draw2(dataset,
nbins=200,
in_range3=(11, 12),
in_range1='fit2')
with wait(t):
model.draw2(dataset, nbins=200, in_range3=(11, 12))
with wait(t):
model.draw2(dataset, nbins=200, in_range1='fit2')
dataset.m_x.setRange('fit3', 2.5, 3.)
model.xvar.setRange('fit3', 2.5, 3.)
with use_canvas('test_fitting_in_range_3d'):
with wait(t):
model.draw3(dataset, nbins=200, in_range2=(6, 8), in_range1=(0, 3))
with wait(t):
model.draw3(dataset, nbins=200, in_range2=(6, 8), in_range1='fit3')
with wait(t):
model.draw3(dataset, nbins=200, in_range2=(6, 8))
with wait(t):
model.draw3(dataset, nbins=200, in_range1='fit3')
