else:
logger = getLogger(__name__)
logger.info('Create 1D dataset for Ostap Tutorial ')
# ============================================================================
RAD = ROOT.RooAbsData
if RAD.Tree != RAD.getDefaultStorageType():
logger.info('DEFINE default storage type to be TTree! ')
RAD.setDefaultStorageType(RAD.Tree)
# ============================================================================
x = ROOT.RooRealVar('x', 'x', 0, 10)
varset = ROOT.RooArgSet(x)
import Ostap.FitModels as Models
gamma = Models.GammaDist_pdf('GPDF', x)
gamma.k.setVal(2)
gamma.theta.setVal(1)
data = gamma.pdf.generate(varset, 100000)
h1 = x.histo(100)
h2 = x.histo(500)
h3 = h1_axis([0, 1, 2, 3, 6, 8, 10])
data.project(h1, 'x')
data.project(h2, 'x')
data.project(h3, 'x')
h4 = h1_axis(h2.equal_edges(5))
h5 = h1_axis(h2.equal_edges(10))
# =============================================================================
logger.info('Test for signal it models from Analysis/Ostap')
# =============================================================================
## make simple test
mass2 = ROOT.RooRealVar('test_mass2', 'Some test mass', 0, 10)
x = mass2
## book very simple data set
varset2 = ROOT.RooArgSet(mass2)
import Ostap.FitModels as Models
events = 5000
logger.debug('Make a test data using Gamma-Distribution')
m_gamma0 = Models.GammaDist_pdf('GD0', x)
m_gamma0.k.setVal(2)
m_gamma0.theta.setVal(1)
dataset2 = m_gamma0.pdf.generate(varset2, events)
models = []
# =============================================================================
logger.info('Test Gamma-Distribution')
# =============================================================================
m_gamma = Models.GammaDist_pdf('GD1', x)
with rooSilent():
result, f = m_gamma.fitTo(dataset2)
result, f = m_gamma.fitTo(dataset2)
#
varset = ROOT.RooArgSet(m_phi)
#
## create model
#
import Ostap.FitModels as Models
mK = 0.49369
mPion = 0.1396
bw = cpp.Gaudi.Math.Phi0(1.0195, 0.0043, mK)
signal = Models.BreitWigner_pdf('BW0',
bw,
mass=m_phi,
gamma=0.0043,
mean=1.0195,
convolution=0.0015)
## Phase space as background:
ps = cpp.Gaudi.Math.PhaseSpaceNL(2 * mK, 10.0, 2, 5)
bkg = Models.PSPol_pdf('PS0', mass=m_phi, phasespace=ps, power=1)
f2 = cpp.Gaudi.Math.Flatte2(0.980, 165, 4.21, mPion, mPion, mK, mK)
flatte = Models.Flatte2_pdf('F20', f2, mass=m_phi, m0_980=1.000, m0g1=0.165)
flatte.mean.fix(0.980)
model = Models.Fit1D(signal=signal, othersignals=[flatte], background=bkg)
for i in xrange(0, 500):
mass.setVal(random.uniform(mass.getMin(), mass.getMax()))
dataset0.add(varset0)
print dataset0
import Ostap.FitModels as Models
models = []
# =============================================================================
## gauss PDF
# =============================================================================
logger.info('Test Gauss_pdf')
signal_gauss = Models.Gauss_pdf(name='Gauss', mass=mass)
signal_gauss.mean.setVal(m.value())
signal_gauss.sigma.setVal(m.error())
models.append(signal_gauss)
# =============================================================================
## Gauss PDF
# =============================================================================
model_gauss = Models.Fit1D(signal=signal_gauss,
background=Models.Bkg_pdf('BkgGauss',
mass=mass,
power=0))
model_gauss.background.tau.fix(0)
with rooSilent():
# =============================================================================
logger.info('Test for some polynomials models from Analysis/Ostap')
# =============================================================================
## make simple test
mass2 = ROOT.RooRealVar('test_mass3', 'Some test mass', 2, 10)
x = mass2
## book very simple data set
varset2 = ROOT.RooArgSet(mass2)
import Ostap.FitModels as Models
events = 10000
logger.debug('Make a test data using Gamma-Distribution')
m_gamma0 = Models.GammaDist_pdf('GD0', x)
m_gamma0.k.setVal(2)
m_gamma0.theta.setVal(1)
dataset2 = m_gamma0.pdf.generate(varset2, events)
models = []
# =============================================================================
logger.info('Test Gamma-Distribution')
# =============================================================================
m_gamma = Models.GammaDist_pdf('GD1', x)
with rooSilent():
result, f = m_gamma.fitTo(dataset2)
result, f = m_gamma.fitTo(dataset2)
logger.info('DEFINE default storage type to be TTree! ')
RAD.setDefaultStorageType(RAD.Tree)
# ============================================================================
# The variables
# ============================================================================
m_b = ROOT.RooRealVar('mB', 'm(B)', 5.2, 5.4)
m_phi = ROOT.RooRealVar('mPhi', 'm(Phi)', 1.0, 1.050)
h_phi = m_phi.histo(50)
# ============================================================================
import Ostap.FitModels as Models
sigB = Models.Gauss_pdf('Bh',
m_b.getMin(),
m_b.getMax(),
mass=m_b,
mean=5.278,
sigma=0.015)
bw = cpp.Gaudi.Math.Phi0(1.0195, 0.0043, 0.4937)
sigPhi0 = Models.BreitWigner_pdf('Phi0',
bw,
mean=1.0195,
gamma=0.0043,
mass=m_phi,
convolution=0.0005)
sigPhi = sigPhi0
ps2 = cpp.Gaudi.Math.PhaseSpaceNL(2 * 0.4937, 5.278 - 3.096, 2, 3)
logger.info('Create 1D dataset for Ostap Tutorial ')
# ============================================================================
from OstapTutor.TestVars1 import m_psi
#
## create data set
#
varset = ROOT.RooArgSet(m_psi)
#
## create model
#
import Ostap.FitModels as Models
signal = Models.Needham_pdf('N0', mass=m_psi)
bkg = Models.Bkg_pdf('B0', mass=m_psi)
bkg.tau.setVal(-10.0)
model = Models.Fit1D(signal=signal, background=bkg)
model.s.setVal(10000)
model.B.setVal(5000)
data = model.pdf.generate(varset, 15000)
# ============================================================================
if '__main__' == __name__:
import Ostap.Line
logger.info(__file__ + '\n' + Ostap.Line.line)
print dataset
# =============================================================================
import Ostap.FitModels as Models
models = []
# =============================================================================
## gauss as signal, const as background
# =============================================================================
logger.info(
'Simplest (factorized) fit model: ( Gauss + const ) x ( Gauss + const ) ')
model = Models.Fit2D(signal_1=Models.Gauss_pdf('Gx',
m_x.getMin(),
m_x.getMax(),
mass=m_x),
signal_2=Models.Gauss_pdf('Gy',
m_y.getMin(),
m_y.getMax(),
mass=m_y))
model.signal1.sigma.fix(m.error())
model.signal2.sigma.fix(m.error())
model.signal1.mean.fix(m.value())
model.signal2.mean.fix(m.value())
model.signal1.mean.fix(m.value())
model.signal2.mean.fix(m.value())
model.bkg1.tau.fix(0)
model.bkg2.tau.fix(0)
model.bkgA.tau.fix(0)
model.bkgB.tau.fix(0)
if '__main__' == __name__: logger = getLogger('Ostap.TestFlatte')
else: logger = getLogger(__name__)
# ==========================================================================================
logger.info('Compare Breit and Flatte')
# ==========================================================================================
import Ostap.FitModels as Models
from Ostap.Utils import rootWarning
m_X = 3.87156
g_X = 0.001
m_Jpsi = 3.0960
m_pipi = 0.4000
mass = ROOT.RooRealVar('m', 'mass(J/psi pipi)', 3.868, 3.88)
bw = cpp.Gaudi.Math.BreitWigner(m_X, g_X, m_Jpsi, m_pipi, 0)
breit = Models.BreitWigner_pdf('BW', bw, mass=mass, mean=m_X, gamma=g_X)
a1 = 0.40
a2 = 0.03
a1 = 0.03
a2 = 0.40
f1 = a1 / (a1 + a2)
f2 = a2 / (a1 + a2)
fl_ = cpp.Gaudi.Math.Flatte(m_X, m_X * g_X * f1, f2 / f1, m_Jpsi, m_pipi,
1.86483, 2.00696)
flatte = Models.Flatte_pdf('Flatte',
fl_,
"""
# =========================================================================================
import ROOT
from Ostap.PyRoUts import *
from AnalysisPython.Logger import getLogger
# ==========================================================================================
if '__main__' == __name__ : logger = getLogger('OstapTutor/yfits')
else : logger = getLogger( __name__ )
# ==========================================================================================
from OstapTutor.TestVars1 import m_psi,m_ups
import Ostap.FitModels as Models
signal_psi = Models.CB2_pdf('Jpsi' ,
mass = m_psi ,
sigma = 0.013 ,
mean = 3.096 )
signal_psi.aL.fix(1.8)
signal_psi.aR.fix(1.8)
signal_psi.nL.fix(1.8)
signal_psi.nR.fix(1.8)
## define model for J/psi
model_psi = Models.Fit1D( signal = signal_psi ,
background = Models.Bkg_pdf ( 'BJpsi' , mass = m_psi ) )
## define the model for Y
model_Y = Models.Manca2_pdf ( m_ups , power = 0 ,
m1s = 9.4539e+00 ,
sigma = 4.03195e-02 )
# =========================================================================================
import ROOT
from Ostap.PyRoUts import *
# ==========================================================================================
from Ostap.Utils import RooSilent, NoContext
from AnalysisPython.Logger import getLogger
if '__main__' == __name__: logger = getLogger('work_CY/fits')
else: logger = getLogger(__name__)
# ==========================================================================================
logger.info('Define fit models and PDFs for Y+charm analysis')
# ==========================================================================================
from OstapTutor.TestVars1 import m_D0, m_Dp, m_Ds, m_Lc, m_ups
import Ostap.FitModels as Models
signal_D0 = Models.D0_pdf(mass=m_D0,
name='D0',
mean=1.8647e+00,
sigma=7.2037e-03)
signal_Dp = Models.Dp_pdf(mass=m_Dp,
name='Dp',
mean=1.8711e+00,
sigma=7.1183e-03)
signal_Ds = Models.Ds_pdf(mass=m_Ds,
name='Ds',
mean=1.9699e+00,
sigma=6.0178e-03)
signal_Lc = Models.Lc_pdf(mass=m_Lc,
name='Lc',
mean=2.2884e+00,
## random.seed(10)
for i in xrange(0, events):
v1 = random.expovariate(1 / 3.0)
if not 0 < v1 < 10: continue
x.setVal(v1)
dataset4.add(varset4)
v2 = 10 - v1
x.setVal(v2)
dataset5.add(varset4)
import Ostap.FitModels as Models
positive = Models.PolyPos_pdf('PP', mass4, power=3)
increasing = Models.Monothonic_pdf('PI', mass4, power=3, increasing=True)
decreasing = Models.Monothonic_pdf('PD', mass4, power=3, increasing=False)
inc_convex = Models.Convex_pdf('PIX',
mass4,
power=3,
increasing=True,
convex=True)
dec_convex = Models.Convex_pdf('PDX',
mass4,
power=3,
increasing=False,
convex=True)
convex = Models.ConvexOnly_pdf('PX', mass4, power=3, convex=True)
concave = Models.ConvexOnly_pdf('PX', mass4, power=3, convex=False)
# ============================================================================
## 1) import dataset and variable
from OstapTutor.TestData4 import m_psi, m_D0, data
logger.info ( 'Data: %s' % data )
## 2) create the model: signnal + background
#
## create model
#
import Ostap.FitModels as Models
jpsi = Models.Needham_pdf ( 'N' , mass = m_psi , mean = 3.096 , sigma = 0.013 )
D0 = Models.Gauss_pdf ( 'G' , mass = m_D0 , mean = 1.864 , sigma = 0.007 )
model = Models.Fit2D (
signal_1 = jpsi ,
signal_2 = D0 ,
power1 = 2 ,
power2 = 2 ,
powerA = 2 ,
powerB = 2 )
r,f = model.fitTo ( data , silence = True , ncpu = 8 )
r,f = model.fitTo ( data , ncpu = 8 , silence = True )
## 1) import dataset and variable
from OstapTutor.TestData2 import m_psi, data
logger.info ( 'Data: %s' % data )
## 2) create the model: signnal + background
import Ostap.FitModels as Models
## 2a) create the signal :
signal = Models.CrystalBall_pdf ( 'CB' ,
mass = m_psi ,
sigma = 0.013 ,
alpha = 1.5 ,
n = 1 ,
mean = 3.096 )
# signal = Models.CB2_pdf ( 'CB' ,
# mass = m_psi ,
# sigma = 0.013 ,
# alphaL = 1.5 ,
# alphaR = 1.5 ,
# nL = 1 ,
# nR = 1 ,
# mean = 3.096 )
# signal = Models.Bukin_pdf ( 'Bk' ,
# mass = m_psi ,
# sigma = 0.013 ,
logger = getLogger(__name__)
logger.info('Simple fit')
# ============================================================================
## 1) import dataset and variable
from OstapTutor.TestData1 import m_psi, data
logger.info('Data: %s' % data)
## 2) create the model: signnal + background
import Ostap.FitModels as Models
## 2a) create the signal : gaussian here
signal = Models.Gauss_pdf('Gauss', mass=m_psi, sigma=0.013, mean=3.096)
## 2b) create the background : exponential times 1st order polymonial
bkg = Models.Bkg_pdf('B', mass=m_psi, power=1)
## 2c) create the model
model = Models.Fit1D(signal=signal, background=bkg)
## 3) try to fit:
r, f = model.fitTo(data, silence=True, ncpu=8)
signal.mean.release()
signal.sigma.release()
def FitHisto(self, fit_methods, histo):
"""Fit Histogram for all fit_methods.
The result is stored in a AnnaResult
Arguments:
fit_methods {list} -- fit configuration string
histo {TH1} -- histo to be fitted
Returns:
list -- contains all the AnnaResults
"""
try:
assert histo is not None
except AssertionError:
error("Cannot get histo")
return None
subresult_list = list()
print(""" \n========= > Fit histo {} < ========= """.format(
histo.GetName()))
for i, fit_method in enumerate(fit_methods):
# Get the fit configuration
for key in self._fit_key.keys():
self._fit_key[key] = None
self.DecodeFitType(fit_method)
# Redefine the fit range to the histo boundaries
hmin = histo.GetXaxis().GetXmin()
hmax = histo.GetXaxis().GetXmax()
if 'range' in self._fit_key.keys():
if self._fit_key['range'] is not None:
print self._fit_key['range']
hmin = float(min(self._fit_key['range'].split(';')))
hmax = float(max(self._fit_key['range'].split(';')))
fit_range = ROOT.RooRealVar(histo.GetXaxis().GetName(),
histo.GetXaxis().GetTitle(), hmin,
hmax)
# get PDF and create fit model
signal = self.CreateSignalPDF(fit_range)
if signal is None:
continue
background = self.CreateBackgroundPDF(fit_range)
if background is None:
continue
# return None
model = Models.Fit1D(signal=signal, background=background)
data = ROOT.RooDataHist(histo.GetName(), histo.GetTitle(),
ROOT.RooArgList(fit_range), histo)
print(" \n------- > with {} + {} (weight = {} ) \n".format(
self._fit_key['signal'], self._fit_key['bkgr'],
self._fit_key['weight']))
result, frame = model.fitTo(data,
silent=False,
draw=True,
refit=True,
ncpu=8)
debug("{}".format(result))
# Create the AnnaResult
sr_name = "{}_{}".format(fit_method, histo.GetName())
sr = AnnaResult(name=sr_name, title=histo.GetTitle(), histo=histo)
sr.weigth = self._fit_key['weight']
sr.frame = frame
for key in result.parameters().keys():
sr.Set(key, result(key)[0].value(), result(key)[0].error())
sr.Set("FitResult", result.status(), 0., 0.)
sr.Set("CovMatrixStatus", result.covQual(), 0., 0.)
subresult_list.append(sr)
return subresult_list
logger.info('Create 1D dataset for Ostap Tutorial ')
# ============================================================================
from OstapTutor.TestVars1 import m_psi, m_D0
#
## create data set
#
varset = ROOT.RooArgSet(m_psi, m_D0)
#
## create model
#
import Ostap.FitModels as Models
jpsi = Models.Needham_pdf('N0', mass=m_psi, mean=3.096, sigma=0.013)
D0 = Models.Gauss_pdf('G0', mass=m_D0, mean=1.864, sigma=0.007)
bkg_jpsi = Models.Bkg_pdf('B01', mass=m_psi)
bkg_D0 = Models.Bkg_pdf('B02', mass=m_D0)
bkg_jpsi.tau.fix(-10)
bkg_D0.tau.fix(+5)
model = Models.Fit2D(signal_1=jpsi,
signal_2=D0,
bkg1=bkg_jpsi,
bkgA=bkg_jpsi,
bkg2=bkg_D0,
bkgB=bkg_D0)
model.ss.fix(5000)
# =============================================================================
logger.info ( 'Test for histogtram fits')
# =============================================================================
## make simple test
mass2 = ROOT.RooRealVar ( 'test_mass2' , 'Some test mass' , 0 , 10 )
x = mass2
## book very simple data set
varset2 = ROOT.RooArgSet ( mass2 )
import Ostap.FitModels as Models
events = 50000
logger.debug('Make a test data using Gamma-Distribution')
m_gamma0 = Models.GammaDist_pdf( 'GD0' , x )
m_gamma0.k .setVal( 2 )
m_gamma0.theta.setVal( 2 )
dataset2 = m_gamma0.pdf.generate ( varset2 , events )
#
##
h1 = ROOT.TH1D ( hID() , '' , 10 , 0 , 10 ) ; h1.Sumw2()
h2 = ROOT.TH1D ( hID() , '' , 20 , 0 , 10 ) ; h2.Sumw2()
h3 = ROOT.TH1D ( hID() , '' , 100 , 10 , 10 ) ; h3.Sumw2()
random.seed(10)
bins = [ 0 ]
for i in range(0, 9 ) : bins.append ( random.uniform ( 0 , 10 ) )
## prepare"data" histogram: lets use simple exponential and non-equidistance bins
hdata = h1_axis([i for i in range(0, 20)] +
[20 + i * 2 for i in range(0, 20)] +
[60 + i * 4 for i in range(0, 10)] + [100])
for i in range(0, 100000):
v = random.random()
v = -20 * math.log(v)
hdata.Fill(v)
#
## prepare MC-dataset: use Gamma-distribution
#
x = ROOT.RooRealVar('x', 'variable', 0, 100)
## book very simple data set
import Ostap.FitModels as Models
m_gamma0 = Models.GammaDist_pdf('GD0', x)
mean = 35.0
variance = 30**2
m_gamma0.k.setVal(mean**2 / variance)
m_gamma0.theta.setVal(variance / mean)
varset4 = ROOT.RooArgSet(x)
dataset4 = m_gamma0.pdf.generate(varset4, 200000)
mctree = dataset4.store().tree()
## store DATA in DBASE
logger.info('Test data will be stored in DBASE "%s"' % testdatadb)
with DBASE.open(testdatadb, 'c') as db:
db['DATAhistorgam'] = hdata
db['MCtree'] = mctree
#
