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 # =============================================================================