def test_set_values_from_intervals(self):
'''Test behavior of Uncertainy.test_set_values_from_intervals function'''
# Dummy central values and variatons relative to central value
npoints = 100
values = list(range(0, npoints, 1))
uncertainty = [(-random.uniform(0, 1), random.uniform(0, 1)) for _ in range(100)]
# Convert +- error to interval bounds
intervals = [(val + unc_minus, val + unc_plus)
for val, (unc_minus, unc_plus) in zip(values, uncertainty)]
# Reference uses "normal" assignment
refunc = Uncertainty("reference_unc")
refunc.is_symmetric = False
refunc.values = uncertainty
# Test uses new function
testunc = Uncertainty("test_unc")
testunc.is_symmetric = False
testunc.set_values_from_intervals(intervals, nominal=values)
# Check that both agree
self.assertTrue(all((test_utilities.tuple_compare(tup1, tup2) \
for tup1, tup2 in zip(testunc.values, refunc.values))))
def test_scale_values(self):
'''Test behavior of Uncertainty.scale_values function'''
values = list(range(0, 300, 1))
uncertainty = [x + random.uniform(0, 2) for x in values]
testvar = Variable("testvar")
testvar.is_binned = False
testvar.units = "GeV"
testvar.values = values
testunc = Uncertainty("testunc")
testunc.is_symmetric = True
testunc.values = uncertainty
testvar.uncertainties.append(testunc)
assert testvar.values == values
self.assertTrue(testunc.values == uncertainty)
for factor in [random.uniform(0, 10000) for x in range(100)]:
# Check that scaling works
testvar.scale_values(factor)
scaled_values = [factor * x for x in values]
scaled_uncertainty = [factor * x for x in uncertainty]
self.assertTrue(all(test_utilities.float_compare(x, y)
for x, y in zip(testvar.values, scaled_values)))
self.assertTrue(all(test_utilities.float_compare(x, y)
for x, y in zip(testunc.values, scaled_uncertainty)))
# Check that inverse also works
testvar.scale_values(1. / factor)
self.assertTrue(all(test_utilities.float_compare(x, y)
for x, y in zip(testvar.values, values)))
self.assertTrue(all(test_utilities.float_compare(x, y)
for x, y in zip(testunc.values, uncertainty)))
def test_make_dict(self):
"""Test the make_dict function."""
# pylint: disable=no-self-use
var = Variable("testvar")
# With or without units
for units in ["", "GeV"]:
var.units = units
# Binned
var.is_binned = False
var.values = [1, 2, 3]
var.make_dict()
# Unbinned
var.is_binned = True
var.values = [(0, 1), (1, 2), (2, 3)]
var.make_dict()
# With symmetric uncertainty
unc1 = Uncertainty("unc1")
unc1.is_symmetric = True
unc1.values = [random.random() for _ in range(len(var.values))]
var.add_uncertainty(unc1)
var.make_dict()
# With asymmetric uncertainty
unc2 = Uncertainty("unc2")
unc2.is_symmetric = False
unc2.values = [(-random.random(), random.random())
for _ in range(len(var.values))]
var.add_uncertainty(unc2)
var.make_dict()
# With qualifiers (which only apply to dependent variables)
var.is_independent = False
var.add_qualifier("testqualifier1", 1, units="GeV")
var.add_qualifier("testqualifier2", 1, units="")
var.make_dict()
def test_add_uncertainty(self):
'''Test behavior of Variable.add_uncertainty function'''
var = Variable("testvar")
var.is_binned = False
var.values = range(5)
# Normal behavior
unc = Uncertainty("testunc")
unc.is_symmetric = True
unc.values = [x * 0.1 for x in var.values]
var.add_uncertainty(unc)
self.assertTrue(len(var.uncertainties) == 1)
self.assertTrue(var.uncertainties[0] == unc)
# Reset variable but leave uncertainty as is
var.uncertainties = []
var.values = []
var.add_uncertainty(unc)
self.assertTrue(len(var.uncertainties) == 1)
self.assertTrue(var.uncertainties[0] == unc)
# Exception testing
var.values = range(5)
def wrong_input_type():
'''Call add_uncertainty with invalid input type.'''
var.add_uncertainty("this is not a proper input argument")
self.assertRaises(TypeError, wrong_input_type)
def wrong_input_properties():
'''Call add_uncertainty with invalid input properties.'''
unc2 = Uncertainty("testunc2")
unc2.is_symmetric = True
unc2.values = unc.values + [3]
var.add_uncertainty(unc2)
self.assertRaises(ValueError, wrong_input_properties)
def convertWJetsHistToYaml( rootfile, label, channel ):
tab = Table(label)
reader = RootFileReader(rootfile)
data = reader.read_hist_1d("dataAR")
# ttg = reader.read_hist_1d("TTG_centralall")
top = reader.read_hist_1d("Top_centralall")
dy = reader.read_hist_1d("DY_LO_centralall")
wjets = reader.read_hist_1d("WJets_centralall")
# wg = reader.read_hist_1d("WG_centralall")
# zg = reader.read_hist_1d("ZG_centralall")
other = reader.read_hist_1d("other_centralall")
qcd = reader.read_hist_1d("QCD")
uncUp = reader.read_hist_1d("totalUncertainty_up")
uncDown = reader.read_hist_1d("totalUncertainty_down")
rootfile = ROOT.TFile(rootfile,"READ")
statHist = rootfile.Get("dataAR")
unc = []
statunc = []
relunc = []
tot = []
for i, i_up in enumerate(uncUp["y"]):
stat = statHist.GetBinError(i+1)
u = abs(i_up-uncDown["y"][i])*0.5
# all = [ ttg["y"][i], top["y"][i], dy["y"][i], wjets["y"][i], wg["y"][i], zg["y"][i], other["y"][i], qcd["y"][i] ]
all = [ top["y"][i], dy["y"][i], wjets["y"][i], other["y"][i], qcd["y"][i] ]
sim = sum(all)
unc.append(u)
statunc.append(stat)
tot.append(sim)
relunc.append(u*100./sim)
xbins = Variable( "$m_{T}(W)$", is_independent=True, is_binned=True, units="GeV")
xbins.values = data["x_edges"]
ydata = Variable( "Observed", is_independent=False, is_binned=False)
ydata.values = data["y"]
ydata.add_qualifier("CHANNEL",channel)
ydata.add_qualifier("SQRT(S)","13","TeV")
ydata.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
ytot = Variable( "Total simulation", is_independent=False, is_binned=False)
ytot.values = tot
ytot.add_qualifier("CHANNEL",channel)
ytot.add_qualifier("SQRT(S)","13","TeV")
ytot.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
# yttg = Variable( "tt$\gamma$", is_independent=False, is_binned=False)
# yttg.values = ttg["y"]
# yttg.add_qualifier("CHANNEL",channel)
# yttg.add_qualifier("SQRT(S)","13","TeV")
# yttg.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
ytop = Variable( "t/tt", is_independent=False, is_binned=False)
ytop.values = top["y"]
ytop.add_qualifier("CHANNEL",channel)
ytop.add_qualifier("SQRT(S)","13","TeV")
ytop.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
ydy = Variable( "Drell-Yan", is_independent=False, is_binned=False)
ydy.values = dy["y"]
ydy.add_qualifier("CHANNEL",channel)
ydy.add_qualifier("SQRT(S)","13","TeV")
ydy.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
ywjets = Variable( "W+jets", is_independent=False, is_binned=False)
ywjets.values = wjets["y"]
ywjets.add_qualifier("CHANNEL",channel)
ywjets.add_qualifier("SQRT(S)","13","TeV")
ywjets.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
# ywg = Variable( "W$\gamma$", is_independent=False, is_binned=False)
# ywg.values = wg["y"]
# ywg.add_qualifier("CHANNEL",channel)
# ywg.add_qualifier("SQRT(S)","13","TeV")
# ywg.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
# yzg = Variable( "Z$\gamma$", is_independent=False, is_binned=False)
# yzg.values = zg["y"]
# yzg.add_qualifier("CHANNEL",channel)
# yzg.add_qualifier("SQRT(S)","13","TeV")
# yzg.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
yother = Variable( "Other", is_independent=False, is_binned=False)
yother.values = other["y"]
yother.add_qualifier("CHANNEL",channel)
yother.add_qualifier("SQRT(S)","13","TeV")
yother.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
yqcd = Variable( "Multijet", is_independent=False, is_binned=False)
yqcd.values = qcd["y"]
yqcd.add_qualifier("CHANNEL",channel)
yqcd.add_qualifier("SQRT(S)","13","TeV")
yqcd.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
# yunc = Variable( "Total systematic uncertainty", is_independent=False, is_binned=False)
# yunc.values = unc
# yunc.add_qualifier("SQRT(S)","13","TeV")
# yunc.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
#yrelunc = Variable( "Rel. uncertainty (%)", is_independent=False, is_binned=False)
#yrelunc.values = relunc
yunc = Uncertainty( "syst" )
yunc.is_symmetric = True
yunc.values = unc
ystatunc = Uncertainty( "stat" )
ystatunc.is_symmetric = True
ystatunc.values = statunc
ydata.uncertainties.append(ystatunc)
ytot.uncertainties.append(yunc)
tab.add_variable(xbins)
tab.add_variable(ydata)
tab.add_variable(ytot)
tab.add_variable(ywjets)
tab.add_variable(yqcd)
tab.add_variable(ydy)
tab.add_variable(ytop)
tab.add_variable(yother)
# tab.add_variable(ywg)
# tab.add_variable(yzg)
# tab.add_variable(yttg)
# tab.add_variable(yunc)
return tab
def convertEFTPtHistToYaml( rootfile, label, channel ):
tab = Table(label)
reader = RootFileReader(rootfile)
data = reader.read_hist_1d("data")
tot = reader.read_hist_1d("total")
totbkg = reader.read_hist_1d("total_background")
ttg = reader.read_hist_1d("signal")
misID = reader.read_hist_1d("misID")
had = reader.read_hist_1d("fakes")
other = reader.read_hist_1d("other")
wg = reader.read_hist_1d("WG")
qcd = reader.read_hist_1d("QCD")
zg = reader.read_hist_1d("ZG")
eftbf = reader.read_hist_1d("bestFit")
eftctZ045 = reader.read_hist_1d("ctZ0.45")
eftctZI045 = reader.read_hist_1d("ctZI0.45")
eftctZm045 = reader.read_hist_1d("ctZ-0.45")
rootfile = ROOT.TFile(rootfile,"READ")
totHist = rootfile.Get("total")
datHist = rootfile.Get("data")
unc = []
statunc = []
relunc = []
for i, i_tot in enumerate(tot["y"]):
u = totHist.GetBinError(i+1)
ustat = datHist.GetBinError(i+1)
unc.append(u)
statunc.append(ustat)
relunc.append(u*100./i_tot)
xbins = Variable( "$p_{T}(\gamma)$", is_independent=True, is_binned=True, units="GeV")
xbins.values = data["x_edges"]
ydata = Variable( "Observed", is_independent=False, is_binned=False)
ydata.values = data["y"]
ydata.add_qualifier("CHANNEL",channel)
ydata.add_qualifier("SQRT(S)","13","TeV")
ydata.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
ytot = Variable( "Total simulation", is_independent=False, is_binned=False)
ytot.values = tot["y"]
ytot.add_qualifier("CHANNEL",channel)
ytot.add_qualifier("SQRT(S)","13","TeV")
ytot.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
ytotbkg = Variable( "Total background", is_independent=False, is_binned=False)
ytotbkg.values = totbkg["y"]
ytotbkg.add_qualifier("CHANNEL",channel)
ytotbkg.add_qualifier("SQRT(S)","13","TeV")
ytotbkg.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
ywg = Variable( "$W\gamma$", is_independent=False, is_binned=False)
ywg.values = wg["y"]
ywg.add_qualifier("CHANNEL",channel)
ywg.add_qualifier("SQRT(S)","13","TeV")
ywg.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
yzg = Variable( "$Z\gamma$", is_independent=False, is_binned=False)
yzg.values = zg["y"]
yzg.add_qualifier("CHANNEL",channel)
yzg.add_qualifier("SQRT(S)","13","TeV")
yzg.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
ymisID = Variable( "Misid. e", is_independent=False, is_binned=False)
ymisID.values = misID["y"]
ymisID.add_qualifier("CHANNEL",channel)
ymisID.add_qualifier("SQRT(S)","13","TeV")
ymisID.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
yhad = Variable( "Hadronic $\gamma$", is_independent=False, is_binned=False)
yhad.values = had["y"]
yhad.add_qualifier("CHANNEL",channel)
yhad.add_qualifier("SQRT(S)","13","TeV")
yhad.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
yqcd = Variable( "Multijet", is_independent=False, is_binned=False)
yqcd.values = qcd["y"]
yqcd.add_qualifier("CHANNEL",channel)
yqcd.add_qualifier("SQRT(S)","13","TeV")
yqcd.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
yttg = Variable( "tt$\gamma$", is_independent=False, is_binned=False)
yttg.values = ttg["y"]
yttg.add_qualifier("CHANNEL",channel)
yttg.add_qualifier("SQRT(S)","13","TeV")
yttg.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
yother = Variable( "Other", is_independent=False, is_binned=False)
yother.values = other["y"]
yother.add_qualifier("CHANNEL",channel)
yother.add_qualifier("SQRT(S)","13","TeV")
yother.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
yeftbf = Variable( "SM-EFT best fit", is_independent=False, is_binned=False)
yeftbf.values = eftbf["y"]
yeftbf.add_qualifier("CHANNEL",channel)
yeftbf.add_qualifier("SQRT(S)","13","TeV")
yeftbf.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
yeftctZ045 = Variable( "$c_{tZ} = 0.45$", is_independent=False, is_binned=False, units="($\Lambda$/TeV)$^2$")
yeftctZ045.values = eftctZ045["y"]
yeftctZ045.add_qualifier("CHANNEL",channel)
yeftctZ045.add_qualifier("SQRT(S)","13","TeV")
yeftctZ045.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
yeftctZI045 = Variable( "$c^I_{tZ} = 0.45$", is_independent=False, is_binned=False, units="($\Lambda$/TeV)$^2$")
yeftctZI045.values = eftctZI045["y"]
yeftctZI045.add_qualifier("CHANNEL",channel)
yeftctZI045.add_qualifier("SQRT(S)","13","TeV")
yeftctZI045.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
yeftctZm045 = Variable( "$c_{tZ} = -0.45$", is_independent=False, is_binned=False, units="($\Lambda$/TeV)$^2$")
yeftctZm045.values = eftctZm045["y"]
yeftctZm045.add_qualifier("CHANNEL",channel)
yeftctZm045.add_qualifier("SQRT(S)","13","TeV")
yeftctZm045.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
yunc = Uncertainty( "syst" )
yunc.is_symmetric = True
yunc.values = unc
ystatunc = Uncertainty( "stat" )
ystatunc.is_symmetric = True
ystatunc.values = statunc
ydata.uncertainties.append(ystatunc)
ytot.uncertainties.append(yunc)
tab.add_variable(xbins)
tab.add_variable(ydata)
tab.add_variable(ytot)
tab.add_variable(yeftbf)
tab.add_variable(yeftctZ045)
tab.add_variable(yeftctZI045)
tab.add_variable(yeftctZm045)
tab.add_variable(ytotbkg)
tab.add_variable(yttg)
tab.add_variable(yhad)
tab.add_variable(ymisID)
tab.add_variable(yother)
tab.add_variable(ywg)
tab.add_variable(yqcd)
tab.add_variable(yzg)
return tab
def convertUnfoldingHistToYaml( rootfile, label, variable, unit ):
tab = Table(label)
reader = RootFileReader(rootfile)
data = reader.read_hist_1d("unfoled_spectrum")
simP8 = reader.read_hist_1d("fiducial_spectrum")
simHpp = reader.read_hist_1d("fiducial_spectrum_Hpp")
simH7 = reader.read_hist_1d("fiducial_spectrum_H7")
totalUncUp = reader.read_hist_1d("totalUncertainty_up")
mcstatUncUp = reader.read_hist_1d("mcStat_up")
matrixUncUp = reader.read_hist_1d("totalMatrixVariationUnc_up")
statUncUp = reader.read_hist_1d("stat_up")
totunc = []
reltotunc = []
statunc = []
relstatunc = []
for i, i_up in enumerate(totalUncUp["y"]):
tot = data["y"][i]
utot = (i_up - tot)**2
utot += (mcstatUncUp["y"][i] - tot)**2
utot += matrixUncUp["y"][i]**2
utot = sqrt(utot)
ustat = statUncUp["y"][i] - tot
totunc.append(utot)
statunc.append(ustat)
reltotunc.append(utot*100./tot)
relstatunc.append(ustat*100./tot)
xbins = Variable( variable, is_independent=True, is_binned=True, units=unit)
xbins.values = data["x_edges"]
ydata = Variable( "Observed", is_independent=False, is_binned=False)
ydata.values = data["y"]
ydata.add_qualifier("SQRT(S)","13","TeV")
ydata.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
yunc = Uncertainty( "total" )
yunc.is_symmetric = True
yunc.values = totunc
ystatunc = Uncertainty( "stat" )
ystatunc.is_symmetric = True
ystatunc.values = statunc
# ydata.uncertainties.append(ystatunc)
# ydata.uncertainties.append(yunc)
ysimP8 = Variable( "Simulation MG5_aMC + Pythia8", is_independent=False, is_binned=False)
ysimP8.values = simP8["y"]
ysimP8.add_qualifier("SQRT(S)","13","TeV")
ysimP8.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
ysimH7 = Variable( "Simulation MG5_aMC + Herwig7", is_independent=False, is_binned=False)
ysimH7.values = simH7["y"]
ysimH7.add_qualifier("SQRT(S)","13","TeV")
ysimH7.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
ysimHpp = Variable( "Simulation MG5_aMC + Herwig++", is_independent=False, is_binned=False)
ysimHpp.values = simHpp["y"]
ysimHpp.add_qualifier("SQRT(S)","13","TeV")
ysimHpp.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
tab.add_variable(xbins)
tab.add_variable(ydata)
tab.add_variable(ysimP8)
tab.add_variable(ysimH7)
tab.add_variable(ysimHpp)
return tab
def convertSRHistToYaml( rootfile, label, variable, unit ):
tab = Table(label)
reader = RootFileReader(rootfile)
data = reader.read_hist_1d("dataAR")
gen = reader.read_hist_1d("TTG_centralnoChgIsoNoSieiephotoncat0")
had = reader.read_hist_1d("TTG_centralnoChgIsoNoSieiephotoncat134")
misID = reader.read_hist_1d("TTG_centralnoChgIsoNoSieiephotoncat2")
qcd = reader.read_hist_1d("QCD")
uncUp = reader.read_hist_1d("totalUncertainty_up")
uncDown = reader.read_hist_1d("totalUncertainty_down")
rootfile = ROOT.TFile(rootfile,"READ")
statHist = rootfile.Get("dataAR")
unc = []
statunc = []
relunc = []
tot = []
for i, i_up in enumerate(uncUp["y"]):
stat = statHist.GetBinError(i+1)
u = abs(i_up-uncDown["y"][i])*0.5
sim = sum([ gen["y"][i], had["y"][i], misID["y"][i], qcd["y"][i] ])
unc.append(u)
statunc.append(stat)
tot.append(sim)
relunc.append(u*100./sim)
xbins = Variable( variable, is_independent=True, is_binned=True, units=unit)
xbins.values = data["x_edges"]
ydata = Variable( "Observed", is_independent=False, is_binned=False)
ydata.values = data["y"]
ydata.add_qualifier("CHANNEL","l+jets")
ydata.add_qualifier("SQRT(S)","13","TeV")
ydata.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
ytot = Variable( "Total simulation", is_independent=False, is_binned=False)
ytot.values = tot
ytot.add_qualifier("CHANNEL","l+jets")
ytot.add_qualifier("SQRT(S)","13","TeV")
ytot.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
ygen = Variable( "Genuine $\gamma$", is_independent=False, is_binned=False)
ygen.values = gen["y"]
ygen.add_qualifier("CHANNEL","l+jets")
ygen.add_qualifier("SQRT(S)","13","TeV")
ygen.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
yhad = Variable( "Hadronic $\gamma$", is_independent=False, is_binned=False)
yhad.values = had["y"]
yhad.add_qualifier("CHANNEL","l+jets")
yhad.add_qualifier("SQRT(S)","13","TeV")
yhad.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
ymisID = Variable( "Misid. e", is_independent=False, is_binned=False)
ymisID.values = misID["y"]
ymisID.add_qualifier("CHANNEL","l+jets")
ymisID.add_qualifier("SQRT(S)","13","TeV")
ymisID.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
yqcd = Variable( "Multijet", is_independent=False, is_binned=False)
yqcd.values = qcd["y"]
yqcd.add_qualifier("CHANNEL","l+jets")
yqcd.add_qualifier("SQRT(S)","13","TeV")
yqcd.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
yunc = Uncertainty( "syst" )
yunc.is_symmetric = True
yunc.values = unc
ystatunc = Uncertainty( "stat" )
ystatunc.is_symmetric = True
ystatunc.values = statunc
ydata.uncertainties.append(ystatunc)
ytot.uncertainties.append(yunc)
tab.add_variable(xbins)
tab.add_variable(ydata)
tab.add_variable(ytot)
tab.add_variable(ygen)
tab.add_variable(yhad)
tab.add_variable(ymisID)
tab.add_variable(yqcd)
return tab
def convertSRPlotToYaml():
tab = Table("Figure 6")
reader = RootFileReader("../regionPlots/SR_incl.root")
data = reader.read_hist_1d("0dc_2016data")
tot = reader.read_hist_1d("0dc_2016total")
totbkg = reader.read_hist_1d("0dc_2016total_background")
ttg = reader.read_hist_1d("0dc_2016signal")
misID = reader.read_hist_1d("0dc_2016misID")
had = reader.read_hist_1d("0dc_2016fakes")
other = reader.read_hist_1d("0dc_2016other")
wg = reader.read_hist_1d("0dc_2016WG")
qcd = reader.read_hist_1d("0dc_2016QCD")
zg = reader.read_hist_1d("0dc_2016ZG")
rootfile = ROOT.TFile("../regionPlots/SR_incl.root","READ")
totHist = rootfile.Get("0dc_2016total")
datHist = rootfile.Get("0dc_2016data")
unc = []
statunc = []
relunc = []
for i, i_tot in enumerate(tot["y"]):
u = totHist.GetBinError(i+1)
ustat = datHist.GetBinError(i+1)
unc.append(u)
statunc.append(ustat)
relunc.append(u*100./i_tot)
crBinLabel = [
"SR3, e, $M_{3}$ $<$ 280 GeV",
"SR3, e, 280 $\leq$ $M_{3}$ $<$ 420 GeV",
"SR3, e, $M_{3}$ $\geq$ 420 GeV",
"SR3, $\mu$, $M_{3}$ $<$ 280 GeV",
"SR3, $\mu$, 280 $\leq$ $M_{3}$ $<$ 420 GeV",
"SR3, $\mu$, $M_{3}$ $\geq$ 420 GeV",
"SR4p, e, $M_{3}$ $<$ 280 GeV",
"SR4p, e, 280 $\leq$ $M_{3}$ $<$ 420 GeV",
"SR4p, e, $M_{3}$ $\geq$ 420 GeV",
"SR4p, $\mu$, $M_{3}$ $<$ 280 GeV",
"SR4p, $\mu$, 280 $\leq$ $M_{3}$ $<$ 420 GeV",
"SR4p, $\mu$, $M_{3}$ $\geq$ 420 GeV",
]
xbins = Variable( "Bin", is_independent=True, is_binned=False)
xbins.values = crBinLabel
ydata = Variable( "Observed", is_independent=False, is_binned=False)
ydata.values = data["y"]
ydata.add_qualifier("SQRT(S)","13","TeV")
ydata.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
ytot = Variable( "Total simulation", is_independent=False, is_binned=False)
ytot.values = tot["y"]
ytot.add_qualifier("SQRT(S)","13","TeV")
ytot.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
ytotbkg = Variable( "Total background", is_independent=False, is_binned=False)
ytotbkg.values = totbkg["y"]
ytotbkg.add_qualifier("SQRT(S)","13","TeV")
ytotbkg.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
ywg = Variable( "$W\gamma$", is_independent=False, is_binned=False)
ywg.values = wg["y"]
ywg.add_qualifier("SQRT(S)","13","TeV")
ywg.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
yzg = Variable( "$Z\gamma$", is_independent=False, is_binned=False)
yzg.values = zg["y"]
yzg.add_qualifier("SQRT(S)","13","TeV")
yzg.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
ymisID = Variable( "Misid. e", is_independent=False, is_binned=False)
ymisID.values = misID["y"]
ymisID.add_qualifier("SQRT(S)","13","TeV")
ymisID.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
yhad = Variable( "Hadronic $\gamma$", is_independent=False, is_binned=False)
yhad.values = had["y"]
yhad.add_qualifier("SQRT(S)","13","TeV")
yhad.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
yqcd = Variable( "Multijet", is_independent=False, is_binned=False)
yqcd.values = qcd["y"]
yqcd.add_qualifier("SQRT(S)","13","TeV")
yqcd.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
yttg = Variable( "tt$\gamma$", is_independent=False, is_binned=False)
yttg.values = ttg["y"]
yttg.add_qualifier("SQRT(S)","13","TeV")
yttg.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
yother = Variable( "Other", is_independent=False, is_binned=False)
yother.values = other["y"]
yother.add_qualifier("SQRT(S)","13","TeV")
yother.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
# yunc = Variable( "Total uncertainty", is_independent=False, is_binned=False)
# yunc.values = unc
# yunc.add_qualifier("SQRT(S)","13","TeV")
# yunc.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
#yrelunc = Variable( "Rel. uncertainty (%)", is_independent=False, is_binned=False)
#yrelunc.values = relunc
yunc = Uncertainty( "syst" )
yunc.is_symmetric = True
yunc.values = unc
ystatunc = Uncertainty( "stat" )
ystatunc.is_symmetric = True
ystatunc.values = statunc
ydata.uncertainties.append(ystatunc)
ytot.uncertainties.append(yunc)
tab.add_variable(xbins)
tab.add_variable(ydata)
tab.add_variable(ytot)
tab.add_variable(ytotbkg)
tab.add_variable(yttg)
tab.add_variable(ymisID)
tab.add_variable(yhad)
tab.add_variable(yother)
tab.add_variable(ywg)
tab.add_variable(yqcd)
tab.add_variable(yzg)
# tab.add_variable(yunc)
return tab
def convertMlgHistToYaml( rootfile, label, variable, channel ):
tab = Table(label)
reader = RootFileReader(rootfile)
data = reader.read_hist_1d("dataAR")
misID = reader.read_hist_1d("TTG_centralnoChgIsoNoSieiephotoncat2")
wg = reader.read_hist_1d("WG_centralnoChgIsoNoSieiephotoncat0")
zg = reader.read_hist_1d("ZG_centralnoChgIsoNoSieiephotoncat0")
other = reader.read_hist_1d("TTG_centralnoChgIsoNoSieiephotoncat0")
had = reader.read_hist_1d("TTG_centralnoChgIsoNoSieiephotoncat134")
qcd = reader.read_hist_1d("QCD")
uncUp = reader.read_hist_1d("totalUncertainty_up")
uncDown = reader.read_hist_1d("totalUncertainty_down")
rootfile = ROOT.TFile(rootfile,"READ")
statHist = rootfile.Get("dataAR")
unc = []
statunc = []
relunc = []
tot = []
for i, i_up in enumerate(uncUp["y"]):
stat = statHist.GetBinError(i+1)
u = abs(i_up-uncDown["y"][i])*0.5
all = [ misID["y"][i], wg["y"][i], zg["y"][i], other["y"][i], had["y"][i], qcd["y"][i] ]
sim = sum(all)
unc.append(u)
statunc.append(stat)
tot.append(sim)
relunc.append(u*100./sim)
xbins = Variable( variable, is_independent=True, is_binned=True, units="GeV")
xbins.values = data["x_edges"]
ydata = Variable( "Observed", is_independent=False, is_binned=False)
ydata.values = data["y"]
ydata.add_qualifier("CHANNEL",channel)
ydata.add_qualifier("SQRT(S)","13","TeV")
ydata.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
ytot = Variable( "Total simulation", is_independent=False, is_binned=False)
ytot.values = tot
ytot.add_qualifier("CHANNEL",channel)
ytot.add_qualifier("SQRT(S)","13","TeV")
ytot.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
ymisID = Variable( "Misid. e", is_independent=False, is_binned=False)
ymisID.values = misID["y"]
ymisID.add_qualifier("CHANNEL",channel)
ymisID.add_qualifier("SQRT(S)","13","TeV")
ymisID.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
yhad = Variable( "Hadronic $\gamma$", is_independent=False, is_binned=False)
yhad.values = had["y"]
yhad.add_qualifier("CHANNEL",channel)
yhad.add_qualifier("SQRT(S)","13","TeV")
yhad.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
ywg = Variable( "W$\gamma$", is_independent=False, is_binned=False)
ywg.values = wg["y"]
ywg.add_qualifier("CHANNEL",channel)
ywg.add_qualifier("SQRT(S)","13","TeV")
ywg.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
yzg = Variable( "Z$\gamma$", is_independent=False, is_binned=False)
yzg.values = zg["y"]
yzg.add_qualifier("CHANNEL",channel)
yzg.add_qualifier("SQRT(S)","13","TeV")
yzg.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
yother = Variable( "Other", is_independent=False, is_binned=False)
yother.values = other["y"]
yother.add_qualifier("CHANNEL",channel)
yother.add_qualifier("SQRT(S)","13","TeV")
yother.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
yqcd = Variable( "Multijet", is_independent=False, is_binned=False)
yqcd.values = qcd["y"]
yqcd.add_qualifier("CHANNEL",channel)
yqcd.add_qualifier("SQRT(S)","13","TeV")
yqcd.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
# yunc = Variable( "Total systematic uncertainty", is_independent=False, is_binned=False)
# yunc.values = unc
# yunc.add_qualifier("SQRT(S)","13","TeV")
# yunc.add_qualifier("LUMINOSITY","137","fb$^{-1}$")
#yrelunc = Variable( "Rel. uncertainty (%)", is_independent=False, is_binned=False)
#yrelunc.values = relunc
yunc = Uncertainty( "syst" )
yunc.is_symmetric = True
yunc.values = unc
ystatunc = Uncertainty( "stat" )
ystatunc.is_symmetric = True
ystatunc.values = statunc
ydata.uncertainties.append(ystatunc)
ytot.uncertainties.append(yunc)
tab.add_variable(xbins)
tab.add_variable(ydata)
tab.add_variable(ytot)
tab.add_variable(ymisID)
tab.add_variable(ywg)
tab.add_variable(yzg)
tab.add_variable(yother)
tab.add_variable(yhad)
tab.add_variable(yqcd)
# tab.add_variable(yunc)
return tab
def wrong_input_properties():
'''Call add_uncertainty with invalid input properties.'''
unc2 = Uncertainty("testunc2")
unc2.is_symmetric = True
unc2.values = unc.values + [3]
var.add_uncertainty(unc2)
sfType = Variable("Scale factor",
is_independent=True,
is_binned=False,
units="")
sfType.values = [
"Misidentified electrons (2016)", "Misidentified electrons (2017)",
"Misidentified electrons (2018)", "Z$\gamma$ normalization",
"W$\gamma$ normalization"
]
value = Variable("Value", is_independent=False, is_binned=False, units="")
value.values = [2.25, 2.00, 1.52, 1.01, 1.13]
value.add_qualifier("SQRT(S)", "13", "TeV")
value.add_qualifier("LUMINOSITY", "137", "fb$^{-1}$")
unc = Uncertainty("total")
unc.is_symmetric = True
unc.values = [0.29, 0.27, 0.17, 0.10, 0.08]
value.uncertainties.append(unc)
tabSF.add_variable(sfType)
tabSF.add_variable(value)
tabSF.keywords["reactions"] = [
"P P --> TOP TOPBAR X", "P P --> TOP TOPBAR GAMMA"
]
tabSF.keywords["cmenergies"] = [13000.0]
tabSF.keywords["phrases"] = [
"Top", "Quark", "Photon", "lepton+jets", "semileptonic", "Cross Section",
"Proton-Proton Scattering", "Inclusive", "Differential"
]
submission.add_table(tabSF)
