def makeCutFlow(submission, config): table = Table(config["name"]) table.description = config["description"] table.location = config["location"] #table.keywords["observables"] = ["SIG"] #table.keywords["reactions"] = ["P P --> TOP --> tt + 6j"] data1 = config["data1"] error1 = config["error1"] data2 = config["data2"] error2 = config["error2"] ##################################################################################### d = Variable("Step", is_independent=True, is_binned=False, units="") d.values = np.array(list(i for i in range(0, data1.size))) cuts = Variable("Selection requirement", is_independent=False, is_binned=False, units="") cuts.values = config["cutnames"] cuts.add_qualifier("SQRT(S)", 13, "TeV") cuts.add_qualifier("LUMINOSITY", config["lumi"], "fb$^{-1}$") obs1 = Variable("RPV $m_{\\tilde{t}}$ = 450 GeV", is_independent=False, is_binned=False, units="") obs1.values = data1 obs1.add_qualifier("SQRT(S)", 13, "TeV") obs1.add_qualifier("LUMINOSITY", config["lumi"], "fb$^{-1}$") unc_obs1 = Uncertainty("1 s.d.", is_symmetric=True) unc_obs1.values = error1 obs1.add_uncertainty(unc_obs1) obs2 = Variable("SYY $m_{\\tilde{t}}$ = 850 GeV", is_independent=False, is_binned=False, units="") obs2.values = data2 obs2.add_qualifier("SQRT(S)", 13, "TeV") obs2.add_qualifier("LUMINOSITY", config["lumi"], "fb$^{-1}$") unc_obs2 = Uncertainty("1 s.d.", is_symmetric=True) unc_obs2.values = error2 obs2.add_uncertainty(unc_obs2) table.add_variable(d) table.add_variable(cuts) table.add_variable(obs1) table.add_variable(obs2) submission.add_table(table)
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 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 make_table(): params = [ 'r_ggH_0J_low', 'r_ggH_0J_high', 'r_ggH_1J_low', 'r_ggH_1J_med', 'r_ggH_1J_high', 'r_ggH_2J_low', 'r_ggH_2J_med', 'r_ggH_2J_high', 'r_ggH_BSM_low', 'r_ggH_BSM_med', 'r_ggH_BSM_high', 'r_qqH_low_mjj_low_pthjj', 'r_qqH_low_mjj_high_pthjj', 'r_qqH_high_mjj_low_pthjj', 'r_qqH_high_mjj_high_pthjj', 'r_qqH_VHhad', 'r_qqH_BSM', 'r_WH_lep_low', 'r_WH_lep_med', 'r_WH_lep_high', 'r_ZH_lep', 'r_ttH_low', 'r_ttH_medlow', 'r_ttH_medhigh', 'r_ttH_high', 'r_ttH_veryhigh', 'r_tH' ] # Load results + xsbr data inputXSBRjson = "/afs/cern.ch/work/j/jlangfor/hgg/legacy/FinalFits/UL/Dec20/CMSSW_10_2_13/src/flashggFinalFit/Plots/jsons/xsbr_theory_stage1p2_extended_125p38.json" inputExpResultsJson = '/afs/cern.ch/work/j/jlangfor/hgg/legacy/FinalFits/UL/Dec20/CMSSW_10_2_13/src/flashggFinalFit/Plots/expected_UL_redo.json' inputObsResultsJson = '/afs/cern.ch/work/j/jlangfor/hgg/legacy/FinalFits/UL/Dec20/CMSSW_10_2_13/src/flashggFinalFit/Plots/observed_UL_redo.json' inputMode = "stage1p2_extended" translatePOIs = LoadTranslations("translate/pois_%s.json" % inputMode) with open(inputXSBRjson, "r") as jsonfile: xsbr_theory = json.load(jsonfile) observed = CopyDataFromJsonFile(inputObsResultsJson, inputMode, params) expected = CopyDataFromJsonFile(inputExpResultsJson, inputMode, params) mh = float(re.sub("p", ".", inputXSBRjson.split("_")[-1].split(".json")[0])) # Make table of results table = Table("STXS stage 1.2 minimal merging scheme") table.description = "Results of the minimal merging scheme STXS fit. The best fit cross sections are shown together with the respective 68% C.L. intervals. The uncertainty is decomposed into the systematic and statistical components. The expected uncertainties on the fitted parameters are given in brackets. Also listed are the SM predictions for the cross sections and the theoretical uncertainty in those predictions." table.location = "Results from Figure 20 and Table 13" table.keywords["reactions"] = ["P P --> H ( --> GAMMA GAMMA ) X"] pois = Variable("STXS region", is_independent=True, is_binned=False) poiNames = [] for poi in params: poiNames.append(str(Translate(poi, translatePOIs))) pois.values = poiNames # Dependent variables # SM predict xsbr_sm = Variable("SM predicted cross section times branching ratio", is_independent=False, is_binned=False, units='fb') xsbr_sm.add_qualifier("SQRT(S)", 13, "TeV") xsbr_sm.add_qualifier("ABS(YRAP(HIGGS))", '<2.5') xsbr_sm.add_qualifier("MH", '125.38', "GeV") theory = Uncertainty("Theory", is_symmetric=False) xsbr_vals = [] xsbr_hi_th, xsbr_lo_th = [], [] for poi in params: xsbr_vals.append(xsbr_theory[poi]['nominal']) xsbr_hi_th.append(xsbr_theory[poi]['High01Sigma']) xsbr_lo_th.append(-1 * abs(xsbr_theory[poi]['Low01Sigma'])) xsbr_sm.values = np.round(np.array(xsbr_vals), 3) theory.values = zip(np.round(np.array(xsbr_lo_th), 3), np.round(np.array(xsbr_hi_th), 3)) xsbr_sm.add_uncertainty(theory) # Observed cross section xsbr = Variable("Observed cross section times branching ratio", is_independent=False, is_binned=False, units='fb') xsbr.add_qualifier("SQRT(S)", 13, "TeV") xsbr.add_qualifier("ABS(YRAP(HIGGS))", '<2.5') xsbr.add_qualifier("MH", '125.38', "GeV") # Add uncertainties tot = Uncertainty("Total", is_symmetric=False) stat = Uncertainty("Stat only", is_symmetric=False) syst = Uncertainty("Syst", is_symmetric=False) xsbr_vals = [] xsbr_hi_tot, xsbr_lo_tot = [], [] xsbr_hi_stat, xsbr_lo_stat = [], [] xsbr_hi_syst, xsbr_lo_syst = [], [] for poi in params: xsbr_vals.append(xsbr_theory[poi]['nominal'] * observed[poi]['Val']) xsbr_hi_tot.append( abs(xsbr_theory[poi]['nominal'] * observed[poi]['ErrorHi'])) xsbr_lo_tot.append( -1 * abs(xsbr_theory[poi]['nominal'] * observed[poi]['ErrorLo'])) xsbr_hi_stat.append( abs(xsbr_theory[poi]['nominal'] * observed[poi]['StatHi'])) xsbr_lo_stat.append( -1 * abs(xsbr_theory[poi]['nominal'] * observed[poi]['StatLo'])) xsbr_hi_syst.append( abs(xsbr_theory[poi]['nominal'] * observed[poi]['SystHi'])) xsbr_lo_syst.append( -1 * abs(xsbr_theory[poi]['nominal'] * observed[poi]['SystLo'])) tot.values = zip(np.round(np.array(xsbr_lo_tot), 3), np.round(np.array(xsbr_hi_tot), 3)) stat.values = zip(np.round(np.array(xsbr_lo_stat), 3), np.round(np.array(xsbr_hi_stat), 3)) syst.values = zip(np.round(np.array(xsbr_lo_syst), 3), np.round(np.array(xsbr_hi_syst), 3)) xsbr.values = np.round(np.array(xsbr_vals), 3) xsbr.add_uncertainty(tot) xsbr.add_uncertainty(stat) xsbr.add_uncertainty(syst) # Observed ratio to SM xsbrr = Variable("Observed ratio to SM", is_independent=False, is_binned=False, units='') xsbrr.add_qualifier("SQRT(S)", 13, "TeV") xsbrr.add_qualifier("ABS(YRAP(HIGGS))", '<2.5') xsbrr.add_qualifier("MH", '125.38', "GeV") # Add uncertainties totr = Uncertainty("Total", is_symmetric=False) statr = Uncertainty("Stat only", is_symmetric=False) systr = Uncertainty("Syst", is_symmetric=False) xsbr_vals = [] xsbr_hi_tot, xsbr_lo_tot = [], [] xsbr_hi_stat, xsbr_lo_stat = [], [] xsbr_hi_syst, xsbr_lo_syst = [], [] for poi in params: xsbr_vals.append(observed[poi]['Val']) xsbr_hi_tot.append(abs(observed[poi]['ErrorHi'])) xsbr_lo_tot.append(-1 * abs(observed[poi]['ErrorLo'])) xsbr_hi_stat.append(abs(observed[poi]['StatHi'])) xsbr_lo_stat.append(-1 * abs(observed[poi]['StatLo'])) xsbr_hi_syst.append(abs(observed[poi]['SystHi'])) xsbr_lo_syst.append(-1 * abs(observed[poi]['SystLo'])) totr.values = zip(np.round(np.array(xsbr_lo_tot), 3), np.round(np.array(xsbr_hi_tot), 3)) statr.values = zip(np.round(np.array(xsbr_lo_stat), 3), np.round(np.array(xsbr_hi_stat), 3)) systr.values = zip(np.round(np.array(xsbr_lo_syst), 3), np.round(np.array(xsbr_hi_syst), 3)) xsbrr.values = np.round(np.array(xsbr_vals), 3) xsbrr.add_uncertainty(totr) xsbrr.add_uncertainty(statr) xsbrr.add_uncertainty(systr) # Expected cross section xsbr_exp = Variable("Expected cross section times branching ratio", is_independent=False, is_binned=False, units='fb') xsbr_exp.add_qualifier("SQRT(S)", 13, "TeV") xsbr_exp.add_qualifier("ABS(YRAP(HIGGS))", '<2.5') xsbr_exp.add_qualifier("MH", '125.38', "GeV") # Add uncertainties tot_exp = Uncertainty("Total", is_symmetric=False) stat_exp = Uncertainty("Stat only", is_symmetric=False) syst_exp = Uncertainty("Syst", is_symmetric=False) xsbr_vals = [] xsbr_hi_tot, xsbr_lo_tot = [], [] xsbr_hi_stat, xsbr_lo_stat = [], [] xsbr_hi_syst, xsbr_lo_syst = [], [] for poi in params: xsbr_vals.append(xsbr_theory[poi]['nominal']) xsbr_hi_tot.append( abs(xsbr_theory[poi]['nominal'] * expected[poi]['ErrorHi'])) xsbr_lo_tot.append( -1 * abs(xsbr_theory[poi]['nominal'] * expected[poi]['ErrorLo'])) xsbr_hi_stat.append( abs(xsbr_theory[poi]['nominal'] * expected[poi]['StatHi'])) xsbr_lo_stat.append( -1 * abs(xsbr_theory[poi]['nominal'] * expected[poi]['StatLo'])) xsbr_hi_syst.append( abs(xsbr_theory[poi]['nominal'] * expected[poi]['SystHi'])) xsbr_lo_syst.append( -1 * abs(xsbr_theory[poi]['nominal'] * expected[poi]['SystLo'])) tot_exp.values = zip(np.round(np.array(xsbr_lo_tot), 3), np.round(np.array(xsbr_hi_tot), 3)) stat_exp.values = zip(np.round(np.array(xsbr_lo_stat), 3), np.round(np.array(xsbr_hi_stat), 3)) syst_exp.values = zip(np.round(np.array(xsbr_lo_syst), 3), np.round(np.array(xsbr_hi_syst), 3)) xsbr_exp.values = np.round(np.array(xsbr_vals), 3) xsbr_exp.add_uncertainty(tot_exp) xsbr_exp.add_uncertainty(stat_exp) xsbr_exp.add_uncertainty(syst_exp) # Expected ratio to SM xsbrr_exp = Variable("Expected ratio to SM", is_independent=False, is_binned=False, units='') xsbrr_exp.add_qualifier("SQRT(S)", 13, "TeV") xsbrr_exp.add_qualifier("ABS(YRAP(HIGGS))", '<2.5') xsbrr_exp.add_qualifier("MH", '125.38', "GeV") # Add uncertainties totr_exp = Uncertainty("Total", is_symmetric=False) statr_exp = Uncertainty("Stat only", is_symmetric=False) systr_exp = Uncertainty("Syst", is_symmetric=False) xsbr_vals = [] xsbr_hi_tot, xsbr_lo_tot = [], [] xsbr_hi_stat, xsbr_lo_stat = [], [] xsbr_hi_syst, xsbr_lo_syst = [], [] for poi in params: xsbr_vals.append(1.00) xsbr_hi_tot.append(abs(expected[poi]['ErrorHi'])) xsbr_lo_tot.append(-1 * abs(expected[poi]['ErrorLo'])) xsbr_hi_stat.append(abs(expected[poi]['StatHi'])) xsbr_lo_stat.append(-1 * abs(expected[poi]['StatLo'])) xsbr_hi_syst.append(abs(expected[poi]['SystHi'])) xsbr_lo_syst.append(-1 * abs(expected[poi]['SystLo'])) totr_exp.values = zip(np.round(np.array(xsbr_lo_tot), 3), np.round(np.array(xsbr_hi_tot), 3)) statr_exp.values = zip(np.round(np.array(xsbr_lo_stat), 3), np.round(np.array(xsbr_hi_stat), 3)) systr_exp.values = zip(np.round(np.array(xsbr_lo_syst), 3), np.round(np.array(xsbr_hi_syst), 3)) xsbrr_exp.values = np.round(np.array(xsbr_vals), 3) xsbrr_exp.add_uncertainty(totr_exp) xsbrr_exp.add_uncertainty(statr_exp) xsbrr_exp.add_uncertainty(systr_exp) # Add variables to table table.add_variable(pois) table.add_variable(xsbr_sm) table.add_variable(xsbr) table.add_variable(xsbrr) table.add_variable(xsbr_exp) table.add_variable(xsbrr_exp) # Add figure table.add_image( "/afs/cern.ch/work/j/jlangfor/hgg/legacy/FinalFits/UL/Dec20/CMSSW_10_2_13/src/OtherScripts/HEPdata/hepdata_lib/hig-19-015/inputs/stxs_dist_stage1p2_minimal.pdf" ) return table
table5.keywords["observables"] = ["Events"] table5.keywords["reactions"] = ["P P --> W W j j"] table5.keywords["phrases"] = ["VBS", "Polarized", "Same-sign WW"] data5 = np.loadtxt("HEPData/inputs/smp20006/total_yields_llfit.txt", dtype='string') print(data5) table5_data = Variable("Process", is_independent=True, is_binned=False, units="") table5_data.values = [str(x) for x in data5[:,0]] table5_yields0 = Variable("Yields in WW signal region", is_independent=False, is_binned=False, units="") table5_yields0.values = [float(x) for x in data5[:,1]] table5_yields0.add_qualifier("SQRT(S)", 13, "TeV") table5_unc0 = Uncertainty("total uncertainty", is_symmetric=True) table5_unc0.values = [float(x) for x in data5[:,2]] table5_yields0.add_uncertainty(table5_unc0) table5_yields0.add_qualifier("L$_{\mathrm{int}}$", 137, "fb$^{-1}$") table5.add_variable(table5_data) table5.add_variable(table5_yields0) submission.add_table(table5) for table5 in submission.tables: table5.keywords["cmenergies"] = [13000] ###End Table 5 ### Begin Table 6 table6 = Table("Table 6") table6.description = "Measured fiducial cross sections for the $\mathrm{W}^\pm_{\mathrm{L}}\mathrm{W}^\pm_{\mathrm{L}}$ and $\mathrm{W}^\pm_{\mathrm{X}}\mathrm{W}^\pm_{\mathrm{T}}$ processes, and for the $\mathrm{W}^\pm_{\mathrm{L}}\mathrm{W}^\pm_{\mathrm{X}}$ and $\mathrm{W}^\pm_{\mathrm{T}}\mathrm{W}^\pm_{\mathrm{T}}$ processes for the helicity eigenstates defined in the WW center-of-mass frame. The combination of the statistical and systematic uncertainties is shown. The theoretical uncertainties include statistical, PDF, and LO scale uncertainties. $\mathcal{B}$ is the branching fraction for $\mathrm{W}\mathrm{W} \\rightarrow \ell \\nu \ell' \\nu$. The fiducial region is defined by requiring two same-sign leptons with $p_{T}>20$, $|\eta|<2.5$, and $m_{ll}>20$, and two jets with $m_{jj}>500$ and $|\Delta \eta_{jj}|>2.5$. The jets at generator level are clustered from stable particles, excluding neutrinos, using the anti-kt clustering algorithm with R = 0.4, and are required to have $p_{T}>50$ and $|\eta|<4.7$. The jets within $\Delta R<0.4$ of the selected charged leptons are not included."
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
if fig["type_stat"].lower() == "th2": x1 = Variable(fig["x1_name"], is_independent=True, is_binned=False, units=fig["x1_units"]) x1.values = stat["x"] x2 = Variable(fig["x2_name"], is_independent=True, is_binned=False, units=fig["x2_units"]) x2.values = stat["y"] y = Variable(fig["y_name"], is_independent=False, is_binned=False, units=fig["y_units"]) y.values = stat["z"] else: x1 = Variable(fig["x1_name"], is_independent=True, is_binned=False, units=fig["x1_units"]) x1.values = stat["x"] y = Variable(fig["y_name"], is_independent=False, is_binned=False, units=fig["y_units"]) y.values = stat["y"] if fig["type_stat"].lower() == "tgraphasymmerrors": y_stat = Uncertainty("stat. uncertainty", is_symmetric=False) y_stat.values = stat["dy"] y.add_uncertainty(y_stat) elif fig["type_stat"].lower() in ["tgrapherrors", "th1"]: y_stat = Uncertainty("stat. uncertainty", is_symmetric=True) y_stat.values = stat["dy"] y.add_uncertainty(y_stat) if fig["type_syst"].lower() == "tgraphasymmerrors": y_syst = Uncertainty("syst. uncertainty", is_symmetric=False) y_syst.values = syst["dy"] y.add_uncertainty(y_syst) elif fig["type_syst"].lower() in ["tgrapherrors", "th1"]: y_syst = Uncertainty("syst. uncertainty", is_symmetric=True) y_syst.values = syst["dy"] y.add_uncertainty(y_syst)
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)
print(data3) table3_data = Variable("Process", is_independent=True, is_binned=False, units="") table3_data.values = [str(x) for x in data3[:, 0]] table3_yields0 = Variable("$\mathrm{W}^{\pm}\mathrm{W}^{\pm}$ SR", is_independent=False, is_binned=False, units="") table3_unc0 = Uncertainty("total uncertainty", is_symmetric=True) table3_yields0.values = [float(x) for x in data3[:, 1]] table3_unc0.values = [float(x) for x in data3[:, 2]] table3_yields0.add_uncertainty(table3_unc0) table3_yields0.add_qualifier("SQRT(S)", 13, "TeV") table3_yields0.add_qualifier("L$_{\mathrm{int}}$", 137, "fb$^{-1}$") table3_yields1 = Variable("WZ SR", is_independent=False, is_binned=False, units="") table3_unc1 = Uncertainty("total uncertainty", is_symmetric=True) table3_yields1.values = [float(x) for x in data3[:, 3]] table3_unc1.values = [float(x) for x in data3[:, 4]] table3_yields1.add_uncertainty(table3_unc1) table3_yields1.add_qualifier("SQRT(S)", 13, "TeV") table3_yields1.add_qualifier("L$_{\mathrm{int}}$", 137, "fb$^{-1}$")
wjets.values = WJets["y"] zjets = Variable("Number of zjets events", is_independent=False, is_binned=False, units="") zjets.values = ZJets["y"] data = Variable("Number of data events", is_independent=False, is_binned=False, units="") data.values = Data["y"] unc_totalbackground = Uncertainty("total uncertainty", is_symmetric=True) unc_totalbackground.values = TotalBackground["dy"] unc_data = Uncertainty("Poisson errors", is_symmetric=True) unc_data.values = Data["dy"] totalbackground.add_uncertainty(unc_totalbackground) data.add_uncertainty(unc_data) table2.add_variable(mmed) table2.add_variable(sig) table2.add_variable(totalbackground) table2.add_variable(tt) table2.add_variable(qcd) table2.add_variable(zjets) table2.add_variable(wjets) table2.add_variable(data)
from hepdata_lib import Table table = Table("pa all") table.description = "description." table.location = "upper left." table.keywords["observables"] = ["pa"] from hepdata_lib import RootFileReader reader = RootFileReader("root://eosuser.cern.ch//eos/user/v/vveckaln/analysis_MC13TeV_TTJets/plots/plotter.root") Data = reader.read_hist_1d("L_pull_angle_allconst_reco_leading_jet_scnd_leading_jet_DeltaRgt1p0/L_pull_angle_allconst_reco_leading_jet_scnd_leading_jet_DeltaRgt1p0") Unc = reader.read_hist_1d("L_pull_angle_allconst_reco_leading_jet_scnd_leading_jet_DeltaRgt1p0/L_pull_angle_allconst_reco_leading_jet_scnd_leading_jet_DeltaRgt1p0_totalMCUncShape") from hepdata_lib import Variable, Uncertainty mmed = Variable("pa", is_independent=True, is_binned=False, units="rad") mmed.values = signal["x"] data = Variable("N", is_independent=False, is_binned=False, units="") data.values = Data["y"] unc = Uncertainty("Total", is_symmetric=True) unc.values = Unc["dy"] data.add_uncertainty(unc) table.add_variable(mmed) table.add_variable(data) submission.add_table(table) submission.create_files("example_output")
mmed_FigAux2a = Variable("$p_{T}$", is_independent=True, is_binned=True, units="GeV") mmed_FigAux2a.values = histoResultXS_0["x_edges"] # y-axis: N events unfoldFigAux2a = Variable("Z to nn/ll cross section (pb)", is_independent=False, is_binned=False, units="") unfoldFigAux2a.values = histoResultXS_0["y"] unc_unfoldFigAux2a = Uncertainty("", is_symmetric=True) unc_unfoldFigAux2a.values = histoResultXS_0["dy"] unfoldFigAux2a.add_uncertainty(unc_unfoldFigAux2a) tableFigAux2a.add_variable(mmed_FigAux2a) tableFigAux2a.add_variable(unfoldFigAux2a) submission.add_table(tableFigAux2a) ### End FigAux2a ### Begin FigAux2b reader_FigAux2b = RootFileReader("HEPData/inputs/smp18003/ZnnSystHist.root") tableFigAux2b = Table("Figure Aux2b") tableFigAux2b.description = "Cross section measurements in bins of Z $p_{T}$ on neutrinos and charged leptons." tableFigAux2b.location = "Data from Figure Aux2b" tableFigAux2b.keywords["observables"] = ["N"]
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 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 make_table(): params = ['r_ggH', 'r_VBF', 'r_VH', 'r_top', 'r_inclusive'] # Load results + xsbr data inputExpResultsJson = '/afs/cern.ch/work/j/jlangfor/hgg/legacy/FinalFits/UL/Dec20/CMSSW_10_2_13/src/flashggFinalFit/Plots/expected_UL_redo.json' inputObsResultsJson = '/afs/cern.ch/work/j/jlangfor/hgg/legacy/FinalFits/UL/Dec20/CMSSW_10_2_13/src/flashggFinalFit/Plots/observed_UL_redo.json' inputMode = "mu" translatePOIs = LoadTranslations("translate/pois_%s.json" % inputMode) observed = CopyDataFromJsonFile(inputObsResultsJson, inputMode, params) expected = CopyDataFromJsonFile(inputExpResultsJson, inputMode, params) # Make table of results table = Table("Signal strengths") table.description = "Best-fit values and 68% confidence intervals for the signal strength modifiers. The uncertainty is decomposed ino the theoretical systematic, experimental systematic and statistical components. Additionally, the expected uncertainties derived using an asimov dataset are provided." table.location = "Results from Figure 16" table.keywords["reactions"] = ["P P --> H ( --> GAMMA GAMMA ) X"] pois = Variable("Parameter", is_independent=True, is_binned=False) poiNames = [] for poi in params: poiNames.append(str(Translate(poi, translatePOIs))) pois.values = poiNames # Dependent variables # Observed values obs = Variable("Observed", is_independent=False, is_binned=False, units='') obs.add_qualifier("SQRT(S)", 13, "TeV") obs.add_qualifier("MH", '125.38', "GeV") # Add uncertainties tot = Uncertainty("Total", is_symmetric=False) th = Uncertainty("Th. syst", is_symmetric=False) exp = Uncertainty("Exp. syst", is_symmetric=False) stat = Uncertainty("Stat only", is_symmetric=False) vals = [] hi_tot, lo_tot = [], [] hi_th, lo_th = [], [] hi_exp, lo_exp = [], [] hi_stat, lo_stat = [], [] for poi in params: vals.append(observed[poi]['Val']) hi_tot.append(abs(observed[poi]['ErrorHi'])) lo_tot.append(-1 * abs(observed[poi]['ErrorLo'])) hi_th.append(abs(observed[poi]['TheoryHi'])) lo_th.append(-1 * abs(observed[poi]['TheoryLo'])) hi_exp.append(abs(observed[poi]['SystHi'])) lo_exp.append(-1 * abs(observed[poi]['SystLo'])) hi_stat.append(abs(observed[poi]['StatHi'])) lo_stat.append(-1 * abs(observed[poi]['StatLo'])) tot.values = zip(np.round(np.array(lo_tot), 3), np.round(np.array(hi_tot), 3)) th.values = zip(np.round(np.array(lo_th), 3), np.round(np.array(hi_th), 3)) exp.values = zip(np.round(np.array(lo_exp), 3), np.round(np.array(hi_exp), 3)) stat.values = zip(np.round(np.array(lo_stat), 3), np.round(np.array(hi_stat), 3)) obs.values = np.round(np.array(vals), 3) obs.add_uncertainty(tot) obs.add_uncertainty(th) obs.add_uncertainty(exp) obs.add_uncertainty(stat) # Expected values ex = Variable("Expected", is_independent=False, is_binned=False, units='') ex.add_qualifier("SQRT(S)", 13, "TeV") ex.add_qualifier("MH", '125.38', "GeV") # Add uncertainties etot = Uncertainty("Total", is_symmetric=False) eth = Uncertainty("Th. syst", is_symmetric=False) eexp = Uncertainty("Exp. syst", is_symmetric=False) estat = Uncertainty("Stat only", is_symmetric=False) vals = [] hi_tot, lo_tot = [], [] hi_th, lo_th = [], [] hi_exp, lo_exp = [], [] hi_stat, lo_stat = [], [] for poi in params: vals.append(1.00) hi_tot.append(abs(expected[poi]['ErrorHi'])) lo_tot.append(-1 * abs(expected[poi]['ErrorLo'])) hi_th.append(abs(expected[poi]['TheoryHi'])) lo_th.append(-1 * abs(expected[poi]['TheoryLo'])) hi_exp.append(abs(expected[poi]['SystHi'])) lo_exp.append(-1 * abs(expected[poi]['SystLo'])) hi_stat.append(abs(expected[poi]['StatHi'])) lo_stat.append(-1 * abs(expected[poi]['StatLo'])) etot.values = zip(np.round(np.array(lo_tot), 3), np.round(np.array(hi_tot), 3)) eth.values = zip(np.round(np.array(lo_th), 3), np.round(np.array(hi_th), 3)) eexp.values = zip(np.round(np.array(lo_exp), 3), np.round(np.array(hi_exp), 3)) estat.values = zip(np.round(np.array(lo_stat), 3), np.round(np.array(hi_stat), 3)) ex.values = np.round(np.array(vals), 3) ex.add_uncertainty(etot) ex.add_uncertainty(eth) ex.add_uncertainty(eexp) ex.add_uncertainty(estat) # Add variables to table table.add_variable(pois) table.add_variable(obs) table.add_variable(ex) # Add figure table.add_image( "/afs/cern.ch/work/j/jlangfor/hgg/legacy/FinalFits/UL/Dec20/CMSSW_10_2_13/src/OtherScripts/HEPdata/hepdata_lib/hig-19-015/inputs/perproc_mu_coloured.pdf" ) return table
def Plot_pp_pPb_Avg_FF_and_Ratio(Comb_Dict): label_size=22 axis_size=34 plot_power = False Colors = ["red","blue"] Markers = ["s","o"] fig = plt.figure(figsize=(8,8)) pp_sys_Error = 0 p_Pb_sys_Error = 0 fig.add_axes((0.1,0.3,0.88,0.6)) for SYS,sys_col,marker in zip(reversed(Systems),reversed(Colors),reversed(Markers)): #Systematics Efficiency_Uncertainty = 0.056*Comb_Dict["%s_Combined_FF"%(SYS)] Eta_Cor = Eta_Correction #see default_value.py for value Eta_Cor_Uncertainty = Eta_Correction_Uncertainty*Comb_Dict["%s_Combined_FF"%(SYS)] if not(Apply_Eta_Correction and SYS=="p-Pb"): Eta_Cor_Uncertainty = 0 #2% otherwise FF_Central = Comb_Dict["%s_Combined_FF"%(SYS)] #Eta Correction is applied when creating Dictionary! Sys_Uncertainty = np.sqrt(Efficiency_Uncertainty**2 + Comb_Dict["%s_purity_Uncertainty"%(SYS)]**2 + Eta_Cor_Uncertainty**2) if (SYS=="pp"): pp_sys_Error = Sys_Uncertainty elif (SYS=="p-Pb"): p_Pb_sys_Error=Sys_Uncertainty #Plots if (SYS=="pp"): leg_string = SYS if (SYS=="p-Pb"): leg_string = "p$-$Pb" plt.errorbar(zT_centers[:NzT-ZT_OFF_PLOT], Comb_Dict["%s_Combined_FF"%(SYS)][:NzT-ZT_OFF_PLOT],xerr=zT_widths[:NzT-ZT_OFF_PLOT]*0, yerr=Comb_Dict["%s_Combined_FF_Errors"%(SYS)][:NzT-ZT_OFF_PLOT],linewidth=1, fmt=marker,color=sys_col,capsize=0)#for lines plt.plot(zT_centers[:NzT-ZT_OFF_PLOT], Comb_Dict["%s_Combined_FF"%(SYS)][:NzT-ZT_OFF_PLOT],marker,linewidth=0,color=sys_col, label=leg_string)#for legend without lines if (SYS == "pp"): Sys_Plot_pp = plt.bar(zT_centers[:NzT-ZT_OFF_PLOT], Sys_Uncertainty[:NzT-ZT_OFF_PLOT]+Sys_Uncertainty[:NzT-ZT_OFF_PLOT], bottom=Comb_Dict["%s_Combined_FF"%(SYS)][:NzT-ZT_OFF_PLOT]-Sys_Uncertainty[:NzT-ZT_OFF_PLOT],width=zT_widths[:NzT-ZT_OFF_PLOT]*2, align='center',color=sys_col,alpha=0.3,edgecolor=sys_col) else: Sys_Plot_pp = plt.bar(zT_centers[:NzT-ZT_OFF_PLOT], Sys_Uncertainty[:NzT-ZT_OFF_PLOT]+Sys_Uncertainty[:NzT-ZT_OFF_PLOT], bottom=Comb_Dict["%s_Combined_FF"%(SYS)][:NzT-ZT_OFF_PLOT]-Sys_Uncertainty[:NzT-ZT_OFF_PLOT],width=zT_widths[:NzT-ZT_OFF_PLOT]*2,align='center',color=sys_col,fill=False,edgecolor="blue") if (plot_power): model,p,chi2dof = Fit_FF_PowerLaw(Comb_Dict,SYS) plt.plot(zT_centers[:NzT-ZT_OFF_PLOT], model, sys_col,label=r"%s $\alpha = %1.2f\pm 0.1 \chi^2 = %1.2f$"%(SYS,p,chi2dof)) if (Use_MC): plt.plot(zT_centers[:NzT-ZT_OFF_PLOT],pythia_FF,'--',color="forestgreen",label="PYTHIA 8.2 Monash") plt.errorbar(zT_centers[:NzT-ZT_OFF_PLOT],pythia_FF,yerr=pythia_FF_Errors,fmt='--',color="forestgreen",capsize=0) plt.yscale('log') plt.ylabel(r"$\frac{1}{N_{\mathrm{\gamma}}}\frac{\mathrm{d}^3N}{\mathrm{d}z_{\mathrm{T}}\mathrm{d}|\Delta\varphi|\mathrm{d}\Delta\eta}$",fontsize=axis_size,y=0.76) plt.ylim(0.037,15) plt.yticks(fontsize=20) plt.xticks(fontsize=0) plt.xlim(0,0.65) plt.tick_params(which='both',direction='in',right=True,top=True,bottom=False,length=10) plt.tick_params(which='minor',length=5) #pp_sys_Error = (Comb_Dict["pp_Combined_FF"][:NzT-ZT_OFF_PLOT])*math.sqrt(Rel_pUncert["pp"]**2+0.056**2) #p_Pb_sys_Error = (Comb_Dict["p-Pb_Combined_FF"][:NzT-ZT_OFF_PLOT])*math.sqrt(Rel_pUncert["p-Pb"]**2+0.056**2+Eta_Cor**2) Chi2,NDF,Pval = Get_pp_pPb_List_Chi2(Comb_Dict["pp_Combined_FF"][:NzT-ZT_OFF_PLOT], Comb_Dict["pp_Combined_FF_Errors"][:NzT-ZT_OFF_PLOT], pp_sys_Error, Comb_Dict["p-Pb_Combined_FF"][:NzT-ZT_OFF_PLOT], Comb_Dict["p-Pb_Combined_FF_Errors"][:NzT-ZT_OFF_PLOT], p_Pb_sys_Error) leg = plt.legend(numpoints=1,frameon=True,edgecolor='white', framealpha=0.0, fontsize=label_size,handlelength=1,labelspacing=0.2,loc='lower left',bbox_to_anchor=(0.001, 0.05)) plt.annotate(r"ALICE, $\sqrt{s_{\mathrm{_{NN}}}}=5.02$ TeV",xy=(0.115,0.008),xycoords='axes fraction', ha='left',va='bottom',fontsize=label_size) plt.annotate(r"%1.0f < $p_\mathrm{T}^{\gamma}$ < %1.0f GeV/$c$"%(pTbins[0],pTbins[N_pT_Bins]),xy=(0.97, 0.81), xycoords='axes fraction', ha='right', va='top', fontsize=label_size) plt.annotate(r"%1.1f < $p_\mathrm{T}^\mathrm{h}$ < %1.1f GeV/$c$"%(Min_Hadron_pT,Max_Hadron_pT),xy=(0.97, 0.89), xycoords='axes fraction', ha='right', va='top', fontsize=label_size) plt.annotate("$\chi^2/\mathrm{ndf}$ = %1.1f/%i, $p$ = %1.2f"%(Chi2*NDF,NDF,Pval), xy=(0.97, 0.97), xycoords='axes fraction', ha='right', va='top', fontsize=label_size) #HEP FF Fig5 = Table("Figure 5 Top Panel") Fig5.description = "$\gamma^\mathrm{iso}$-tagged fragmentation function for pp (red) and p$-$Pb data (blue) at $\sqrt{s_\mathrm{NN}}$ = 5.02 TeV as measured by the ALICE detector. The boxes represent the systematic uncertainties while the vertical bars indicate the statistical uncertainties. The dashed green line corresponds to PYTHIA 8.2 Monash Tune. The $\chi^2$ test for the comparison of pp and p$-$Pb data incorporates correlations among different $z_\mathrm{T}$ intervals. A constant that was fit to the ratio is shown as grey band, with the width indicating the uncertainty on the fit." Fig5.location = "Data from Figure 5 Top Panel, Page 15" Fig5.keywords["observables"] = ["$\frac{1}{N_{\mathrm{\gamma}}}\frac{\mathrm{d}^3N}{\mathrm{d}z_{\mathrm{T}}\mathrm{d}\Delta\varphi\mathrm{d}\Delta\eta}$"] Fig5.add_image("./pics/LO/zT_Rebin_8_006zT06zT13fnew/Final_FFunction_and_Ratio.pdf") # x-axis: zT zt = Variable(r"$z_\mathrm{T}$", is_independent=True, is_binned=True, units="") zt.values = zT_edges Fig5.add_variable(zt) # y-axis: p-Pb Yields pPb_data = Variable("p$-$Pb conditional yield of associated hadrons", is_independent=False, is_binned=False, units="") pPb_data.values = Comb_Dict["p-Pb_Combined_FF"] pPb_sys = Uncertainty("p-Pb Systematic", is_symmetric=True) pPb_sys.values = p_Pb_sys_Error pPb_stat = Uncertainty("p-Pb Statistical", is_symmetric=True) pPb_stat.values = Comb_Dict["p-Pb_Combined_FF_Errors"] pPb_data.add_uncertainty(pPb_sys) pPb_data.add_uncertainty(pPb_stat) # y-axis: pp Yields pp_data = Variable("pp conditional yield of associated hadrons", is_independent=False, is_binned=False, units="") pp_data.values = Comb_Dict["pp_Combined_FF"] pp_sys = Uncertainty("pp Systematic", is_symmetric=True) pp_sys.values = pp_sys_Error pp_stat = Uncertainty("pp Statistical", is_symmetric=True) pp_stat.values = Comb_Dict["pp_Combined_FF_Errors"] pp_data.add_uncertainty(pp_sys) pp_data.add_uncertainty(pp_stat) # y-axis: PYTHIA Yields pythia_data = Variable("PYTHIA conditional yield of associated hadrons", is_independent=False, is_binned=False, units="") pythia_data.values = pythia_FF pythia_stat = Uncertainty("PYTHIA Statistical", is_symmetric=True) pythia_stat.values = pythia_FF_Errors pythia_data.add_uncertainty(pythia_stat) #Add everything to the HEP Table Fig5.add_variable(pPb_data) Fig5.add_variable(pp_data) Fig5.add_variable(pythia_data) submission.add_table(Fig5) #RATIO SECOND Y_AXIS fig.add_axes((0.1,0.1,0.88,0.2)) pPb_Combined = Comb_Dict["p-Pb_Combined_FF"] pPb_Combined_Errors = Comb_Dict["p-Pb_Combined_FF_Errors"] pPb_purity_Uncertainty = Comb_Dict["p-Pb_purity_Uncertainty"] pp_Combined = Comb_Dict["pp_Combined_FF"] pp_Combined_Errors = Comb_Dict["pp_Combined_FF_Errors"] pp_purity_Uncertainty = Comb_Dict["pp_purity_Uncertainty"] Ratio = pPb_Combined/pp_Combined Ratio_Error = np.sqrt((pPb_Combined_Errors/pPb_Combined)**2 + (pp_Combined_Errors/pp_Combined)**2)*Ratio Ratio_Plot = plt.errorbar(zT_centers[:NzT-ZT_OFF_PLOT], Ratio[:NzT-ZT_OFF_PLOT], yerr=Ratio_Error[:NzT-ZT_OFF_PLOT],xerr=zT_widths[:NzT-ZT_OFF_PLOT]*0, fmt='ko',capsize=0, ms=6,lw=1) #Save np.save("npy_files/%s_Averaged_FF_Ratio_%s.npy"%(Shower,description_string),Ratio) np.save("npy_files/%s_Averaged_FF_Ratio_Errors_%s.npy"%(Shower,description_string),Ratio_Error) Purity_Uncertainty = np.sqrt((pp_purity_Uncertainty/pp_Combined)**2 + (pPb_purity_Uncertainty/pPb_Combined)**2)*Ratio Efficiency_Uncertainty = np.ones(len(pPb_Combined))*0.056*math.sqrt(2)*Ratio Eta_Cor_Uncertainty = Eta_Correction_Uncertainty/Comb_Dict["p-Pb_Combined_FF"]*Ratio if (CorrectedP): Ratio_Systematic = np.sqrt(Purity_Uncertainty**2 + Efficiency_Uncertainty**2 + Eta_Cor_Uncertainty**2) Sys_Plot = plt.bar(zT_centers[:NzT-ZT_OFF_PLOT], Ratio_Systematic[:NzT-ZT_OFF_PLOT]+Ratio_Systematic[:NzT-ZT_OFF_PLOT], bottom=Ratio[:NzT-ZT_OFF_PLOT]-Ratio_Systematic[:NzT-ZT_OFF_PLOT], width=zT_widths[:NzT-ZT_OFF_PLOT]*2, align='center',color='black',alpha=0.25) ### ROOT LINEAR and CONSTANT FITS ### Ratio_TGraph = TGraphErrors() for izt in range (len(Ratio)-ZT_OFF_PLOT): Ratio_TGraph.SetPoint(izt,zT_centers[izt],Ratio[izt]) Ratio_TGraph.SetPointError(izt,0,Ratio_Error[izt]) Ratio_TGraph.Fit("pol0","S") f = Ratio_TGraph.GetFunction("pol0") chi2_red = f.GetChisquare()/f.GetNDF() pval = f.GetProb() p0 = f.GetParameter(0) p0e = f.GetParError(0) p0col = "grey" Show_Fits = True if (Show_Fits): sys_const = 0.19 #23% relative from purity + tracking #sys_const = 0.504245 #IRC plt.annotate("$c = {0:.2f} \pm {1:.2f} \pm {2:.2f}$".format(p0,p0e,sys_const), xy=(0.98, 0.9), xycoords='axes fraction', ha='right', va='top', color="black",fontsize=label_size,alpha=.9) plt.annotate(r"$p = %1.2f$"%(pval), xy=(0.98, 0.75), xycoords='axes fraction', ha='right', va='top', color="black",fontsize=label_size,alpha=.9) c_error = math.sqrt(p0e**2 + sys_const**2) plt.fill_between(np.arange(0,1.1,0.1), p0+c_error, p0-c_error,color=p0col,alpha=.3) ###LABELS/AXES### plt.axhline(y=1, color='k', linestyle='--') plt.xlabel("${z_\mathrm{T}} = p_\mathrm{T}^{\mathrm{h}}/p_\mathrm{T}^\gamma$",fontsize=axis_size-8,x=0.9) plt.ylabel(r"$\frac{\mathrm{p-Pb}}{\mathrm{pp}}$",fontsize=axis_size,y=0.5) plt.ylim((-0.0, 2.8)) plt.xticks(fontsize=20) plt.yticks([0.5,1.0,1.5,2.0,2.5],fontsize=20) plt.xlim(0,0.65) plt.tick_params(which='both',direction='in',right=True,bottom=True,top=True,length=10) plt.tick_params(which='both',direction='in',top=True,length=5) plt.savefig("pics/%s/%s/Final_FFunction_and_Ratio.pdf"%(Shower,description_string), bbox_inches = "tight") plt.show() #RATIO HEP FigRatio = Table("Figure 5 Bottom Panel") FigRatio.description = r"$\gamma^\mathrm{iso}$-tagged fragmentation function for pp (red) and p$-$Pb data (blue) at $\sqrt{s_\mathrm{NN}}$ = 5.02 TeV as measured by the ALICE detector. The boxes represent the systematic uncertainties while the vertical bars indicate the statistical uncertainties. The dashed green line corresponds to PYTHIA 8.2 Monash Tune. The $\chi^2$ test for the comparison of pp and p$-$Pb data incorporates correlations among different $z_\mathrm{T}$ intervals. A constant that was fit to the ratio is shown as grey band, with the width indicating the uncertainty on the fit." FigRatio.location = "Data from Figure 5, Bottom Panel, Page 15" FigRatio.keywords["observables"] = [r"$\frac{1}{N_{\mathrm{\gamma}}}\frac{\mathrm{d}^3N}{\mathrm{d}z_{\mathrm{T}}\mathrm{d}\Delta\varphi\mathrm{d}\Delta\eta}$"] FigRatio.add_image("./pics/LO/zT_Rebin_8_006zT06zT13fnew/Final_FFunction_and_Ratio.pdf") # x-axis: zT zt_ratio = Variable(r"$z_\mathrm{T}$", is_independent=True, is_binned=True, units="") zt_ratio.values = zT_edges FigRatio.add_variable(zt_ratio) # y-axis: p-Pb Yields Ratio_HEP = Variable("Ratio conditional yield of associated hadrons in pp and p$-$Pb", is_independent=False, is_binned=False, units="") Ratio_HEP.values = Ratio Ratio_sys = Uncertainty("Ratio Systematic", is_symmetric=True) Ratio_sys.values = Ratio_Systematic Ratio_stat = Uncertainty("Ratio Statistical", is_symmetric=True) Ratio_stat.values = Ratio_Error Ratio_HEP.add_uncertainty(Ratio_stat) Ratio_HEP.add_uncertainty(Ratio_sys) FigRatio.add_variable(Ratio_HEP) submission.add_table(FigRatio)
#diphoton pT fig2_ul_pt = Variable("$p_T^{\gamma\gamma}$", is_independent=True, is_binned=False, units="GeV") fig2_ul_pt.values = fig2_ul_in[:, 0] #Data fig2_ul_Data = Variable("Data", is_independent=False, is_binned=False, units="Events per bin") fig2_ul_Data.values = fig2_ul_in[:, 1] fig2_ul_Data_stat = Uncertainty("stat", is_symmetric=True) fig2_ul_Data_stat.values = fig2_ul_in[:, 2] fig2_ul_Data.add_uncertainty(fig2_ul_Data_stat) #Wgg fig2_ul_Wgg = Variable("$\mathrm{W}\gamma\gamma$", is_independent=False, is_binned=False, units="Events per bin") fig2_ul_Wgg.values = fig2_ul_in[:, 3] fig2_ul_Wgg_stat = Uncertainty("stat", is_symmetric=True) fig2_ul_Wgg_stat.values = fig2_ul_in[:, 4] fig2_ul_Wgg.add_uncertainty(fig2_ul_Wgg_stat) #Misid. electrons fig2_ul_Mele = Variable("Misid. electrons", is_independent=False,
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)
is_independent=True, is_binned=False, units="none") table2_data.values = [str(x) for x in data2[:, 0]] table2_yields1 = Variable("WV events", is_independent=False, is_binned=False, units="") table2_yields1.values = [float(x) for x in data2[:, 1]] table2_yields1.add_qualifier("Expected events", "WV selection") table2_yields1.add_qualifier("SQRT(S)", 13, "TeV") table2_yields1.add_qualifier("L$_{\mathrm{int}}$", 36.9, "fb$^{-1}$") table2_unc1 = Uncertainty("stat,syst", is_symmetric=True) table2_unc1.values = [float(x) for x in data2[:, 2]] table2_yields2 = Variable("ZV events", is_independent=False, is_binned=False, units="") table2_yields2.values = [float(x) for x in data2[:, 3]] table2_yields2.add_qualifier("Expected events", "ZV selection") table2_yields2.add_qualifier("SQRT(S)", 13, "TeV") table2_unc2 = Uncertainty("stat,syst", is_symmetric=True) table2_unc2.values = [float(x) for x in data2[:, 4]] table2_yields1.add_uncertainty(table2_unc1) table2_yields2.add_uncertainty(table2_unc2)