def Process(self, entry):
"""
Fills data set
"""
#
# == getting the next entry from the tree
#
if self.GetEntry(entry) < 0:
return 0 # RETURN
#
if not self._progress:
self._total = self.fChain.GetEntries()
logger.info('TChain entries: %d' % self._total)
self._progress = ProgressBar(
0,
self._total,
80,
mode='fixed')
if 0 == self._events % 1000:
self._progress.increment_amount(1000)
self._events += 1
#
# == for more convenience
#
bamboo = self.fChain
if not self.mmin <= bamboo.DTFm_b < self.mmax:
return 0
#
# apply cuts
if not self . _cuts(bamboo):
return 0
# calculate & store the efficiency weight
w = self._weight(bamboo)
self._counter += 0 != w
vv = self._mlp()
# if vv < 0.75 : return 0
self.mass . setVal(bamboo.DTFm_b)
for k, v in self.variables.items():
if k in self.meta:
v.setVal(getattr(bamboo, self.meta[k][0])[self.meta[k][1]])
else:
v.setVal(getattr(bamboo, k))
# v.setVal(self.get_from_bamboo(k, bamboo))
self.data .add(self.varset)
return 1
class TrgSelector(Selector):
"""
ROOT selector for getting Tis/Tos information from prompt charm particle
"""
# constructor from cuts and histogram bins
# @param var_ the prefix for trgger variable in n-tuple
# @param histo the mass histogram template
# @param pt_axis the pt-axis binnig
# @param y_axis the y-axis binnig
# @param l0 perform tistos'ing of L0
# @param l1 perform tistos'ing of L1
# @param l2 perform tistos'ing of L2
# @param cuts the cuts (in any)
def __init__(self,
var_,
histo,
pt_axis,
y_axis,
l0=True,
l1=True,
l2=True,
cuts=lambda s: True):
Selector.__init__(self, None, self) # initialize the base
self._l0 = l0
self._l1 = l1
self._l2 = l2
trg = self._l0 or self._l1 or self._l2
if not trg:
raise TypeError, 'Trigger is not specified '
self._cuts = cuts
self._pt_axis = pt_axis
self. _y_axis = y_axis
self._histos = {}
self._events = 0L
#
self.pt_ = 'pt_' + var_
self.y_ = 'y_' + var_
self.m_ = 'm_' + var_
#
self.l0_tos = var_ + '_l0tos_1'
self.l0_tis = var_ + '_l0tis_2'
#
self.l1_tos = var_ + '_l1tos_1'
self.l1_tis = var_ + '_l1tis_2'
#
self.l2_tos = var_ + '_l2tos_1'
self.l2_tis = var_ + '_l2tis_2'
self._var = var_
for iPt in pt_axis:
for iY in y_axis:
hTotal = histo.Clone(hID())
hExTos = histo.Clone(hID())
hTisTos = histo.Clone(hID())
hExTis = histo.Clone(hID())
hTob = histo.Clone(hID())
hTotal . SetTitle('Total')
hExTis . SetTitle('ExTis')
hExTos . SetTitle('ExTos')
hTisTos . SetTitle('Tis&Tos')
hTob . SetTitle('Tob')
self._histos[(iPt, iY)] = [
hTotal,
hExTos,
hTisTos,
hExTis,
hTob
]
#
## global bin
#
hTotal = histo.Clone(hID())
hExTos = histo.Clone(hID())
hTisTos = histo.Clone(hID())
hExTis = histo.Clone(hID())
hTob = histo.Clone(hID())
hTotal . SetTitle('Total')
hExTis . SetTitle('ExTis')
hExTos . SetTitle('ExTos')
hTisTos . SetTitle('Tis&Tos')
hTob . SetTitle('Tob')
self._histos0 = [
hTotal,
hExTos,
hTisTos,
hExTis,
hTob
]
#
# progress bar
#
self._progress = None
self._events = 0
def histos(self):
print ' '
return self._histos, self._pt_axis, self._y_axis, self._histos0
# start processing
def Begin(self):
"""
Start processing
"""
print 80 * '*'
print 'Begin %s L0 %s L1 %s L2 %s ' % (self._var,
self._l0,
self._l1,
self._l2)
# end processing
def Terminate(self):
"""
End processing
"""
print '\nTerminate %s L0 %s L1 %s L2 %s ' % (self._var,
self._l0,
self._l1,
self._l2)
n_total = self._histos0[0] . accumulate()
n_extos = self._histos0[1] . accumulate()
n_tistos = self._histos0[2] . accumulate()
n_extis = self._histos0[3] . accumulate()
n_tob = self._histos0[4] . accumulate()
print ' #tot %.0f #extos %.0f #tistos %.0f #extis %.f #tob %.0f ' % (n_total . value(),
n_extos . value(
),
n_tistos . value(
),
n_extis . value(
),
n_tob . value())
eTOS = 1 / (1 + n_extis / n_tistos)
eTIS = 1 / (1 + n_extos / n_tistos)
print ' eTOS=%s%% eTIS=%s%% ' % (eTOS * 100, eTIS * 100)
print 80 * '*'
# the only one important method
def Process(self, entry):
"""
Fills the histograms from a tree
"""
#
# == getting the next entry from the tree
#
if self.GetEntry(entry) <= 0:
return 0 # RETURN
if not self._progress:
print ' Trg-Chain entries: %d' % self.fChain.GetEntries()
self._progress = ProgressBar(
0,
self.fChain.GetEntries(),
80,
mode='fixed')
self._events += 1
if 0 == self._events % 1000:
self._progress.increment_amount(1000)
print self._progress, '\r',
#
# == for more convenience
#
bamboo = self.fChain
#
# apply trivial "acceptance" cuts
#
pt = getattr(bamboo, self.pt_)
y = getattr(bamboo, self.y_)
if not 2 <= y <= 4.5:
return 0 # RETURN
if not pt <= 12.0:
return 0 # RETURN
#
# check cuts
#
if not self._cuts(bamboo):
return 0 # RETURN
#
# Finally: find the histogram and fill it !
#
ptBin = self._pt_axis . FindBin(pt)
yBin = self. _y_axis . FindBin(y)
key = (ptBin, yBin)
if not key in self._histos:
return 0
histos = self._histos[key]
histos0 = self._histos0
#
# extract TisTos information:
#
# ALL:
tos = True
tis = True
#
# L0
if self._l0 and (tis or tos):
#
tos_l0 = 1 == getattr(bamboo, self.l0_tos)
tis_l0 = 1 == getattr(bamboo, self.l0_tis)
#
tos = tos and tos_l0
tis = tis and tis_l0
#
# HLT1
if self._l1 and (tis or tos):
#
tos_l1 = 1 == getattr(bamboo, self.l1_tos)
tis_l1 = 1 == getattr(bamboo, self.l1_tis)
tos = tos and tos_l1
tis = tis and tis_l1
#
# HLT2
if self._l2 and (tis or tos):
tos_l2 = 1 == getattr(bamboo, self.l2_tos)
tis_l2 = 1 == getattr(bamboo, self.l2_tis)
tos = tos and tos_l2
tis = tis and tis_l2
#
# TIS/TOS categories
exTos = tos and not tis
exTis = tis and not tos
tisTos = tis and tos
mass = getattr(bamboo, self.m_)
#
# All:
if True:
histos[0] . Fill(mass) # ALL
histos0[0] . Fill(mass) # ALL
#
# start TisTos'ing:
if exTos:
histos[1] . Fill(mass) # ExTos
histos0[1] . Fill(mass) # ExTos
elif tisTos:
histos[2] . Fill(mass) # Tis&Tos
histos0[2] . Fill(mass) # Tis&Tos
elif exTis:
histos[3] . Fill(mass) # ExTis
histos0[3] . Fill(mass) # ExTis
else:
histos[4] . Fill(mass) # Tob
histos0[4] . Fill(mass) # Tob
#
return 1
def Process(self, entry):
"""
Fills the histograms from a tree
"""
#
# == getting the next entry from the tree
#
if self.GetEntry(entry) <= 0:
return 0 # RETURN
if not self._progress:
print ' Trg-Chain entries: %d' % self.fChain.GetEntries()
self._progress = ProgressBar(
0,
self.fChain.GetEntries(),
80,
mode='fixed')
self._events += 1
if 0 == self._events % 1000:
self._progress.increment_amount(1000)
print self._progress, '\r',
#
# == for more convenience
#
bamboo = self.fChain
#
# apply trivial "acceptance" cuts
#
pt = getattr(bamboo, self.pt_)
y = getattr(bamboo, self.y_)
if not 2 <= y <= 4.5:
return 0 # RETURN
if not pt <= 12.0:
return 0 # RETURN
#
# check cuts
#
if not self._cuts(bamboo):
return 0 # RETURN
#
# Finally: find the histogram and fill it !
#
ptBin = self._pt_axis . FindBin(pt)
yBin = self. _y_axis . FindBin(y)
key = (ptBin, yBin)
if not key in self._histos:
return 0
histos = self._histos[key]
histos0 = self._histos0
#
# extract TisTos information:
#
# ALL:
tos = True
tis = True
#
# L0
if self._l0 and (tis or tos):
#
tos_l0 = 1 == getattr(bamboo, self.l0_tos)
tis_l0 = 1 == getattr(bamboo, self.l0_tis)
#
tos = tos and tos_l0
tis = tis and tis_l0
#
# HLT1
if self._l1 and (tis or tos):
#
tos_l1 = 1 == getattr(bamboo, self.l1_tos)
tis_l1 = 1 == getattr(bamboo, self.l1_tis)
tos = tos and tos_l1
tis = tis and tis_l1
#
# HLT2
if self._l2 and (tis or tos):
tos_l2 = 1 == getattr(bamboo, self.l2_tos)
tis_l2 = 1 == getattr(bamboo, self.l2_tis)
tos = tos and tos_l2
tis = tis and tis_l2
#
# TIS/TOS categories
exTos = tos and not tis
exTis = tis and not tos
tisTos = tis and tos
mass = getattr(bamboo, self.m_)
#
# All:
if True:
histos[0] . Fill(mass) # ALL
histos0[0] . Fill(mass) # ALL
#
# start TisTos'ing:
if exTos:
histos[1] . Fill(mass) # ExTos
histos0[1] . Fill(mass) # ExTos
elif tisTos:
histos[2] . Fill(mass) # Tis&Tos
histos0[2] . Fill(mass) # Tis&Tos
elif exTis:
histos[3] . Fill(mass) # ExTis
histos0[3] . Fill(mass) # ExTis
else:
histos[4] . Fill(mass) # Tob
histos0[4] . Fill(mass) # Tob
#
return 1
class SBT(SelectorWithCuts):
"""
Create and fill the basic dataset for RooFit
"""
def add_variable(self, name, description, low, high):
self.variables[name] = ROOT.RooRealVar(filter_name(name), description, low, high)
self.varset.add(self.variables[name])
index = self.num_re.search(name)
if index:
i = int(index.group(0))
name_noindex = name.replace('[' + str(i) + ']', '')
self.meta[name] = (name_noindex, i)
def __init__(self,
mass, # mass-variable
selection, # Tree-selection
cuts=lambda s: True,
weight=lambda s: 1,
name='',
tmva_weights='',
short=False):
if not name:
name = hID()
SelectorWithCuts.__init__(self, selection) # initialize the base
self.num_re = re.compile(r"[(\d)]")
self._cuts = cuts
self._weight = weight
self._short = short
self.variables = {}
# meta info about vector-variables
# contain pairs (name without `[N]`, N as int)
self.meta = {}
self.mass = mass
self.varset = ROOT.RooArgSet(self.mass)
for v in varlist:
self.add_variable(v[0], v[4], v[2] - 0.1, v[3] + 0.1,)
self.data = ROOT.RooDataSet(
#
name,
"Bu -> J/psi KK pi: " + self.mass.GetName(),
#
self.varset
)
ROOT.SetOwnership(self.data, False)
self.mmin = self.mass.getMin()
self.mmax = self.mass.getMax()
self._events = 0
self._counter = SE()
self._progress = None
self._total = 1
self._tmva_weights = tmva_weights
def __del__(self):
self.data.Clear()
self.data.reset()
del self.data
def dataset(self):
return self.data
def Terminate(self):
print ''
logger.info('Terminate: %d/%d %s ' %
(self._events, self._total, self.cuts()))
self.data.Print('v')
def Init(self, chain):
self._mlp = lambda: 0.5
if chain and self._tmva_weights:
from tmva_reader import Cutter
self._mlp = Cutter(chain, self._tmva_weights)
return SelectorWithCuts.Init(self, chain)
# the only one important method
def Process(self, entry):
"""
Fills data set
"""
#
# == getting the next entry from the tree
#
if self.GetEntry(entry) < 0:
return 0 # RETURN
#
if not self._progress:
self._total = self.fChain.GetEntries()
logger.info('TChain entries: %d' % self._total)
self._progress = ProgressBar(
0,
self._total,
80,
mode='fixed')
if 0 == self._events % 1000:
self._progress.increment_amount(1000)
self._events += 1
#
# == for more convenience
#
bamboo = self.fChain
if not self.mmin <= bamboo.DTFm_b < self.mmax:
return 0
#
# apply cuts
if not self . _cuts(bamboo):
return 0
# calculate & store the efficiency weight
w = self._weight(bamboo)
self._counter += 0 != w
vv = self._mlp()
# if vv < 0.75 : return 0
self.mass . setVal(bamboo.DTFm_b)
for k, v in self.variables.items():
if k in self.meta:
v.setVal(getattr(bamboo, self.meta[k][0])[self.meta[k][1]])
else:
v.setVal(getattr(bamboo, k))
# v.setVal(self.get_from_bamboo(k, bamboo))
self.data .add(self.varset)
return 1
class SpsiD(Selector):
"""
Create and fill the basic dataset for RooFit
"""
def __init__(self,
cuts,
dvar,
weight,
jvar="psi",
h1=None,
h2=None,
h3=None,
h4=None):
Selector.__init__(self, None, self) # initialize the base
self._jvar = jvar
self._cuts = cuts
self._weight = weight
self.m_2c = ROOT.RooRealVar(
"m_2c", "mass(J/psiD)", 3.0, 100)
self.m_psi = ROOT.RooRealVar(
"m_psi", "mass(J/psi)", 3.0, 3.2)
self.pt_psi = ROOT.RooRealVar("pt_psi", "pt(J/psi)", 0, 12.0)
self.y_psi = ROOT.RooRealVar("y_psi", "y(J/psi)", 2.0, 4.5)
self.lv01_psi = ROOT.RooRealVar(
"lv01_psi", "lv01(J/psi)", -1.01, 1.01)
self.chi2dtf = ROOT.RooRealVar(
"chi2dtf", "chi2(dtf)/ndf", 0, 1.e+100)
self._dvar = dvar[0]
self.m_D = ROOT.RooRealVar(
"m_" + dvar[0], "mass(D)", dvar[1], dvar[2])
self.pt_D = ROOT.RooRealVar("pt_" + dvar[0], "pt(D)", 0, 12.0)
self.y_D = ROOT.RooRealVar("y_" + dvar[0], "y(D)", 2.0, 4.5)
self.weight = ROOT.RooRealVar("weight", "weight", 0.0, 1.e+20)
self.dphi = ROOT.RooRealVar(
"dphi", "|delta(phi)|/pi", 0.0, 1.0)
self.varset = ROOT.RooArgSet(
#
self.m_2c,
self.m_psi,
self.pt_psi,
self.y_psi,
#
self.m_D,
self.pt_D,
self.y_D,
# efficiency weight
self.weight
)
self.varset.add(self.lv01_psi)
self.varset.add(self.dphi)
self.varset.add(self.chi2dtf)
self.nPV = ROOT.RooRealVar("nPV", 'n(PV)', 0, 20)
self.nSpd = ROOT.RooRealVar("nSpd", 'n(Spd)', 0, 20000)
self.nBest = ROOT.RooRealVar("nBest", 'n(Best)', 0, 5000)
self.nLong = ROOT.RooRealVar("nLong", 'n(Long)', 0, 5000)
self.nOT = ROOT.RooRealVar("nOT", 'n(OT)', 0, 50000)
self.varset.add(self.nPV)
self.varset.add(self.nSpd)
self.varset.add(self.nBest)
self.varset.add(self.nLong)
self.varset.add(self.nOT)
self.data = ROOT.RooDataSet(
#
"SpsiD",
"Jpsi + Charm",
#
self.varset
)
#
#
# prepare the structure for slice fits:
# fill histos only in case both histo templates are supplied
self.slices_raw = None
self.slices_cor = None
if h1 and h2:
self.slices_raw = Slices(h1, h2)
if h3 and h4:
self.slices_cor = Slices(h3, h4)
#
self._events = 0
self._counter = SE()
#
self._progress = None
#
#
def dataset(self):
return self.data
# the only one important method
def Process(self, entry):
"""
Fills data set
"""
#
# == getting the next entry from the tree
#
if self.GetEntry(entry) <= 0:
return 0 # RETURN
# if 0 == self._events % 100 :
if not self._progress:
self._progress = ProgressBar(0,
self.fChain.GetEntries(),
77,
mode='fixed')
self._progress.increment_amount()
print self._progress, '\r',
self._events += 1
#
# == for more convenience
#
bamboo = self.fChain
#
# J/psi acceptance
if not 12 > bamboo.pt_psi:
return 0
if not 2.0 < bamboo. y_psi <= 4.5:
return 0
#
# "good" J/psi
if not 1 == bamboo.good_psi:
return 0 # Good J/psi
#
# apply cuts
if not self . _cuts(bamboo):
return 0
# calculate & store the efficiency weight
w = self._weight(bamboo)
self._counter += 0 != w
if 0 == w:
return 0 # skip invalid weights
self.weight . setVal(w)
self.m_2c . setVal(bamboo.m_2c)
m1 = getattr(bamboo, 'm_' + self._jvar)
m2 = getattr(bamboo, 'm_' + self._dvar)
self.m_psi . setVal(m1)
self.pt_psi . setVal(getattr(bamboo, 'pt_' + self._jvar))
self.y_psi . setVal(getattr(bamboo, 'y_' + self._jvar))
self.lv01_psi . setVal(getattr(bamboo, 'lv01_' + self._jvar))
self.chi2dtf . setVal(bamboo.dtf_2c)
self.m_D . setVal(m2)
self.pt_D . setVal(getattr(bamboo, 'pt_' + self._dvar))
self.y_D . setVal(getattr(bamboo, 'y_' + self._dvar))
self.dphi . setVal(dphi(bamboo, self._jvar, self._dvar))
# GEC
self.nPV . setVal(bamboo.nPV_rec)
self.nSpd . setVal(bamboo.nSpd_gec)
self.nBest . setVal(bamboo.nBest_rec)
self.nLong . setVal(bamboo.nLong_rec)
self.nOT . setVal(bamboo.nOT_gec)
self.data .add(self.varset)
if self.slices_raw:
self.slices_raw.fill(m1, m2)
if self.slices_cor:
self.slices_cor.fill(m1, m2, w)
return 1
def Process(self, entry):
"""
Fills data set
"""
#
# == getting the next entry from the tree
#
if self.GetEntry(entry) <= 0:
return 0 # RETURN
self._events += 1
# if 0 == self._events % 1000 :
# print self._events
if not self._progress:
self._progress = ProgressBar(0,
self.fChain.GetEntries(),
77,
mode='fixed')
self._progress.increment_amount()
print self._progress, '\r',
#
# == for more convenience
#
bamboo = self.fChain
#
# apply cuts
if not self . _cuts(bamboo):
return 0
# calculate & store the efficiency weight
w = self._weight(bamboo)
self._counter += 0 != w
if 0 == w:
return 0 # skip invalid weights
self.weight . setVal(w)
self.m_2c . setVal(bamboo.m_2c)
m1 = getattr(bamboo, 'm_' + self._d1)
self.m_D1 . setVal(m1)
self.pt_D1 . setVal(getattr(bamboo, 'pt_' + self._d1))
self.y_D1 . setVal(getattr(bamboo, 'y_' + self._d1))
m2 = getattr(bamboo, 'm_' + self._d2)
self.m_D2 . setVal(m2)
self.pt_D2 . setVal(getattr(bamboo, 'pt_' + self._d2))
self.y_D2 . setVal(getattr(bamboo, 'y_' + self._d2))
self.chi2dtf . setVal(bamboo.dtf_2c)
self.dphi . setVal(dphi(bamboo, self._d1, self._d2))
pid1 = getattr(bamboo, 'pid_' + self._d1)
pid2 = getattr(bamboo, 'pid_' + self._d2)
ccbar = pid1 * pid2 < 0
data = self.data1 if ccbar else self.data2
# GEC
self.nPV . setVal(bamboo.nPV_rec)
self.nSpd . setVal(bamboo.nSpd_gec)
self.nBest . setVal(bamboo.nBest_rec)
self.nLong . setVal(bamboo.nLong_rec)
self.nOT . setVal(bamboo.nOT_gec)
data .add(self.varset)
if self.slices_raw:
if ccbar:
self.slices_raw[0].fill(m1, m2)
else:
self.slices_raw[1].fill(m1, m2)
if self.slices_cor:
if ccbar:
self.slices_cor[0].fill(m1, m2, w)
else:
self.slices_cor[1].fill(m1, m2, w)
return 1
class DD(Selector):
"""
Create and fill the basic dataset for RooFit
"""
def __init__(self,
cuts,
d1var,
d2var,
weight,
h1=None,
h2=None,
h3=None,
h4=None):
Selector.__init__(self, None, self) # initialize the base
self._cuts = cuts
self._weight = weight
self.m_2c = ROOT.RooRealVar("m_2c", "mass(DD)", 3.0, 100)
self.chi2dtf = ROOT.RooRealVar(
"chi2dtf", "chi2(dtf)/ndf", 0, 1.e+100)
self._d1 = d1var[0]
self.m_D1 = ROOT.RooRealVar(
"m_" + d1var[0], "mass(%s)" % d1var[0], d1var[1], d1var[2])
self.pt_D1 = ROOT.RooRealVar(
"pt_" + d1var[0], "pt(%s)" % d1var[0], 2.0, 12.0)
self.y_D1 = ROOT.RooRealVar(
"y_" + d1var[0], "y(%s)" % d1var[0], 2.0, 4.5)
self._d2 = d2var[0]
self.m_D2 = ROOT.RooRealVar(
"m_" + d2var[0], "mass(%s)" % d2var[0], d2var[1], d2var[2])
self.pt_D2 = ROOT.RooRealVar(
"pt_" + d2var[0], "pt(%s)" % d2var[0], 2.0, 12.0)
self.y_D2 = ROOT.RooRealVar(
"y_" + d2var[0], "y(%s)" % d2var[0], 2.0, 4.5)
self.weight = ROOT.RooRealVar(
"weight", "efficiency-weight", 0.0, 1.e+20)
self.dphi = ROOT.RooRealVar("dphi", "|delta(phi)|/pi", 0.0, 1.0)
self.varset = ROOT.RooArgSet(
#
self.m_2c,
self.m_D1,
self.pt_D1,
self.y_D1,
#
self.m_D2,
self.pt_D2,
self.y_D2,
#
# efficiency weight
self.weight,
)
self.varset.add(self.dphi)
self.varset.add(self.chi2dtf)
self.nPV = ROOT.RooRealVar("nPV", 'n(PV)', 0, 20)
self.nSpd = ROOT.RooRealVar("nSpd", 'n(Spd)', 0, 20000)
self.nBest = ROOT.RooRealVar("nBest", 'n(Best)', 0, 5000)
self.nLong = ROOT.RooRealVar("nLong", 'n(Long)', 0, 5000)
self.nOT = ROOT.RooRealVar("nOT", 'n(OT)', 0, 50000)
self.varset.add(self.nPV)
self.varset.add(self.nSpd)
self.varset.add(self.nBest)
self.varset.add(self.nLong)
self.varset.add(self.nOT)
self.data1 = ROOT.RooDataSet(
"DDbar",
"D & anti-Charm",
self.varset)
self.data2 = ROOT.RooDataSet(
"DD",
"D & Charm",
self.varset)
#
# prepare the structure for slice fits:
# fill histos only in case both histo templates are supplied
self.slices_raw = None
self.slices_cor = None
if h1 and h2:
self.slices_raw = (Slices(h1, h2), Slices(h1, h2))
if h3 and h4:
self.slices_cor = (Slices(h3, h4), Slices(h3, h4))
self._events = 0
self._counter = SE()
self._progress = None
#
def dataset(self):
return self.data1, self.data2
# the only one important method
def Process(self, entry):
"""
Fills data set
"""
#
# == getting the next entry from the tree
#
if self.GetEntry(entry) <= 0:
return 0 # RETURN
self._events += 1
# if 0 == self._events % 1000 :
# print self._events
if not self._progress:
self._progress = ProgressBar(0,
self.fChain.GetEntries(),
77,
mode='fixed')
self._progress.increment_amount()
print self._progress, '\r',
#
# == for more convenience
#
bamboo = self.fChain
#
# apply cuts
if not self . _cuts(bamboo):
return 0
# calculate & store the efficiency weight
w = self._weight(bamboo)
self._counter += 0 != w
if 0 == w:
return 0 # skip invalid weights
self.weight . setVal(w)
self.m_2c . setVal(bamboo.m_2c)
m1 = getattr(bamboo, 'm_' + self._d1)
self.m_D1 . setVal(m1)
self.pt_D1 . setVal(getattr(bamboo, 'pt_' + self._d1))
self.y_D1 . setVal(getattr(bamboo, 'y_' + self._d1))
m2 = getattr(bamboo, 'm_' + self._d2)
self.m_D2 . setVal(m2)
self.pt_D2 . setVal(getattr(bamboo, 'pt_' + self._d2))
self.y_D2 . setVal(getattr(bamboo, 'y_' + self._d2))
self.chi2dtf . setVal(bamboo.dtf_2c)
self.dphi . setVal(dphi(bamboo, self._d1, self._d2))
pid1 = getattr(bamboo, 'pid_' + self._d1)
pid2 = getattr(bamboo, 'pid_' + self._d2)
ccbar = pid1 * pid2 < 0
data = self.data1 if ccbar else self.data2
# GEC
self.nPV . setVal(bamboo.nPV_rec)
self.nSpd . setVal(bamboo.nSpd_gec)
self.nBest . setVal(bamboo.nBest_rec)
self.nLong . setVal(bamboo.nLong_rec)
self.nOT . setVal(bamboo.nOT_gec)
data .add(self.varset)
if self.slices_raw:
if ccbar:
self.slices_raw[0].fill(m1, m2)
else:
self.slices_raw[1].fill(m1, m2)
if self.slices_cor:
if ccbar:
self.slices_cor[0].fill(m1, m2, w)
else:
self.slices_cor[1].fill(m1, m2, w)
return 1
def Process(self, entry):
"""
Fills data set
"""
#
# == getting the next entry from the tree
#
if self.GetEntry(entry) <= 0:
return 0 # RETURN
# if 0 == self._events % 100 :
if not self._progress:
self._progress = ProgressBar(0,
self.fChain.GetEntries(),
77,
mode='fixed')
self._progress.increment_amount()
print self._progress, '\r',
self._events += 1
#
# == for more convenience
#
bamboo = self.fChain
#
# J/psi acceptance
if not 12 > bamboo.pt_psi:
return 0
if not 2.0 < bamboo. y_psi <= 4.5:
return 0
#
# "good" J/psi
if not 1 == bamboo.good_psi:
return 0 # Good J/psi
#
# apply cuts
if not self . _cuts(bamboo):
return 0
# calculate & store the efficiency weight
w = self._weight(bamboo)
self._counter += 0 != w
if 0 == w:
return 0 # skip invalid weights
self.weight . setVal(w)
self.m_2c . setVal(bamboo.m_2c)
m1 = getattr(bamboo, 'm_' + self._jvar)
m2 = getattr(bamboo, 'm_' + self._dvar)
self.m_psi . setVal(m1)
self.pt_psi . setVal(getattr(bamboo, 'pt_' + self._jvar))
self.y_psi . setVal(getattr(bamboo, 'y_' + self._jvar))
self.lv01_psi . setVal(getattr(bamboo, 'lv01_' + self._jvar))
self.chi2dtf . setVal(bamboo.dtf_2c)
self.m_D . setVal(m2)
self.pt_D . setVal(getattr(bamboo, 'pt_' + self._dvar))
self.y_D . setVal(getattr(bamboo, 'y_' + self._dvar))
self.dphi . setVal(dphi(bamboo, self._jvar, self._dvar))
# GEC
self.nPV . setVal(bamboo.nPV_rec)
self.nSpd . setVal(bamboo.nSpd_gec)
self.nBest . setVal(bamboo.nBest_rec)
self.nLong . setVal(bamboo.nLong_rec)
self.nOT . setVal(bamboo.nOT_gec)
self.data .add(self.varset)
if self.slices_raw:
self.slices_raw.fill(m1, m2)
if self.slices_cor:
self.slices_cor.fill(m1, m2, w)
return 1
