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 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 _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 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()
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 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 _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 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
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 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))
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)
dataset0 = 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, 5000):
mass.value = m.gauss()
dataset0.add(varset0)
for i in range(0, 500):
mass.value = random.uniform(mmin, mmax)
dataset0.add(varset0)
logger.info('DATASET\n%s' % dataset0)
models = set()
## signal component
signal_gauss = Models.Gauss_pdf(
name='Gauss', ## the name
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()
if '__main__' == __name__ or '__builtin__' == __name__ :
logger = getLogger ( 'test_fitting_pypdf' )
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 ,
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()
# =============================================================================
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
