def SFB_Lookup(self, Y,HF ):
weightSFb,weightSFb_down,weightSFb_up = 1.0,1.0,1.0
#print [weightSFb,weightSFb_down,weightSFb_up]
ptminsfb = [100.0,140.0,200.0,300.0,600.0,]
ptmaxsfb = [140.0,200.0,300.0,600.0,1000.0,]
if HF==5:
SFb = TFormula("SFb","0.887973*((1.+(0.0523821*x))/(1.+(0.0460876*x)))")
SFb_down = [
TFormula("SFb_down_1","(0.887973*((1.+(0.0523821*x))/(1.+(0.0460876*x))))-0.010811596177518368"),
TFormula("SFb_down_2","(0.887973*((1.+(0.0523821*x))/(1.+(0.0460876*x))))-0.010882497765123844"),
TFormula("SFb_down_3","(0.887973*((1.+(0.0523821*x))/(1.+(0.0460876*x))))-0.013456921093165874"),
TFormula("SFb_down_4","(0.887973*((1.+(0.0523821*x))/(1.+(0.0460876*x))))-0.017094610258936882"),
TFormula("SFb_down_5","(0.887973*((1.+(0.0523821*x))/(1.+(0.0460876*x))))-0.02186630479991436")
]
SFb_up = [
TFormula("SFb_up_1","(0.887973*((1.+(0.0523821*x))/(1.+(0.0460876*x))))+0.010811596177518368"),
TFormula("SFb_up_2","(0.887973*((1.+(0.0523821*x))/(1.+(0.0460876*x))))+0.010882497765123844"),
TFormula("SFb_up_3","(0.887973*((1.+(0.0523821*x))/(1.+(0.0460876*x))))+0.013456921093165874"),
TFormula("SFb_up_4","(0.887973*((1.+(0.0523821*x))/(1.+(0.0460876*x))))+0.017094610258936882"),
TFormula("SFb_up_5","(0.887973*((1.+(0.0523821*x))/(1.+(0.0460876*x))))+0.02186630479991436")
]
elif HF==4:
SFb = TFormula("SFb","0.887973*((1.+(0.0523821*x))/(1.+(0.0460876*x)))")
SFb_down = [
TFormula("SFb_down_1","(0.887973*((1.+(0.0523821*x))/(1.+(0.0460876*x))))-0.027028990909457207"),
TFormula("SFb_down_2","(0.887973*((1.+(0.0523821*x))/(1.+(0.0460876*x))))-0.027206243947148323"),
TFormula("SFb_down_3","(0.887973*((1.+(0.0523821*x))/(1.+(0.0460876*x))))-0.033642303198575974"),
TFormula("SFb_down_4","(0.887973*((1.+(0.0523821*x))/(1.+(0.0460876*x))))-0.04273652657866478"),
TFormula("SFb_down_5","(0.887973*((1.+(0.0523821*x))/(1.+(0.0460876*x))))-0.054665762931108475")
]
SFb_up = [
TFormula("SFb_up_1","(0.887973*((1.+(0.0523821*x))/(1.+(0.0460876*x))))+0.027028990909457207"),
TFormula("SFb_up_2","(0.887973*((1.+(0.0523821*x))/(1.+(0.0460876*x))))+0.027206243947148323"),
TFormula("SFb_up_3","(0.887973*((1.+(0.0523821*x))/(1.+(0.0460876*x))))+0.033642303198575974"),
TFormula("SFb_up_4","(0.887973*((1.+(0.0523821*x))/(1.+(0.0460876*x))))+0.04273652657866478"),
TFormula("SFb_up_5","(0.887973*((1.+(0.0523821*x))/(1.+(0.0460876*x))))+0.054665762931108475")
]
else:
SFb = TFormula("SFb","1.13904+-0.000594946*x+1.97303e-06*x*x+-1.38194e-09*x*x*x")
SFb_down = [
TFormula("SFb_down_1","(1.13904+-0.000594946*x+1.97303e-06*x*x+-1.38194e-09*x*x*x)*(1-(0.0996438+-8.33354e-05*x+4.74359e-08*x*x))"),
TFormula("SFb_down_2","(1.13904+-0.000594946*x+1.97303e-06*x*x+-1.38194e-09*x*x*x)*(1-(0.0996438+-8.33354e-05*x+4.74359e-08*x*x))"),
TFormula("SFb_down_3","(1.13904+-0.000594946*x+1.97303e-06*x*x+-1.38194e-09*x*x*x)*(1-(0.0996438+-8.33354e-05*x+4.74359e-08*x*x))"),
TFormula("SFb_down_4","(1.13904+-0.000594946*x+1.97303e-06*x*x+-1.38194e-09*x*x*x)*(1-(0.0996438+-8.33354e-05*x+4.74359e-08*x*x))"),
TFormula("SFb_down_5","(1.13904+-0.000594946*x+1.97303e-06*x*x+-1.38194e-09*x*x*x)*(1-(0.0996438+-8.33354e-05*x+4.74359e-08*x*x))")
]
SFb_up = [
TFormula("SFb_up_1","(1.13904+-0.000594946*x+1.97303e-06*x*x+-1.38194e-09*x*x*x)*(1+(0.0996438+-8.33354e-05*x+4.74359e-08*x*x))"),
TFormula("SFb_up_2","(1.13904+-0.000594946*x+1.97303e-06*x*x+-1.38194e-09*x*x*x)*(1+(0.0996438+-8.33354e-05*x+4.74359e-08*x*x))"),
#
# To see the graphics output of this macro, click begin_html <a href="gif/formula1.gif">here</a>. end_html
#
from ROOT import TCanvas, TFormula, TF1
from ROOT import gROOT, gObjectTable
c1 = TCanvas('c1', 'Example with Formula', 200, 10, 700, 500)
# We create a formula object and compute the value of this formula
# for two different values of the x variable.
form1 = TFormula('form1', 'sqrt(abs(x))')
form1.Eval(2)
form1.Eval(-45)
# Create a one dimensional function and draw it
fun1 = TF1('fun1', 'abs(sin(x)/x)', 0, 10)
c1.SetGridx()
c1.SetGridy()
fun1.Draw()
c1.Update()
# Before leaving this demo, we print the list of objects known to ROOT
#
if (gObjectTable):
gObjectTable.Print()
def test_evaluate():
# create functions and histograms
f1 = TF1("f1", "x")
f2 = TF2("f2", "x*y")
f3 = TF3("f3", "x*y*z")
h1 = TH1D("h1", "", 10, 0, 1)
h1.FillRandom("f1")
h2 = TH2D("h2", "", 10, 0, 1, 10, 0, 1)
h2.FillRandom("f2")
h3 = TH3D("h3", "", 10, 0, 1, 10, 0, 1, 10, 0, 1)
h3.FillRandom("f3")
# generate random arrays
arr_1d = np.random.rand(5)
arr_2d = np.random.rand(5, 2)
arr_3d = np.random.rand(5, 3)
arr_4d = np.random.rand(5, 4)
# evaluate the functions
assert_array_equal(rnp.evaluate(f1, arr_1d), map(f1.Eval, arr_1d))
assert_array_equal(rnp.evaluate(f1.GetTitle(), arr_1d),
map(f1.Eval, arr_1d))
assert_array_equal(rnp.evaluate(f2, arr_2d),
[f2.Eval(*x) for x in arr_2d])
assert_array_equal(rnp.evaluate(f2.GetTitle(), arr_2d),
[f2.Eval(*x) for x in arr_2d])
assert_array_equal(rnp.evaluate(f3, arr_3d),
[f3.Eval(*x) for x in arr_3d])
assert_array_equal(rnp.evaluate(f3.GetTitle(), arr_3d),
[f3.Eval(*x) for x in arr_3d])
# 4d formula
f4 = TFormula('test', 'x*y+z*t')
assert_array_equal(rnp.evaluate(f4, arr_4d),
[f4.Eval(*x) for x in arr_4d])
# evaluate the histograms
assert_array_equal(rnp.evaluate(h1, arr_1d),
[h1.GetBinContent(h1.FindBin(x)) for x in arr_1d])
assert_array_equal(rnp.evaluate(h2, arr_2d),
[h2.GetBinContent(h2.FindBin(*x)) for x in arr_2d])
assert_array_equal(rnp.evaluate(h3, arr_3d),
[h3.GetBinContent(h3.FindBin(*x)) for x in arr_3d])
# create a graph
g = TGraph(2)
g.SetPoint(0, 0, 1)
g.SetPoint(1, 1, 2)
assert_array_equal(rnp.evaluate(g, [0, .5, 1]), [1, 1.5, 2])
from ROOT import TSpline3
s = TSpline3("spline", g)
assert_array_equal(rnp.evaluate(s, [0, .5, 1]), map(s.Eval, [0, .5, 1]))
# test exceptions
assert_raises(TypeError, rnp.evaluate, object(), [1, 2, 3])
assert_raises(ValueError, rnp.evaluate, h1, arr_2d)
assert_raises(ValueError, rnp.evaluate, h2, arr_3d)
assert_raises(ValueError, rnp.evaluate, h2, arr_1d)
assert_raises(ValueError, rnp.evaluate, h3, arr_1d)
assert_raises(ValueError, rnp.evaluate, h3, arr_2d)
assert_raises(ValueError, rnp.evaluate, f1, arr_2d)
assert_raises(ValueError, rnp.evaluate, f2, arr_3d)
assert_raises(ValueError, rnp.evaluate, f2, arr_1d)
assert_raises(ValueError, rnp.evaluate, f3, arr_1d)
assert_raises(ValueError, rnp.evaluate, f3, arr_2d)
assert_raises(ValueError, rnp.evaluate, g, arr_2d)
assert_raises(ValueError, rnp.evaluate, s, arr_2d)
assert_raises(ValueError, rnp.evaluate, "f", arr_1d)
assert_raises(ValueError, rnp.evaluate, "x*y", arr_1d)
assert_raises(ValueError, rnp.evaluate, "x", arr_2d)
assert_raises(ValueError, rnp.evaluate, "x*y", arr_3d)
class CutFlow:
def __init__(self, dataset, selection, lumi, main):
self.dataset = dataset
self.selection = selection
self.lumi = lumi
self.main = main
self.Ntotal = 0
self.Nselected = []
self.Nrejected = []
self.eff = []
self.effcumu = []
self.formulaSBratio()
def formulaSBratio(self):
from ROOT import TFormula
text = self.main.SBratio
text = text.replace("S", "x")
text = text.replace("B", "y")
self.Mformula = TFormula("SBratio", text)
text = self.main.SBerror
text = text.replace("ES", "z")
text = text.replace("EB", "t")
text = text.replace("S", "x")
text = text.replace("B", "y")
self.Eformula = TFormula("SBerror", text)
def calculateBSratio(self, B, eB, S, eS):
value = Measure()
value.mean = self.Mformula.Eval(S, B)
value.error = self.Eformula.Eval(S, B, eS, eB)
return value
@staticmethod
def binomialNEventError(k, N):
if N == 0:
return 0.
else:
return sqrt(float(k * abs(N - k)) / float(N))
@staticmethod
def binomialError(k, N):
if N == 0:
return 0.
else:
return sqrt(float(k * abs(N - k)) / float(N * N * N))
def initializeFromCutflow(self, cutflows):
# Ntotal
self.Ntotal = Measure()
for item in cutflows:
self.Ntotal.mean += item.Ntotal.mean
self.Ntotal.error += item.Ntotal.error**2
self.Ntotal.error = sqrt(self.Ntotal.error)
# Prepare vectors
for i in range(0, len(cutflows[0].Nselected)):
self.Nselected.append(Measure())
self.Nrejected.append(Measure())
self.eff.append(Measure())
self.effcumu.append(Measure())
# Fill selected and rejected
for iset in range(0, len(cutflows)):
for icut in range(0, len(cutflows[iset].Nselected)):
self.Nselected[icut].mean += cutflows[iset].Nselected[
icut].mean
self.Nrejected[icut].mean += cutflows[iset].Nrejected[
icut].mean
self.Nselected[icut].error += cutflows[iset].Nselected[
icut].error**2
self.Nrejected[icut].error += cutflows[iset].Nrejected[
icut].error**2
self.Nselected[icut].error = sqrt(self.Nselected[icut].error)
self.Nrejected[icut].error = sqrt(self.Nrejected[icut].error)
# Compute efficiencies
for i in range(0, len(self.eff)):
if self.Ntotal.mean != 0:
self.effcumu[i].mean = float(self.Nselected[i].mean) / float(
self.Ntotal.mean)
self.effcumu[i].error = CutFlow.binomialError(
self.Nselected[i].mean, self.Ntotal.mean)
if i == 0:
if self.Ntotal.mean != 0:
self.eff[i].mean = float(self.Nselected[i].mean) / float(
self.Ntotal.mean)
self.eff[i].error = CutFlow.binomialError(
self.Nselected[i].mean, self.Ntotal.mean)
else:
if self.Nselected[i - 1].mean != 0:
self.eff[i].mean = float(self.Nselected[i].mean) / float(
self.Nselected[i - 1].mean)
self.eff[i].error = CutFlow.binomialError(
self.Nselected[i].mean, self.Nselected[i - 1].mean)
def initializeFromFile(self, file):
# Getting cuts from ROOT file
cut = file.Get("cuts/cuts", "TVectorT<float>")
if cut is None:
return False
# Preparing architecture for vectors
self.Ntotal = Measure()
for iabscut in range(0, len(self.selection)):
if self.selection[iabscut].__class__.__name__ != "Cut":
continue
self.Nselected.append(Measure())
self.Nrejected.append(Measure())
self.eff.append(Measure())
self.effcumu.append(Measure())
# Extracting Nselected information
for icut in range(0, len(self.Nselected)):
self.Nselected[icut].mean = cut[icut]
# Extracting Ntotal
self.Ntotal.mean = self.dataset.measured_n
return True
def calculate(self):
# Calculating Nrejected
for icut in range(0, len(self.Nselected)):
if icut == 0:
self.Nrejected[
icut].mean = self.Ntotal.mean - self.Nselected[icut].mean
else:
self.Nrejected[icut].mean = self.Nselected[
icut - 1].mean - self.Nselected[icut].mean
# Calculating errors on Naccepted and Nrejected
for icut in range(0, len(self.Nselected)):
if icut == 0:
self.Nselected[icut].error = CutFlow.binomialNEventError(
self.Nselected[icut].mean, self.Ntotal.mean)
self.Nrejected[icut].error = CutFlow.binomialNEventError(
self.Nrejected[icut].mean, self.Ntotal.mean)
else:
self.Nselected[icut].error = CutFlow.binomialNEventError(
self.Nselected[icut].mean, self.Ntotal.mean)
self.Nrejected[icut].error = CutFlow.binomialNEventError(
self.Nrejected[icut].mean, self.Ntotal.mean)
# efficiency calculation and its error
for icut in range(0, len(self.Nselected)):
if icut == 0:
if self.Ntotal.mean == 0:
self.eff[icut].mean = 0
else:
self.eff[icut].mean = float(self.Nselected[icut].mean) / \
float(self.Ntotal.mean)
self.eff[icut].error = CutFlow.binomialError(
self.Nselected[icut].mean, self.Ntotal.mean)
else:
if self.Nselected[icut - 1].mean == 0:
self.eff[icut].mean = 0
else:
self.eff[icut].mean = float(self.Nselected[icut].mean) / \
float(self.Nselected[icut-1].mean)
self.eff[icut].error = CutFlow.binomialError(
self.Nselected[icut].mean, self.Nselected[icut - 1].mean)
if self.Ntotal.mean == 0:
self.effcumu[icut].mean = 0
else:
self.effcumu[icut].mean = float(self.Nselected[icut].mean) / \
float(self.Ntotal.mean)
self.effcumu[icut].error = CutFlow.binomialError(
self.Nselected[icut].mean, self.Ntotal.mean)
# Getting xsection
xsection = self.dataset.measured_xsection
xerror = self.dataset.measured_xerror
if self.dataset.xsection != 0.:
xsection = self.dataset.xsection
xerror = 0
# Saving ntotal
ntot = 0. + self.Ntotal.mean
# Scaling Ntotal
if self.main.normalize == NormalizeType.LUMI:
self.Ntotal.error = xerror * self.lumi * 1000
self.Ntotal.mean = xsection * self.lumi * 1000
elif self.main.normalize == NormalizeType.LUMI_WEIGHT:
self.Ntotal.error = xerror * self.lumi * 1000 * \
self.dataset.weight
self.Ntotal.mean = xsection * self.lumi * 1000 * \
self.dataset.weight
# Scaling Nselected
for icut in range(0, len(self.Nselected)):
if self.main.normalize == NormalizeType.LUMI:
# error due to xsec
errXsec = xerror * self.lumi * 1000 * self.Nselected[
icut].mean / ntot
# scale factor
factor = xsection * self.lumi * 1000 / ntot
self.Nselected[icut].mean *= factor
self.Nselected[icut].error = CutFlow.binomialNEventError(
self.Nselected[icut].mean, self.Ntotal.mean)
# compute final error
self.Nselected[icut].error = sqrt(\
self.Nselected[icut].error**2 + errXsec**2)
elif self.main.normalize == NormalizeType.LUMI_WEIGHT:
# error due to xsec
errXsec = xerror * self.lumi * 1000 * self.dataset.weight * self.Nselected[
icut].mean / ntot
# scale factor
factor = xsection * self.lumi * self.dataset.weight * 1000 / ntot
self.Nselected[icut].mean *= factor
self.Nselected[icut].error = CutFlow.binomialNEventError(
self.Nselected[icut].mean, self.Ntotal.mean)
# compute final error
self.Nselected[icut].error = sqrt(\
self.Nselected[icut].error**2 + errXsec**2)
# Scaling Nrejected
for icut in range(0, len(self.Nrejected)):
if self.main.normalize == NormalizeType.LUMI:
# error due to xsec
errXsec = xerror * self.lumi * 1000 * self.Nrejected[
icut].mean / ntot
# scale factor
factor = xsection * self.lumi * 1000 / ntot
self.Nrejected[icut].mean *= factor
self.Nrejected[icut].error = CutFlow.binomialNEventError(
self.Nrejected[icut].mean, self.Ntotal.mean)
# compute final error
self.Nrejected[icut].error = sqrt(\
self.Nrejected[icut].error**2 + errXsec**2)
elif self.main.normalize == NormalizeType.LUMI_WEIGHT:
# error due to xsec
errXsec = xerror * self.lumi * 1000 * self.dataset.weight * self.Nrejected[
icut].mean / ntot
# scale factor
factor = xsection * self.lumi * self.dataset.weight * 1000 / ntot
self.Nrejected[icut].mean *= factor
self.Nrejected[icut].error = CutFlow.binomialNEventError(
self.Nrejected[icut].mean, self.Ntotal.mean)
# compute final error
self.Nrejected[icut].error = sqrt(\
self.Nrejected[icut].error**2 + errXsec**2)
