def test_vars3():
logger = getLogger('test_vars3')
a = ROOT.RooRealVar('A', 'a', 0.05, 0, 1)
b = ROOT.RooRealVar('B', 'b', 0.02, -0.05, 0.1)
c = ROOT.RooRealVar('C', 'c', 0.005, 0, 0.1)
import ostap.fitting.roofuncs as R
from ostap.fitting.funbasic import Fun1D
X = Fun1D(x, xvar=x, name='X')
##F = (X**2) * c + X * b + a
F = a + b * X + c * X**2
eff2 = Efficiency1D('E5', F, cut=acc, xvar=x)
r2 = eff2.fitTo(ds)
logger.info("Fit result using-Fun1D \n%s" % r2.table(prefix="# "))
logger.info("Compare with true efficiency (using Fun1D)\n%s" %
make_table(eff2, title='using Fnu1D'))
with wait(2), use_canvas('test_vars3'):
f2 = eff2.draw(ds, nbins=25)
def test_pyvar():
## if 1 < 2 :
from ostap.fitting.pyvar import PyVAR
class MyVar(PyVAR):
def evaluate(self):
vlist = self.varlist
_x = float(vlist[0])
_a = float(vlist[1])
_b = float(vlist[2])
_c = float(vlist[3])
_x0 = float(vlist[4])
r = eff(_x, _a, _b, _c, _x0)
return r
myEff2 = MyVar('myEff2', vars=vars, title='title')
eff2 = Efficiency1D('E2', myEff2.var, cut=acc, xvar=x)
r2 = eff2.fitTo(ds)
r2 = eff2.fitTo(ds)
f2 = eff2.draw(ds, nbins=20)
print(r2)
for p in points:
print(' Point/Eff %4.1f %s%% %.2f%%' %
(p, (100 * eff2(p, error=True)).toString('(%5.2f+-%4.2f)'),
100 * eff0(p)))
def test_vars2 () :
logger = getLogger ( 'test_vars2' )
from ostap.fitting.roofuncs import MonotonicPoly as MP
f = MP ( 'G' , xvar = x , increasing = True , power = 4 )
f.pars = 0.6 , 0.8 , -0.1 , -0.6
f.a = 0.06
f.b = 2.72
f.a.release ()
f.b.release ()
eff2 = Efficiency1D ( 'E4' , f , cut = acc , xvar = x )
r2 = eff2.fitTo ( ds )
with use_canvas ( 'test_vars2' ) :
f2 = eff2.draw ( ds )
for p in points :
e = eff2 ( p , error = True )
ev = e.value()
e0 = eff0 ( p ) / emax
logger.info (' Point/Eff %4.1f %s%% (%.2f%%)' % ( p , (100*e).toString ( '(%5.2f+-%4.2f)' ) , e0 * 100 ) )
def test_vars3():
a = ROOT.RooRealVar('A', 'a', 0.05, 0, 1)
b = ROOT.RooRealVar('B', 'b', 0.02, -0.05, 0.1)
c = ROOT.RooRealVar('C', 'c', 0.005, 0, 0.1)
import ostap.fitting.roofuncs as R
from ostap.fitting.funbasic import Fun1D
X = Fun1D(x, xvar=x, name='X')
##F = (X**2) * c + X * b + a
F = a + b * X + c * X**2
eff2 = Efficiency1D('E5', F, cut=acc, xvar=x)
r2 = eff2.fitTo(ds)
f2 = eff2.draw(ds)
print(r2)
for p in points:
e = eff2(p, error=True)
ev = e.value()
e0 = eff0(p) / emax
print(' Point/Eff %4.1f %s%% (%.2f%%)' %
(p, (100 * e).toString('(%5.2f+-%4.2f)'), e0 * 100))
def test_pdf():
effPdf = Models.PolyPos_pdf('B', xvar=x, power=6)
eff2 = Efficiency1D('E2', effPdf, cut=acc)
r2 = eff2.fitTo(ds)
f2 = eff2.draw(ds)
print r2
for p in points:
print ' Point/Eff %.1f %s%%' % (p, (
100 * eff2(p, error=True)).toString('(%5.2f+-%4.2f)'))
def test_formula():
effFunc = ROOT.RooFormulaVar("effFunc", "a+0.5*b*(1+tanh((x-x0)*c))", vars)
eff1 = Efficiency1D('E1', effFunc, cut=acc, xvar=x)
r1 = eff1.fitTo(ds)
r1 = eff1.fitTo(ds)
f1 = eff1.draw(ds, nbins=20)
print(r1)
for p in points:
print(' Point/Eff %4.1f %s%% %.2f%%' %
(p, (100 * eff1(p, error=True)).toString('(%5.2f+-%4.2f)'),
100 * eff0(p)))
def test_formula():
a = ROOT.RooRealVar('a', 'a', 0.0001, 1.e-6, 0.95)
b = ROOT.RooRealVar('b', 'b', 1, 0, 2)
c = ROOT.RooRealVar('c', 'c', 1, 0.01, 10)
effFunc = ROOT.RooFormulaVar("effFunc", "(1-a)+a*cos((x-b)/c)",
ROOT.RooArgList(x, a, b, c))
eff1 = Efficiency1D('E1', effFunc, cut=acc, xvar=x)
r1 = eff1.fitTo(ds)
f1 = eff1.draw(ds)
print r1
for p in points:
print ' Point/Eff %.1f %s%%' % (p, (
100 * eff1(p, error=True)).toString('(%5.2f+-%4.2f)'))
def test_pyvar2():
from ostap.fitting.pyvar import PyVAR2
myEff3 = PyVAR2(name='myEff3', vars=vars, function=eff)
eff3 = Efficiency1D('E3', myEff3.var, cut=acc, xvar=x)
r2 = eff3.fitTo(ds)
r2 = eff3.fitTo(ds)
f2 = eff3.draw(ds, nbins=20)
print(r2)
for p in points:
print(' Point/Eff %4.1f %s%% %.2f%%' %
(p, (100 * eff3(p, error=True)).toString('(%5.2f+-%4.2f)'),
100 * eff0(p)))
def test_vars1():
from ostap.fitting.roofuncs import BernsteinPoly as BP
logger = getLogger('test_vars1')
f = BP('G', xvar=x, power=4)
f.pars = 0.2, 0.2, 0.2, 0.2
eff2 = Efficiency1D('E3', f.fun, cut=acc, xvar=x)
r2 = eff2.fitTo(ds)
logger.info("Fit result using-BernsteinPoly \n%s" % r2.table(prefix="# "))
logger.info("Compare with true efficiency (using BernsteinPoly)\n%s" %
make_table(eff2, title='using BernsteinPoly'))
with wait(2), use_canvas('test_pdf'):
f2 = eff2.draw(ds, nbins=25)
def test_vars1 () :
from ostap.fitting.roofuncs import BernsteinPoly as BP
f = BP ( 'G' , xvar = x , power = 4 )
f.pars = 0.2 , 0.2 , 0.2 , 0.2
eff2 = Efficiency1D ( 'E3' , f.fun , cut = acc , xvar = x )
r2 = eff2.fitTo ( ds )
f2 = eff2.draw ( ds )
print (r2)
for p in points :
e = eff2 ( p , error = True )
ev = e.value()
e0 = eff0 ( p ) / emax
print (' Point/Eff %4.1f %s%% (%.2f%%)' % ( p , (100*e).toString ( '(%5.2f+-%4.2f)' ) , e0 * 100 ) )
def test_pyVAR2():
"""Use PyVAR2
"""
logger = getLogger("test_pyVAR2")
from ostap.fitting.pyvar import PyVAR2
myEff3 = PyVAR2(name='myEff3', vars=vars, function=eff)
with timing("Using-PyVAR2", logger):
eff3 = Efficiency1D('E3', myEff3.var, cut=acc, xvar=x)
a.fix(A)
b.fix(B)
c.value = C
x0.value = X0
r3 = eff3.fitTo(ds, silent=True)
a.release()
b.release()
c.fix()
x0.fix()
r3 = eff3.fitTo(ds, silent=True)
c.release()
x0.release()
r3 = eff3.fitTo(ds, silent=True)
logger.info("Fit result using-PyVAR2 \n%s" % r3.table(prefix="# "))
logger.info("Compare with true efficiency (using PyVAR2)\n%s" %
make_table(eff3, title='using PyVAR2'))
with use_canvas("test_pyVAR2"):
eff3.draw(ds)
time.sleep(2)
def test_formula():
"""Use RooFormulaVar to parameterise efficiency:
"""
logger = getLogger("test_formula")
## create RooFormularVar
effFunc = ROOT.RooFormulaVar("effFunc", "a+0.5*b*(1+tanh((x-x0)*c))", vars)
with timing("Using-RooFormularVar", logger):
eff1 = Efficiency1D('E1', effFunc, cut=acc, xvar=x)
a.fix(A)
b.fix(B)
c.value = C
x0.value = X0
r1 = eff1.fitTo(ds, silent=True)
a.release()
b.release()
c.fix()
x0.fix()
r1 = eff1.fitTo(ds, silent=True)
c.release()
x0.release()
r1 = eff1.fitTo(ds, silent=True)
logger.info("Fit result using-RooFormularVar \n%s" %
r1.table(prefix="# "))
logger.info("Compare with true efficiency (using RooFormulaVar)\n%s" %
make_table(eff1, title='using RooFormulaVer'))
with use_canvas("test_formula"):
eff1.draw(ds)
time.sleep(2)
def test_pdf () :
effPdf = Models.Monotonic_pdf ( 'P6' , xvar = x , power = 3 , increasing = True )
maxe = margin * effPdf ( xmax )
s0 = min ( 1.0 / emax , 1.0 / maxe )
scale = ROOT.RooRealVar ( 'scaleX' , 'scaleX' , s0 , 0.2 * s0 , 5.0 * s0 )
eff2 = Efficiency1D ( 'E2' , effPdf , cut = acc , scale = scale )
r2 = eff2.fitTo ( ds )
f2 = eff2.draw ( ds )
print (r2)
for p in points :
e = eff2 ( p , error = True )
ev = e.value()
e0 = eff0 ( p ) / emax
print (' Point/Eff %4.1f %s%% (%.2f%%)' % ( p , (100*e).toString ( '(%5.2f+-%4.2f)' ) , e0 * 100 ) )
def test_pdf():
logger = getLogger('test_pdf')
effPdf = Models.Monotonic_pdf('P6', xvar=x, power=4, increasing=True)
maxe = margin * effPdf(xmax)
s0 = min(1.0 / emax, 1.0 / maxe)
scale = ROOT.RooRealVar('scaleX', 'scaleX', s0, 0.2 * s0, 5.0 * s0)
eff2 = Efficiency1D('E2', effPdf, cut=acc, scale=scale)
r2 = eff2.fitTo(ds)
logger.info("Fit result using-Monotonic_pdf \n%s" % r2.table(prefix="# "))
logger.info("Compare with true efficiency (using Monotonic_pdf)\n%s" %
make_table(eff2, title='using Monotonic_pdf'))
with wait(2), use_canvas('test_pdf'):
f2 = eff2.draw(ds, nbins=25)
def test_vars2():
logger = getLogger('test_vars2')
from ostap.fitting.roofuncs import MonotonicPoly as MP
f = MP('G', xvar=x, increasing=True, power=4)
f.pars = 0.6, 0.8, -0.1, -0.6
f.a = 0.06
f.b = 2.72
f.a.release()
f.b.release()
eff2 = Efficiency1D('E4', f, cut=acc, xvar=x)
r2 = eff2.fitTo(ds)
logger.info("Fit result using-MonotonicPoly \n%s" % r2.table(prefix="# "))
logger.info("Compare with true efficiency (using MonotonicPoly)\n%s" %
make_table(eff2, title='using MonotonicPoly'))
with wait(2), use_canvas('test_pdf'):
f2 = eff2.draw(ds, nbins=25)
def test_pyVar():
"""use PyVar stuff
- For *NEW* PyROOT only!
"""
logger = getLogger("test_pyVar")
if old_PyROOT:
logger.warning("test is enabled only for *NEW* PyROOT!")
return
# =========================================================================
## @class MyEff4
# Local ``pythonic'' variable
class MyEff4(Ostap.Functions.PyVar):
def __init__(self, name, title, variables):
vlist = ROOT.RooArgList()
for v in variables:
vlist.add(v)
super(MyEff4, self).__init__(name, title, vlist)
def clone(self, newname):
name = newname if newname else self.name
nv = MyEff4(name, self.title, self.variables())
ROOT.SetOwnership(nv, False)
return nv
def evaluate(self):
vlist = self.variables()
_x = float(vlist[0])
_a = float(vlist[1])
_b = float(vlist[2])
_c = float(vlist[3])
_x0 = float(vlist[4])
return eff(_x, _a, _b, _c, _x0)
myEff4 = MyEff4('myEff4', variables=vars, title='title')
the_fun = myEff4
with timing("Using-PyVar", logger):
eff4 = Efficiency1D('E4', the_fun, cut=acc, xvar=x)
a.fix(A)
b.fix(B)
c.value = C
x0.value = X0
r4 = eff4.fitTo(ds, silent=True)
a.release()
b.release()
c.fix()
x0.fix()
r4 = eff4.fitTo(ds, silent=True)
c.release()
x0.release()
r4 = eff4.fitTo(ds, silent=True)
logger.info("Fit result using-PyVar \n%s" % r4.table(prefix="# "))
logger.info("Compare with true efficiency (using PyVar)\n%s" %
make_table(eff4, title='using PyVar'))
time.sleep(2)
def test_pyVAR():
"""Yse PyVAR stuff
- For *old* PyROOT only!
"""
logger = getLogger("test_pyVAR")
if not old_PyROOT:
logger.warning("test is enabled only for *OLD* PyROOT!")
return
from ostap.fitting.pyvar import PyVAR
# =========================================================================
## @class MyEff2
# Local "pythonic" variable
# @see PyVAR
class MyEff2(PyVAR):
"""Local ``pythonic'' variable
"""
def evaluate(self):
vlist = self.varlist
_x = float(vlist[0])
_a = float(vlist[1])
_b = float(vlist[2])
_c = float(vlist[3])
_x0 = float(vlist[4])
return eff(_x, _a, _b, _c, _x0)
myEff2 = MyEff2('myEff2', vars=vars, title='title')
the_fun = myEff2.var
with timing("Using-PyVAR", logger):
eff2 = Efficiency1D('E2', the_fun, cut=acc, xvar=x)
a.fix(A)
b.fix(B)
c.value = C
x0.value = X0
r2 = eff2.fitTo(ds, silent=True)
a.release()
b.release()
c.fix()
x0.fix()
r2 = eff2.fitTo(ds, silent=True)
c.release()
x0.release()
r2 = eff2.fitTo(ds, silent=True)
logger.info("Fit result using-PyVAR \n%s" % r2.table(prefix="# "))
logger.info("Compare with true efficiency (using PyVAR)\n%s" %
make_table(eff2, title='using PyVAR'))
time.sleep(2)
