def point(self, level): """Contruct a graph objejct for this data point/measurement at givel level""" epos, eneg = self.positive_errors, self.negative_errors if not epos: graph = ROOT.TGraph(1) graph[0] = self.value, 1.0 * level elif epos == eneg: graph = ROOT.TGraphErrors(len(epos)) for i, e in enumerate(epos): graph[i] = VE(self.value, e * e), VE(1.0 * level, 0.) else: graph = ROOT.TGraphAsymmErrors(len(epos)) for i, e in enumerate(zip(epos, eneg)): ep, en = e graph[i] = self.value, en, ep, 1. * level, 0., 0. graph.set_line_attributes(**self.config) graph.set_fill_attributes(**self.config) graph.set_marker_attributes(**self.config) name = self.config.get('name', self.config.get('label', '')) if name: graph.SetName(name) return graph
def test_derivative_5 (): logger = getLogger ( 'test_derivative_5' ) ## the function func2 = lambda x,y : 0.25*x*x + (x-y)*(x-y) + y + 2*x ## use explicit partial derivatives eval2_1 = Eval2VE( func2 , dFdX = lambda x,y : 2+0.5*x+2*(x-y) , dFdY = lambda x,y : 1-2*(x-y) ) ## use numerical partial derivatives eval2_2 = Eval2VE( func2 ) table = [ ( 'x' , 'y' , 'corr' , 'F(exact)' , 'F(numerical)' ) ] for x , y in [ (0,0) , (1,0) , (0,1) , (1,2) , ( 1 , -1 ) , ( -1 , 1 ) , (2,1) ] : for c in ( -1.0 , -0.5 , 0.0 , 0.5 , 1.0 ) : x = VE ( x , 0.1 ** 2 ) y = VE ( y , 0.1 ** 2 ) row = [ x.toString ( '%+5.2f +/- %-5.2f' ) , y.toString ( '%+5.2f +/- %-5.2f' ) , '%+3.1f' % c ] v1 = eval2_1 ( x , y , c ) v2 = eval2_2 ( x , y , c ) row.append ( v1.toString ( '%+6.3f +/- %-5.3f') ) row.append ( v2.toString ( '%+6.3f +/- %-5.3f') ) table.append ( tuple ( row ) ) title = 'Error propagation for F(x,y)' table = T.table ( table , title = title , prefix = '# ' , alignment=5*'c' ) logger.info ('%s\n%s' % ( title , table ) )
def _rfr_sum_ ( self , var1 , var2 , *vars ) : """Get correct estimate of sum of two or more variables, taking into account correlations >>> r = ... >>> print r.sum( 'S' , 'B' ) ## S+B """ allvars = ( var1 , var2 ) + vars n = len ( allvars ) s = 0.0 c2 = 0.0 for i in range ( n ) : vi = allvars [ i ] if isinstance ( vi , str ) : vi = self.param ( vi ) [1] v = vi.value v = VE ( v ) s += v . value () vc = v.cov2() if 0 >= vc or vi in self.constPars() : continue c2 += vc for j in range ( i ) : vj = allvars [ j ] if isinstance ( vj , str ) : vj = self.param ( vj ) [1] if vj in self.constPars() : continue c2 += 2 * self.covariance ( vi , vj ) return VE ( s , c2 )
def _rfr_multiply_ ( self , var1 , var2 , *vars ) : """Get correct estimate of product of two variables, taking into account correlations >>> r = ... >>> print r.multiply( 'S' , 'B' ) ## S*B """ allvars = ( var1 , var2 ) + vars n = len ( allvars ) m = 1.0 c2 = 0 for i in range ( n ) : vi = allvars[i] if isinstance ( vi , str ) : vi = self.param ( vi )[1] v = vi.value v = VE ( v ) vv = v.value () if iszero ( vv ) or iszero ( m ) : return VE ( 0.0 , 0.0 ) ## RETURN HERE m *= vv vc = v.cov2() if 0 >= vc or vi in self.constPars() : continue c2 += vc / ( vv * vv ) for j in range ( i ) : vj = allvars [ j ] if isinstance ( vj , str ) : vj = self.param( vj )[1] if vj in self.constPars() : continue w = vj . value w = VE ( w ) ww = w.value() c2 += 2 * self.covariance ( vi , vj ) / ( vv * ww ) return VE ( m , c2 * m * m )
def _mn_par_ ( self , i ) : """Get the parameter from (T)Minuit >>> mn = ... # TMinuit object >>> p1 = mn[0] # get the parameter by index >>> p1 = mn.par(0) # ditto >>> p1 = mn.parameter(0) # ditto >>> p2 = mn['par2'] # get the parameter by name >>> p2 = mn.par('par2') # ditto >>> p2 = mn.parameter('par2') # ditto """ if not i in self : raise IndexError if isinstance ( i , string_types ) : i = _mn_index_ ( self , i ) # val = ctypes.c_double ( 0 ) err = ctypes.c_double ( 0 ) # res = self.GetParameter ( i , val , err ) # val = float ( val.value ) err = float ( err.value ) # return VE ( val , err * err )
def _rav_getvale_(self): """Get the value(and the error), associated with the variable >>> var = ... >>> print var.value """ v = self.getVal() e = self.getError() return VE(v, e * e) if e > 0 else v
def _rrv_ve_(var): """Convert RooRealVar into ValueWithError >>> par = ... >>> ve = par.ve() """ v = var.getVal() e2 = 0 if var.isConstant() else var.getError()**2 # return VE(v, e2)
def _rad_skewness_(data, var, error=True, *args): if isintance(var, str): varset = data.get() assert var in varset, 'Invalid variable %s' % var var = getarrt(varset, var) return _rad_skewness_(data, var, error, *args) s = data._old_skewness_(var, *args) if not error: return s n = dat.sumEntries(*args) if 2 > n: return VE(s, 0) c2 = 6.0 c2 *= (n - 2) c2 /= (n + 1) * (n + 3) return VE(s, c2)
def test_constraint(): logger = getLogger('test_constraint') r0, f0 = model.fitTo(data, silent=True) with wait(1), use_canvas("Unconstrained fit"): r0, f0 = model.fitTo(data, silent=True, draw=True, nbins=100, minos=('S', 'mean_Gauss', 'sigma_Gauss')) logger.info("Uncontrained fit\n%s" % r0.table(prefix='# ')) ## prepare asymmetric constraints a0 = model.soft_constraint2(signal.sigma, 1, -0.7, 0.05) a1 = model.soft_constraint2(signal.mean, 5, -0.05, 5) with wait(1), use_canvas("Constrained (asymmetric) fit"): r1, f1 = model.fitTo(data, silent=True, constraints=(a0, a1)) r1, f1 = model.fitTo(data, silent=True, draw=True, nbins=100, constraints=(a0, a1), minos=('S', 'mean_Gauss', 'sigma_Gauss')) logger.info("Constrained (asymmetric) fit\n%s" % r1.table(prefix='# ')) ## prepare symmetric constrains s0 = model.soft_constraint(signal.sigma, VE(1, 0.15**2)) s1 = model.soft_constraint(signal.mean, VE(5, 0.10**2)) with wait(1), use_canvas("Constrained (symmetric) fit"): r2, f2 = model.fitTo(data, silent=True, constraints=(s0, s1)) r2, f2 = model.fitTo(data, silent=True, draw=True, nbins=100, constraints=(s0, s1), minos=('S', 'mean_Gauss', 'sigma_Gauss')) logger.info("Symmetric constrained fit\n%s" % r2.table(prefix='# '))
def _om_rms(obj): """Get a RMS value for the moment-counter >>> m = ... >>> v = m.rms () """ assert 2 <= obj.order, 'rms: the order must be >=2!' ## var = obj.variance() if isinstance(var, VE): return VE(max(var.value(), 0), var.cov2())**0.5 return max(var, 0)**0.5
def _rad_kurtosis_(data, var, error=True, *args): if isintance(var, str): varset = data.get() assert var in varset, 'Invalid variable %s' % var var = getarrt(varset, var) return _rad_kurtisis_(data, var, error, *args) k = data._old_kurtosis_(var, *args) if not error: return k n = dat.sumEntries(*args) if 3 > n: return VE(k, 0) c2 = 24.0 * n c2 *= (n - 2) * (n - 3) c2 /= (n + 1) * (n + 1) c2 /= (n + 3) * (n + 5) return VE(k, c2)
def test_covtransform2(): logger.info('Absolute yields to the ratios') ## three independent variables: X = VE ( 81143.24 , 286.58 ** 2 ) , \ VE ( 4231.37 , 72.57 ** 2 ) , \ VE ( 137.11 , 25.79 ** 2 ) ## their ratios alpha = lambda x0, x1, x2: x2 * 1.0 / x1 beta = lambda x0, x1, x2: x2 * 1.0 / x0 gamma = lambda x0, x1, x2: x1 * 1.0 / x0 C = transform(None, X, alpha, beta, gamma) R = C.correlations() logger.info('Covariance :\n%s' % C) logger.info('Correlation :\n%s' % R)
def test_covtransform3(): logger.info('Absolute values to the differences') ## three independent variables: X = VE ( 3686.05 , 0.01 ** 2 ) , \ VE ( 3871.55 , 0.06 ** 2 ) , \ VE ( 3824.04 , 0.53 ** 2 ) ## their differences alpha = lambda x0, x1, x2: x1 - x2 beta = lambda x0, x1, x2: x2 - x0 gamma = lambda x0, x1, x2: x1 - x0 C = transform(None, X, alpha, beta, gamma) R = C.correlations() logger.info('Covariance :\n%s' % C) logger.info('Correlation :\n%s' % R)
def _tf1_par_(func, par): """Get parameter from TF1 >>> fun = ... ## function >>> p2 = fun.par(2) ## get parameter #2 >>> pm = fun.par('m') ## get parameter 'm' """ if not par in func: raise IndexError("Invalid parameter index %s" % par) # if isinstance(par, str): par = func.GetParNumber(par) v = func.GetParameter(par) e = func.GetParError(par) # return VE(v, e * e)
def _sum_var_ ( tree , expression , *cuts ) : """Make a sum over expression in Tree/Dataset >>> dataset = ... ## get corrected number of signal events >>> n_corr = dataset.sumVar ( 'S_sw/effic' ) ## get corrected number of signal events >>> n_corr_pt = dataset.sumVar ( 'S_sw/effic' , 'pt>1') """ w = tree.statVar ( expression , *cuts ) return VE ( w.sum() , w.sum2() )
def jackknife_statistics(statistics, theta=None): """Jackknife estimator from jackknife statistic >>> statistics = .... >>> jacknife = jackknife_estimator ( statistics ) >>> jacknife , theta_corr , bias = jackknife_esiimator ( statistics , value ) """ assert isinstance ( theta , VE ) or theta is None ,\ "jackknife_statistics: invalid type of ``value'' %s" % type ( value ) N = statistics.nEntries() ## number of jackknife samples theta_dot = statistics.mean() ## mean over jackknife samples jvar = statistics.variance() * (N - 1) ## variance jackknife = VE(theta_dot.value(), jvar) ## jackknife estimate ## get Jackknife estimator from statistics if theta is None: return jackknife bias = (N - 1) * (theta_dot.value() - theta.value()) ## theta corrected for the bias and with Jackknife variance theta_jack = VE(theta.value() - bias, jvar) ## corrected value return jackknife, theta_jack
def _rfr_asymmetry_ ( self , var1 , var2 ) : """Get correct estimate of asymmetry of two variables, (v1-v2)/(v1+v2) taking into account correlations >>> r = ... >>> print r.asymmetry( 'A' , 'B' ) ## (A-B)/(A+B) """ if isinstance ( var1 , str ) : var1 = self.param ( var1 ) [1] if isinstance ( var2 , str ) : var2 = self.param ( var2 ) [1] ## _av1 = abs ( var1.value.value() ) _av2 = abs ( var2.value.value() ) _one = VE ( 1 , 0 ) if _av1 <= _av2 : return self.ratio ( var1 , var2 ) . asym ( _one ) else : return -1 * self.ratio ( var2 , var1 ) . asym ( _one )
def _mn_par_ ( self , i ) : """Get the parameter from minuit >>> mn = ... # TMinuit object >>> p1 = mn[0] # get the parameter >>> p1 = mn.par(0) # ditto >>> p1 = mn.parameter(0) # ditto """ if not i in self : raise IndexError # ip = ROOT.Long ( i ) val = ROOT.Double ( 0 ) err = ROOT.Double ( 0 ) # res = self.GetParameter ( ip , val , err ) # return VE ( val , err*err )
def _rad_moment_(data, var, order, value=0, error=True, *args): """ Get n-th moment of the distribution >>> data = ... >>> print data.moment ( 'mass' , 3 ) """ assert isinstance(order, int) and 0 <= order, 'Invalid "order" %s' % order if isintance(var, str): varset = data.get() assert var in varset, 'Invalid variable %s' % var var = getarrt(varset, var) return _rad_moment_(data, var, order, value, error, *args) m = data._old_moment_(var, order, value, *args) if not error: return m n = data.sumEntries(*args) sigma = data.sigma(var, *args) if abs(value - 0) < 0.01 * sigma: m2 = data._old_moment(var, 2 * order, *args) c2 = (m2 - m * m) c2 /= n elif abs(value - data._old_moment_(var, 1, 0, *args)) < 0.01 * sigma: m2 = data._old_moment_(var, 2, value, *args) m2o = data._old_moment_(var, 2 * order, value, *args) mum = data._old_moment_(var, order - 1, value, *args) mup = data._old_moment_(var, order + 1, value, *args) c2 = m2o c2 -= 2.0 * order * mum * mup c2 -= m * m c2 += order * order * m2 * mum * mup c2 /= n else: logger.error( "Uncertainnry can be calcualted onlyfro moment/central moment") return VE(m, c2)
def _mn_par_(self, i): """Get the parameter from minuit >>> mn = ... # TMinuit object >>> p1 = mn[0] # get the parameter >>> p1 = mn.par(0) # ditto >>> p1 = mn.parameter(0) # ditto """ if not i in self: raise IndexError # val = ctypes.c_double(0) err = ctypes.c_double(0) # res = self.GetParameter(i, val, err) # val = float(val.value) err = float(err.value) # return VE(val, err * err)
def transform(C, X, *Y): """ Transform the covariance nmatrix C at point X to the variables Y(X) >>> X = 1 , 2 >>> C = Ostap.SymMatrix(2)() >>> C [ 0 , 0 ] = 0.20 >>> C [ 0 , 1 ] = 0.05 >>> C [ 1 , 1 ] = 0.30 >>> r = lambda x , y : (x*x+y*y)**2 >>> phi = lambda x , y : math.atan2 ( y , x ) >>> C_polar = transform ( C , X , r , phi ) """ ny = len(Y) assert 1 <= ny, 'Invalid size of Y!' nx = len(X) if C is None and 1 <= nx: C = Ostap.SymMatrix(nx)() for i, x in enumerate(X): xx = VE(x) C[i, i] = xx.cov2() shape = C.shape assert shape[0] == shape[1] and shape[0] == nx, 'Invalid shape of matrix C!' CC = Ostap.SymMatrix(nx)() for i in range(CC.kRows): CC[i, i] = C(i, i) for j in range(i + 1, CC.kCols): v = 0.5 * (C(i, j) + C(j, i)) CC[i, j] = v XX = Ostap.Vector(nx)() for i, x in enumerate(X): XX[i] = float(x) ## get vector-with-errors XX = Ostap.VectorE(nx)(XX, CC) R = XX.transform(*Y) return R.cov2()
if '__main__' == __name__ or '__builtin__' == __name__: logger = getLogger('test_components') else: logger = getLogger(__name__) # ============================================================================= ## 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() m1 = VE(3, 0.500**2) m2 = VE(5, 0.250**2) m3 = VE(7, 0.125**2) ## fill it with three gausissians, 5k events each for i in xrange(0, 5000): for m in (m1, m2, m3): mass.value = m.gauss() dataset.add(varset) ## add 5k events of uniform background for i in xrange(0, 5000): mass.value = random.uniform(*mass.minmax()) dataset.add(varset) ## make background less trivial:
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='# ')))
from ostap.logger.logger import getLogger if '__main__' == __name__ or '__builtin__' == __name__ : logger = getLogger ( 'test_fitting_models_2D' ) else : logger = getLogger ( __name__ ) # ============================================================================= ## make simple test mass m_x = ROOT.RooRealVar ( 'mass_x' , 'Some test mass(X)' , 3 , 3.2 ) m_y = ROOT.RooRealVar ( 'mass_y' , 'Some test mass(Y)' , 3 , 3.2 ) ## book very simple data set varset = ROOT.RooArgSet ( m_x , m_y ) dataset = ROOT.RooDataSet ( dsID() , 'Test Data set-1' , varset ) ## fill it with uniform (x,y) m = VE(3.100,0.015**2) w = VE(3.100,0.100**2) for i in range(0,2500) : 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 ) models = set() # ============================================================================= ## Positive polynomial in X and Y
def print_bootstrap(fitresult, stats, morevars={}, logger=logger, title=''): """print Bootstrap statistics """ header = ('Parameter', 'theta', 'theta_boot', 'bias/sigma [%]', 'error [%]') table = [] n = 0 for name in sorted(stats): if name in fitresult: p = fitresult[name] theta = p * 1.0 if not isinstance(theta, VE) or theta.cov2() <= 0: logger.warning( 'print_bootstrap: parameter "%s" is invalid in ``fitresult' ', skip %s' % (name, theta)) continue elif name in morevars: theta = morevars[name] if not isinstance(theta, VE) or theta.cov2() <= 0: logger.warning( 'print_bootstrap: parameter "%s" is invalid in ``morevars' ', skip %s' % (name, theta)) continue else: continue statistics = stats[name] n = max(n, statistics.nEntries()) theta_boot = VE(statistics.mean().value(), statistics.mu2()) bias = theta_boot.value() - theta.value() scale = theta.error() / theta_boot.error() row = (name, "%+13.6g +/- %-13.6g" % (theta.value(), theta.error()), "%+13.6g +/- %-13.6g" % (theta_boot.value(), theta_boot.error()), '%+6.2f' % (bias / theta.error() * 100), '%+6.2f' % (scale * 100 - 100)) table.append(row) for name in sorted(stats): if name in fitresult: continue if name in morevars: continue statistics = stats[name] theta_boot = VE(statistics.mean().value(), statistics.mu2()) row = name, '', "%+13.6g +/- %-13.6g" % (theta_boot.value(), theta_boot.error()), '', '' table.append(row) table = [header] + table title = title if title else "Bootstrapping with #%d samples" % n import ostap.logger.table as Table table = Table.table(table, title=title, alignment='lcccc', prefix="# ") logger.info('%s:\n%s' % (title, table))
def getLumi(data, *args): """Get lumi : >>> l1 = getLumi ( 'myfile.root' ) >>> l2 = getLumi ( tree ) >>> l3 = getLumi ( chain ) >>> l4 = getLumi ( file ) >>> l5 = getLumi ( [ any sequence of above ] ) """ # if args: data = [data] for a in args: data.append(a) return getLumi(data) if isinstance(data, str): ## expand the actual file name data = os.path.expandvars(data) data = os.path.expanduser(data) data = os.path.expandvars(data) data = os.path.expandvars(data) try: tree = ROOT.TChain(lumi_tree) tree.Add(data) return getLumi(tree) except: logger.error('Unable to get lumi/1 for %s' % data) return VE() # if isinstance(data, ROOT.TFile): try: tree = data.Get(lumi_tree) return getLumi(tree) except: logger.error('Unable to get lumi/2 for %s' % data.GetName()) return VE() if isinstance(data, ROOT.TTree): ## try : with rootError(): ## suppress errors from ROOT ## if hasattr ( data , 'pstatVar' ) : ## stat = data.pstatVar ( [ lumi , lumi_err ] , lumi_cuts , chunk_size = -1 , max_files = 10 ) ## else : stat = data.statVar([lumi, lumi_err], lumi_cuts) ## s1 = stat[lumi] s2 = stat[lumi_err] ## return VE(s1.sum(), s2.sum()**2) ##except : ## logger.error('Unable to get lumi/3 for %s' % data.GetName() ) ## return VE() l = VE() for i in data: k = getLumi(i) ## @attention: linear addition of uncertainties: l = VE(l.value() + k.value(), (l.error() + k.error())**2) return l
from ostap.logger.logger import getLogger if '__main__' == __name__ or '__builtin__' == __name__: logger = getLogger('test_fitting_components') else: logger = getLogger(__name__) # ============================================================================= ## 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) ## 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.20**2) ## fill it with three gausissians, 5k events each N_ss = 5000 N_sb = 500 N_bs = 500 N_bb = 1000 random.seed(0) ## fill it : 5000 events Gauss * Gauss *Gauss for m in (m1, m2): for i in range(0, N_ss): m_x.value = m.gauss() m_y.value = m.gauss()
docme(__name__, logger=logger) conf = { 'marker_style': 20, 'marker_size': 2, 'marker_color': 1, 'line_color': 1, 'label_position': 4.0 } aconf = {} aconf.update(conf) aconf.update({'marker_size': 4, 'marker_style': 1}) data = [ Record(3, 0.5, 0.5, 0.5, label='LHCb', **conf), Record(VE(2.5, 0.3**3), (-0.8, 0.1), 0.5, label='LHCb-2', **conf), Limit(1.4, 1.e-6, label='BESIII', **aconf) ] ave = Average(VE(2.0, 0.2**2), (-0.3, 0.8), label='PDG', **conf) data.append(ave) result1 = draw_summary(data, average=ave, vmax=6) result2 = draw_summary(data, average=ave, transpose=True, vmax=6) # ============================================================================= ## The END # =============================================================================
# ============================================================================= from ostap.logger.logger import getLogger if '__main__' == __name__ or '__builtin__' == __name__: logger = getLogger('test_fitting_models4_2D') else: logger = getLogger(__name__) # ============================================================================= ## make simple test mass m_x = ROOT.RooRealVar('mass_x', 'Some test mass(X)', 3, 3.2) m_y = ROOT.RooRealVar('mass_y', 'Some test mass(Y)', 3, 3.2) ## 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
logger = getLogger('test_fitting_resolutions') else: 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() # =============================================================================