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)
logger.info(80 * '*')
logger.info('Run info for #run=%d ' % 169064)
logger.info(80 * '*')
rinfo = run_info(169064)
for k in rinfo:
logger.info(" %30s : %-35s " % (k, rinfo[k]))
logger.info(80 * '*')
logger.info('Fill info for #fill=%d ' % 4691)
logger.info(80 * '*')
finfo = fill_info(4691)
for k in finfo:
logger.info(" %30s : %-35s " % (k, finfo[k]))
logger.info(80 * '*')
from ostap.utils.utils import timing
runs = [0, 1, 169064, 5, 6, 98241980, 169064, 2334, 2334, 524387]
for run in runs:
with timing():
fill = fill_number(run)
logger.info('Run/Fill#:%12d/%-10d ' % (run, fill))
logger.info(80 * '*')
# =============================================================================
# The END
# =============================================================================
def test_PyPDF() :
"""Test pure python PDF: pyPDF
- For *OLD* PyROOT only!
- see Ostap.Models.PyPdf
"""
logger = getLogger("test_PyPDF")
if not old_PyROOT :
logger.warning("test enabled only for OLD PyROOT!")
return
logger.info ("Test pure python PDF: PyPDF ")
from ostap.fitting.pypdf import PyPDF
# =============================================================================
## @class PyGauss
# local ``pure-python'' PDF
class PyGauss(MASS,PyPDF) :
"""Local ``pure-python'' PDF
"""
def __init__ ( self ,
name ,
xvar ,
mean = ( 3.080 , 3.05 , 3.15 ) ,
sigma = ( 0.010 , 0.005 , 0.020 ) ,
pypdf = None ) :
MASS .__init__ ( self , name , xvar , mean , sigma )
PyPDF.__init__ ( self , self.name , ( self.xvar ,
self.mean ,
self.sigma ) , pypdf = pypdf )
self.pdf = self.pypdf
self.config = {
'name' : self.name ,
'xvar' : self.xvar ,
'mean' : self.mean ,
'sigma' : self.sigma ,
'pypdf' : None ## attention!
}
## the main method
def evaluate ( self ) :
vlist = self.varlist
x = self.variable ( 0 )
m = self.variable ( 1 )
s = self.variable ( 2 )
dx = ( x - m ) / s
return math.exp ( -0.5 * dx * dx ) * NORM / s
with timing ("Using-PyPDF", logger ) :
pdf.mean = random.gauss ( 3.100 , 0.010 )
pdf.sigma = random.gauss ( 0.012 , 0.001 )
## create PDF
gauss = PyGauss( 'PyGauss' , xvar = mass ,
mean = pdf.mean , sigma = pdf.sigma )
## build fit model
model = Fit1D ( signal = gauss , background = None , name = 'M0' )
## fit!
r, _ = model .fitTo ( dataset , draw = False , silent = True , ncpu=1 )
with wait ( 1 ) , use_canvas ( "test_PyPDF" ) :
r, f = model .fitTo ( dataset , draw = True , silent = True , ncpu=1 )
logger.info ("Fit result for``pure python'' PDF: PyPDF \n%s" % r.table ( prefix = "# " ) )
def test_PyPdf_AI() :
"""Test pure python PDF: pyPDF
- For *NEW* PyROOT only!
- see Ostap.Models.PyPdf
"""
logger = getLogger("test_PyPdf_AI")
if old_PyROOT :
logger.warning("test enabled only for NEW PyROOT!")
return
logger.info ("Test pure python PDF: PyPdf with analytical integral")
# =============================================================================
## @class PyGauss
# local ``pure-python'' PDF
class MyGauss(Ostap.Models.PyPdf) :
"""Local ``pure-python'' PDF
"""
def __init__ ( self , name , xvar , mean , sigma ) :
vars = ROOT.RooArgList()
vars.add ( xvar )
vars.add ( mean )
vars.add ( sigma )
super(MyGauss,self).__init__ ( name , 'title' , vars )
## the main method
def evaluate ( self ) :
x = self.variable ( 0 )
m = self.variable ( 1 )
s = self.variable ( 2 )
dx = ( x - m ) / s
return math.exp ( -0.5 * dx * dx ) * NORM / s
def clone ( self , newname ) :
name = newname if newname else self.name
vlist = self.variables()
xvar = vlist[0]
mean = vlist[1]
sigma = vlist[2]
cl = MyGauss( name , xvar , mean , sigma )
ROOT.SetOwnership ( cl , False )
return cl
## declare analytical integral
def get_analytical_integral ( self ) :
"""Declare the analytical integral"""
x = self.variables()[0]
if self.matchArgs ( x ) : return 1 ## get the integration code
return 0
## calculate the analytical integral
def analytical_integral ( self ) :
"""Calculate the analytical integral"""
assert 1 == self.intCode () , 'Invalid integration code!'
vlist = self.variables()
rn = self.rangeName()
xv = vlist [ 0 ]
xmax = xv.getMax ( rn )
xmin = xv.getMin ( rn )
m = float ( vlist [ 1 ] )
s = float ( vlist [ 2 ] )
return CDF ( xmax , m , s ) - CDF ( xmin , m , s )
with timing ("Using-PyPdf+AI", logger ) :
pdf.mean = random.gauss ( 3.100 , 0.010 )
pdf.sigma = random.gauss ( 0.012 , 0.001 )
pdf_ = MyGauss ( 'MyGauss' , pdf.xvar , pdf.mean , pdf.sigma )
gauss = Generic1D_pdf ( pdf_ , xvar = pdf.xvar )
## build fit model
model = Fit1D ( signal = gauss , background = None , name = 'M3' )
## fit!
r, _ = model .fitTo ( dataset , draw = False , silent = True , ncpu=1 )
with wait ( 1 ) , use_canvas ( "test_PyPdf_AI" ) :
r, f = model .fitTo ( dataset , draw = True , silent = True , ncpu=1 )
logger.info ("Fit result for``pure python'' PDF: PyPdf with analytical integral\n%s" % r.table ( prefix = "# " ) )
def test_PyPdf() :
"""Test pure python PDF: pyPDF
- For *NEW* PyROOT only!
- see Ostap.Models.PyPdf
"""
logger = getLogger("test_PyPdf")
if old_PyROOT :
logger.warning("test enabled only for NEW PyROOT!")
return
logger.info ("Test pure python PDF: PyPdf ")
# =============================================================================
## @class PyGauss
# local ``pure-python'' PDF
class MyGauss(Ostap.Models.PyPdf) :
"""Local ``pure-python'' PDF
"""
def __init__ ( self , name , xvar , mean , sigma ) :
vars = ROOT.RooArgList()
vars.add ( xvar )
vars.add ( mean )
vars.add ( sigma )
super(MyGauss,self).__init__ ( name , 'title' , vars )
## the main method
def evaluate ( self ) :
vlist = self.varlist
x = self.variable ( 0 )
m = self.variable ( 1 )
s = self.variable ( 2 )
dx = ( x - m ) / s
return math.exp ( -0.5 * dx * dx ) * NORM / s
def clone ( self , newname ) :
name = newname if newname else self.name
vlist = self.variables()
xvar = vlist[0]
mean = vlist[1]
sigma = vlist[2]
cl = MyGauss( name , xvar , mean , sigma )
ROOT.SetOwnership ( cl , False )
return cl
with timing ("Using-PyPdf", logger ) :
pdf.mean = random.gauss ( 3.100 , 0.010 )
pdf.sigma = random.gauss ( 0.012 , 0.001 )
pdf_ = MyGauss ( 'MyGauss' , pdf.xvar , pdf.mean , pdf.sigma )
gauss = Generic1D_pdf ( pdf_ , xvar = pdf.xvar )
## build fit model
model = Fit1D ( signal = gauss , background = None , name = 'M3' )
## fit!
r, _ = model .fitTo ( dataset , draw = False , silent = True , ncpu=1 )
with wait ( 1 ) , use_canvas ( "test_PyPdf" ) :
r, f = model .fitTo ( dataset , draw = True , silent = True , ncpu=1 )
logger.info ("Fit result for``pure python'' PDF: PyPdf \n%s" % r.table ( prefix = "# " ) )
def test_PyPDF2 () :
"""Test pure python PDF: PyPDF2
- see Ostap.Models.PyPdf2
"""
logger = getLogger("test_PyPDF2")
logger.info ("Test pure python PDF: PyPDF2 with python function")
from ostap.fitting.pypdf import PyPDF2
# =============================================================================
## @class PyGauss2
# local ``pure-python'' PDF
class PyGauss2(MASS,PyPDF2) :
"""Local ``pure-python'' PDF """
def __init__ ( self ,
name ,
function ,
xvar ,
mean = ( 3.080 , 3.05 , 3.15 ) ,
sigma = ( 0.010 , 0.005 , 0.020 ) ,
title = ''
) :
MASS .__init__ ( self , name , xvar , mean , sigma )
PyPDF2.__init__ ( self ,
name = self.name ,
function = function ,
vars = ( self.xvar , self.mean , self.sigma ) )
self.config = {
'name' : self.name ,
'function' : self.function ,
'xvar' : self.xvar ,
'mean' : self.mean ,
'sigma' : self.sigma ,
}
## the function
def function ( x , m , s ) :
dx = ( x - m ) / s
return math.exp ( -0.5 * dx * dx ) * NORM / s
with timing ("Using-PyPDF2", logger ) :
pdf.mean = random.gauss ( 3.100 , 0.010 )
pdf.sigma = random.gauss ( 0.012 , 0.001 )
## construct PDF
gauss = PyGauss2 ( name ='G2' , function = function ,
xvar = mass , mean = pdf.mean , sigma = pdf.sigma )
## model
model = Fit1D ( signal = gauss , background = 'p0' , name = 'M2' )
## fit!
r, _ = model .fitTo ( dataset , draw = False , silent = True , ncpu=1 )
with wait ( 1 ) , use_canvas ( "test_PyPDF2" ) :
r, f = model .fitTo ( dataset , draw = True , silent = True , ncpu=1 )
logger.info ("Fit result for``pure python'' PDF: PyPDF2 with python function \n%s" % r.table ( prefix = "# " ) )
def test_PyPDF_AI() :
"""Test pure python PDF: PyPDF with analytical integral
- For *OLD* PyROOT only!
- see Ostap.Models.PyPdf
"""
logger = getLogger("test_PyPDF_AI")
if not old_PyROOT :
logger.warning("test enabled only for OLD PyROOT!")
return
logger.info ("Test pure python PDF: PyPDF with analytical integral")
from ostap.fitting.pypdf import PyPDF
# =========================================================================
## @class PyGaussAI
# local ``pure-python'' PDF with analytical integrals
class PyGaussAI(MASS,PyPDF) :
"""Local ``pure-python'' PDF with analytical integrals """
def __init__ ( self ,
name ,
xvar ,
mean = ( 3.080 , 3.05 , 3.15 ) ,
sigma = ( 0.010 , 0.005 , 0.020 ) ,
pypdf = None ) :
MASS .__init__ ( self , name , xvar , mean , sigma )
PyPDF.__init__ ( self , self.name , ( self.xvar ,
self.mean ,
self.sigma ) , pypdf = pypdf )
self.pdf = self.pypdf
self.config = {
'name' : self.name ,
'xvar' : self.xvar ,
'mean' : self.mean ,
'sigma' : self.sigma ,
'pypdf' : None ## attention!
}
## the main method
def evaluate ( self ) :
vlist = self.varlist
x = self.variable ( 0 )
m = self.variable ( 1 )
s = self.variable ( 2 )
dx = ( x - m ) / s
return math.exp ( -0.5 * dx * dx ) * NORM / s
## declare analytical integral
def get_analytical_integral ( self ) :
"""Declare the analytical integral"""
x = self.varlist[0]
if self.matchArgs ( x ) : return 1 ## get the integration code
return 0
## calculate the analytical integral
def analytical_integral ( self ) :
"""Calculate the analytical integral"""
assert 1 == self.intCode , 'Invalid integration code!'
vlist = self.varlist
rn = self.rangeName
xv = vlist [ 0 ]
xmax = xv.getMax ( rn )
xmin = xv.getMin ( rn )
m = float ( vlist [ 1 ] )
s = float ( vlist [ 2 ] )
return CDF ( xmax , m , s ) - CDF ( xmin , m , s )
with timing ("Using-PyPDF+AI", logger ) :
pdf.mean = random.gauss ( 3.100 , 0.010 )
pdf.sigma = random.gauss ( 0.012 , 0.001 )
## create PDF
gauss = PyGaussAI( 'PyGaussAI' , xvar = mass ,
mean = pdf.mean , sigma = pdf.sigma )
## build fit model
model = Fit1D ( signal = gauss , background = None , name = 'M1' )
## fit!
r, _ = model .fitTo ( dataset , draw = False , silent = True , ncpu=1 )
with wait ( 1 ) , use_canvas ( "test_PyPDF_AI" ) :
r, f = model .fitTo ( dataset , draw = True , silent = True , ncpu=1 )
logger.info ("Fit result for``pure python'' PDF: PyPDF with analytical integral \n%s" % r.table ( prefix = "# " ) )
gauss = PyGauss2(name='G2', function=function, xvar=mass)
## model
model = Fit1D(signal=gauss, background='p0', name='Q2')
## r1, f1 = gauss .fitTo ( dataset , draw = True , silent = True , ncpu=1 )
## print (r1)
r2, f2 = model.fitTo(dataset, draw=True, silent=True, ncpu=1)
print(r2)
# =============================================================================
if '__main__' == __name__:
## simple Gaussian PDF
with timing("PyGauss : "):
test_pygauss()
## simple Gaussian PDF with analytical integral
with timing("PyGaussAI : "):
test_pygauss_AI()
## simple Gaussian PDF
with timing("PyGauss2 : "):
test_pygauss2()
# =============================================================================
# The END
# =============================================================================
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)
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)))
# =============================================================================
if '__main__' == __name__:
with timing('RooFormulaVar : '):
test_formula()
with timing('PyVAR : '):
test_pyvar()
with timing('PyVAR2 : '):
test_pyvar2()
# =============================================================================
## The END
# =============================================================================
