def __init__(self, csv=None, wp_key=None, eff_file=None, pattern=None): '''SF computation according to method 1a of https://twiki.cern.ch/twiki/bin/view/CMS/BTagSFMethods Inputs: csv, wp_key, eff_file, pattern csv: path to a b-tagging CSV file wp_key: a tuple of three elements containing (Algo name, SF method, WP name) eff_file: root file containing the efficiency histograms pattern: formattable string that accepts one parameter for flavour definition''' parsed_csv = reshuffle_sf_dict(convert_btag_csv_file(csv)) self.sf_ = recursive_compile( parsed_csv[wp_key[0]][wp_key[1]][wp_key[2]]) # FIXME: move to correlated/uncorrelated # Define, by hand, the proper correlation among taggers, # somewhere unfortunately needs to be hardcoded by hand # tuple of names for UDSG, B, C self.schema_ = { 'central': ('UDSG_central', 'C_central', 'B_central'), 'bc_up': ('UDSG_central', 'C_up', 'B_up'), 'bc_down': ('UDSG_central', 'C_down', 'B_down'), 'udgs_up': ('UDSG_up', 'C_central', 'B_central'), 'udsg_down': ('UDSG_down', 'C_central', 'B_central'), } effs = convert_histo_root_file(eff_file) self.eff_ = { 'B': dense_lookup(*effs[(pattern.format('bottom'), 'dense_lookup')]), 'C': dense_lookup(*effs[(pattern.format('charm'), 'dense_lookup')]), 'UDSG': dense_lookup(*effs[(pattern.format('light'), 'dense_lookup')]), }
def __init__(self, year, workingpoint): self._year = year self._wp = BTagEfficiency.btagWPs[year][workingpoint] files = { '2016': 'DeepCSV_Moriond17_B_H.csv.gz', '2017': 'DeepCSV_94XSF_V5_B_F.csv.gz', '2018': 'DeepCSV_102XSF_V1.csv.gz', } filename = os.path.join(os.path.dirname(__file__), 'data', files[year]) self.sf = BTagScaleFactor(filename, workingpoint) files = { '2016': 'btagQCD2017.coffea', '2017': 'btagQCD2017.coffea', '2018': 'btagQCD2017.coffea', } filename = os.path.join(os.path.dirname(__file__), 'data', files[year]) btag = util.load(filename) bpass = btag.integrate('btag', 'pass').values()[()] ball = btag.integrate('btag').values()[()] nom = bpass / numpy.maximum(ball, 1.) dn, up = hist.clopper_pearson_interval(bpass, ball) self.eff = dense_lookup(nom, [ax.edges() for ax in btag.axes()[1:]]) self.eff_statUp = dense_lookup(up, [ax.edges() for ax in btag.axes()[1:]]) self.eff_statDn = dense_lookup(dn, [ax.edges() for ax in btag.axes()[1:]])
def get_pu_weights_function(): pufile_ = uproot.open( join(os.getenv('FH_BASE'), 'FireHydrant/Tools/store/puWeights_10x_56ifb.root')) sf_pu_cen = dense_lookup(pufile_['puWeights'].values, pufile_['puWeights'].edges) sf_pu_up = dense_lookup(pufile_['puWeightsUp'].values, pufile_['puWeightsUp'].edges) sf_pu_down = dense_lookup(pufile_['puWeightsDown'].values, pufile_['puWeightsDown'].edges) return sf_pu_cen, sf_pu_up, sf_pu_down
def stxs_lookups(): stxs_acc_lookups = {} edges = np.array([]) values = np.array([]) for i in range(10): for k, v in stxs_acc.items(): edges = np.append(edges, k) values = np.append(values, v[i]) stxs_acc_lookups[i] = dense_lookup.dense_lookup(values, [edges]) stxs_acc_lookups[i]._axes = stxs_acc_lookups[i]._axes[0] powheg_xsec_lookup = dense_lookup.dense_lookup( np.array(list(powheg_xsec.values())), [np.array(list(powheg_xsec.keys()))]) powheg_xsec_lookup._axes = powheg_xsec_lookup._axes[0] return stxs_acc_lookups, powheg_xsec_lookup
def get_nlo_weight_function(type): kfactor = uproot.open( join(os.getenv('FH_BASE'), 'FireHydrant/Tools/store/kfactors.root')) sf_qcd = 1. sf_ewk = 1 lo = dict( z="ZJets_LO/inv_pt", w="WJets_LO/inv_pt", a="GJets_LO/inv_pt_G", ) nlo = dict( z="ZJets_012j_NLO/nominal", w="WJets_012j_NLO/nominal", a="GJets_1j_NLO/nominal_G", ) ewk = dict( z="EWKcorr/Z", w="EWKcorr/W", a="EWKcorr/photon", ) LO = kfactor[lo[type]].values NLO = kfactor[nlo[type]].values EWK = kfactor[ewk[type]].values sf_qcd = NLO / LO sf_ewk = EWK / LO correction = dense_lookup(sf_qcd * sf_ewk, kfactor[nlo[type]].edges) return correction
def _build(self, wrapped_values): self._nsets = wrapped_values['nsets'] self._members = wrapped_values['members'] # now build the lookup tables # for data scale, simple, just M A in bins of eta,phi edges = wrapped_values['edges']['scales'] M = wrapped_values['values']['M'] A = wrapped_values['values']['A'] self._M = {s: {m: {t: dense_lookup(M[s][m][t], edges) for t in M[s][m]} for m in M[s]} for s in M} self._A = {s: {m: {t: dense_lookup(A[s][m][t], edges) for t in A[s][m]} for m in A[s]} for s in A} # for mc scale, more complicated # version 1 if gen pt available # only requires the kRes lookup edges = wrapped_values['edges']['res'] kRes = wrapped_values['values']['kRes'] self._kRes = {s: {m: {t: dense_lookup(kRes[s][m][t], edges) for t in kRes[s][m]} for m in kRes[s]} for s in kRes} # version 2 if gen pt not available edges = wrapped_values['edges']['cb'] rsPars = wrapped_values['values']['rsPars'] cbS = wrapped_values['values']['cbS'] cbA = wrapped_values['values']['cbA'] cbN = wrapped_values['values']['cbN'] self._rsPars = {s: {m: {t: dense_lookup(rsPars[s][m][t], edges) for t in rsPars[s][m]} for m in rsPars[s]} for s in rsPars} self._cbS = {s: {m: dense_lookup(cbS[s][m], edges) for m in cbS[s]} for s in cbS} self._cbA = {s: {m: dense_lookup(cbA[s][m], edges) for m in cbA[s]} for s in cbA} self._cbN = {s: {m: dense_lookup(cbN[s][m], edges) for m in cbN[s]} for s in cbN} self._loaduncs = len(self._M.keys()) > 1
def _build(self, wrapped_values): self._nsets = wrapped_values["nsets"] self._members = wrapped_values["members"] # now build the lookup tables # for data scale, simple, just M A in bins of eta,phi edges = wrapped_values["edges"]["scales"] M = wrapped_values["values"]["M"] A = wrapped_values["values"]["A"] self._M = { s: {m: {t: dense_lookup(M[s][m][t], edges) for t in M[s][m]} for m in M[s]} for s in M } self._A = { s: {m: {t: dense_lookup(A[s][m][t], edges) for t in A[s][m]} for m in A[s]} for s in A } # for mc scale, more complicated # version 1 if gen pt available # only requires the kRes lookup edges = wrapped_values["edges"]["res"] kRes = wrapped_values["values"]["kRes"] self._kRes = { s: { m: {t: dense_lookup(kRes[s][m][t], edges) for t in kRes[s][m]} for m in kRes[s] } for s in kRes } # version 2 if gen pt not available edges = wrapped_values["edges"]["cb"] rsPars = wrapped_values["values"]["rsPars"] cbS = wrapped_values["values"]["cbS"] cbA = wrapped_values["values"]["cbA"] cbN = wrapped_values["values"]["cbN"] self._rsPars = { s: { m: {t: dense_lookup(rsPars[s][m][t], edges) for t in rsPars[s][m]} for m in rsPars[s] } for s in rsPars } self._cbS = { s: {m: dense_lookup(cbS[s][m], edges) for m in cbS[s]} for s in cbS } self._cbA = { s: {m: dense_lookup(cbA[s][m], edges) for m in cbA[s]} for s in cbA } self._cbN = { s: {m: dense_lookup(cbN[s][m], edges) for m in cbN[s]} for s in cbN } self._loaduncs = len(self._M.keys()) > 1
def __init__(self): self.lepSFs_ = {} for lepton in lep_info[year].keys(): SFfile = convert_histo_root_file( '%s/inputs/data/%s' % (proj_dir, lep_info[year][lepton]['filename'])) for sf_type in lep_info[year][lepton]['SFs'].keys(): if lep_info[year][lepton]['SFs'][sf_type]['available']: self.lepSFs_['%s_%s' % (lepton, sf_type)] = dense_lookup( *SFfile[(sf_type, 'dense_lookup')]) print('Lepton SF constructed')
def test_dense_lookup(): from coffea.lookup_tools.dense_lookup import dense_lookup import numpy a = ak.Array([[0.1, 0.2], [0.3]]) lookup = dense_lookup(numpy.ones(shape=(3, 4)), (numpy.linspace(0, 1, 4), numpy.linspace(0, 1, 5))) assert lookup(0.1, 0.3) == 1.0 assert numpy.all( lookup(0.1, numpy.array([0.3, 0.5])) == numpy.array([1.0, 1.0])) assert ak.to_list(lookup(a, a)) == [[1.0, 1.0], [1.0]]
def test_dense_lookup(): from coffea.lookup_tools.dense_lookup import dense_lookup import numpy import awkward1 a = awkward1.Array([[.1, .2], [.3]]) lookup = dense_lookup(numpy.ones(shape=(3, 4)), (numpy.linspace(0, 1, 4), numpy.linspace(0, 1, 5))) assert lookup(.1, .3) == 1. assert numpy.all( lookup(.1, numpy.array([.3, .5])) == numpy.array([1., 1.])) assert awkward1.to_list(lookup(a, a)) == [[1.0, 1.0], [1.0]]
def pu_lookups(parameters, mode="nom", auto=[]): lookups = {} branch = {"nom": "pileup", "up": "pileup_plus", "down": "pileup_minus"} for mode in ["nom", "up", "down"]: pu_hist_data = uproot.open(parameters["pu_file_data"])[branch[mode]].values() nbins = len(pu_hist_data) edges = [[i for i in range(nbins)]] if len(auto) == 0: pu_hist_mc = uproot.open(parameters["pu_file_mc"])["pu_mc"].values() else: pu_hist_mc = np.histogram(auto, bins=range(nbins + 1))[0] lookup = dense_lookup.dense_lookup(pu_reweight(pu_hist_data, pu_hist_mc), edges) if Version(coffea.__version__) < Version("0.7.6"): lookup._axes = lookup._axes[0] lookups[mode] = lookup return lookups
def musf_lookup(parameters): mu_id_vals = 0 mu_id_err = 0 mu_iso_vals = 0 mu_iso_err = 0 mu_trig_vals_data = 0 mu_trig_err_data = 0 mu_trig_vals_mc = 0 mu_trig_err_mc = 0 for scaleFactors in parameters['muSFFileList']: id_file = uproot.open(scaleFactors['id'][0]) iso_file = uproot.open(scaleFactors['iso'][0]) trig_file = uproot.open(scaleFactors['trig'][0]) mu_id_vals += id_file[scaleFactors['id'][1]].values * scaleFactors['scale'] mu_id_err += id_file[scaleFactors['id'][1]].variances**0.5 * scaleFactors['scale'] mu_id_edges = id_file[scaleFactors['id'][1]].edges mu_iso_vals += iso_file[scaleFactors['iso'][1]].values * scaleFactors['scale'] mu_iso_err += iso_file[scaleFactors['iso'][1]].variances**0.5 * scaleFactors['scale'] mu_iso_edges = iso_file[scaleFactors['iso'][1]].edges mu_trig_vals_data += trig_file[scaleFactors['trig'][1]].values * scaleFactors['scale'] mu_trig_vals_mc += trig_file[scaleFactors['trig'][2]].values * scaleFactors['scale'] mu_trig_err_data += trig_file[scaleFactors['trig'][1]].variances**0.5 * scaleFactors['scale'] mu_trig_err_mc += trig_file[scaleFactors['trig'][2]].variances**0.5 * scaleFactors['scale'] mu_trig_edges = trig_file[scaleFactors['trig'][1]].edges mu_id_sf = dense_lookup.dense_lookup(mu_id_vals, mu_id_edges) mu_id_err = dense_lookup.dense_lookup(mu_id_err, mu_id_edges) mu_iso_sf = dense_lookup.dense_lookup(mu_iso_vals, mu_iso_edges) mu_iso_err = dense_lookup.dense_lookup(mu_iso_err, mu_iso_edges) mu_trig_eff_data = dense_lookup.dense_lookup(mu_trig_vals_data, mu_trig_edges) mu_trig_eff_mc = dense_lookup.dense_lookup(mu_trig_vals_mc, mu_trig_edges) mu_trig_err_data = dense_lookup.dense_lookup(mu_trig_err_data, mu_trig_edges) mu_trig_err_mc = dense_lookup.dense_lookup(mu_trig_err_mc, mu_trig_edges) return (mu_id_sf, mu_id_err, mu_iso_sf, mu_iso_err, mu_trig_eff_data,\ mu_trig_eff_mc, mu_trig_err_data, mu_trig_err_mc)
def pu_lookup(parameters, mode='nom', auto=[]): if mode=='nom': pu_hist_data = uproot.open(parameters['pu_file_data'])['pileup'] elif mode=='up': pu_hist_data = uproot.open(parameters['pu_file_data'])['pileup_plus'] elif mode=='down': pu_hist_data = uproot.open(parameters['pu_file_data'])['pileup_minus'] else: print("PU lookup: incorrect mode ", mode) return nbins = len(pu_hist_data) edges = [[i for i in range(nbins)]] if len(auto)==0: pu_hist_mc = uproot.open(parameters['pu_file_mc'])['pu_mc'] else: pu_hist_mc = np.histogram(auto, bins=range(nbins+1))[0] lookup = dense_lookup.dense_lookup(pu_reweight(pu_hist_data, pu_hist_mc), edges) lookup._axes = lookup._axes[0] return lookup
def musf_lookup(parameters): mu_id_vals = 0 mu_id_err = 0 mu_iso_vals = 0 mu_iso_err = 0 mu_trig_vals_data = 0 mu_trig_err_data = 0 mu_trig_vals_mc = 0 mu_trig_err_mc = 0 for scaleFactors in parameters["muSFFileList"]: id_file = uproot.open(scaleFactors["id"][0]) iso_file = uproot.open(scaleFactors["iso"][0]) trig_file = uproot.open(scaleFactors["trig"][0]) mu_id_vals += id_file[scaleFactors["id"][1]].values() * scaleFactors["scale"] mu_id_err += ( id_file[scaleFactors["id"][1]].variances() ** 0.5 * scaleFactors["scale"] ) mu_id_edges = [ id_file[scaleFactors["id"][1]].axis(0).edges(), id_file[scaleFactors["id"][1]].axis(1).edges(), ] mu_iso_vals += iso_file[scaleFactors["iso"][1]].values() * scaleFactors["scale"] mu_iso_err += ( iso_file[scaleFactors["iso"][1]].variances() ** 0.5 * scaleFactors["scale"] ) mu_iso_edges = [ iso_file[scaleFactors["iso"][1]].axis(0).edges(), iso_file[scaleFactors["iso"][1]].axis(1).edges(), ] mu_trig_vals_data += ( trig_file[scaleFactors["trig"][1]].values() * scaleFactors["scale"] ) mu_trig_vals_mc += ( trig_file[scaleFactors["trig"][2]].values() * scaleFactors["scale"] ) mu_trig_err_data += ( trig_file[scaleFactors["trig"][1]].variances() ** 0.5 * scaleFactors["scale"] ) mu_trig_err_mc += ( trig_file[scaleFactors["trig"][2]].variances() ** 0.5 * scaleFactors["scale"] ) mu_trig_edges = [ trig_file[scaleFactors["trig"][1]].axis(0).edges(), trig_file[scaleFactors["trig"][1]].axis(1).edges(), ] mu_id_sf = dense_lookup.dense_lookup(mu_id_vals, mu_id_edges) mu_id_err = dense_lookup.dense_lookup(mu_id_err, mu_id_edges) mu_iso_sf = dense_lookup.dense_lookup(mu_iso_vals, mu_iso_edges) mu_iso_err = dense_lookup.dense_lookup(mu_iso_err, mu_iso_edges) mu_trig_eff_data = dense_lookup.dense_lookup(mu_trig_vals_data, mu_trig_edges) mu_trig_eff_mc = dense_lookup.dense_lookup(mu_trig_vals_mc, mu_trig_edges) mu_trig_err_data = dense_lookup.dense_lookup(mu_trig_err_data, mu_trig_edges) mu_trig_err_mc = dense_lookup.dense_lookup(mu_trig_err_mc, mu_trig_edges) return { "mu_id_sf": mu_id_sf, "mu_id_err": mu_id_err, "mu_iso_sf": mu_iso_sf, "mu_iso_err": mu_iso_err, "mu_trig_eff_data": mu_trig_eff_data, "mu_trig_eff_mc": mu_trig_eff_mc, "mu_trig_err_data": mu_trig_err_data, "mu_trig_err_mc": mu_trig_err_mc, }
def __init__(self, runNum=-1, eventNum=-1, mcEventYields=None): self.mcEventYields = mcEventYields dataset_axis = hist.Cat("dataset", "Dataset") lep_axis = hist.Bin("lepFlavor", r"ElectronOrMuon", 2, -1, 1) lep_axis.identifiers()[0].label = 'Electron' lep_axis.identifiers()[1].label = 'Muon' m3_axis = hist.Bin("M3", r"$M_3$ [GeV]", 200, 0., 1000) mass_axis = hist.Bin("mass", r"$m_{\ell\gamma}$ [GeV]", 400, 0., 400) pt_axis = hist.Bin("pt", r"$p_{T}$ [GeV]", 200, 0., 1000) eta_axis = hist.Bin("eta", r"$\eta_{\gamma}$", 300, -1.5, 1.5) chIso_axis = hist.Bin("chIso", r"Charged Hadron Isolation", np.arange(-0.1, 20.001, .05)) ## Define axis to keep track of photon category phoCategory_axis = hist.Bin("category", r"Photon Category", [1, 2, 3, 4, 5]) phoCategory_axis.identifiers()[0].label = "Genuine Photon" phoCategory_axis.identifiers()[1].label = "Misidentified Electron" phoCategory_axis.identifiers()[2].label = "Hadronic Photon" phoCategory_axis.identifiers()[3].label = "Hadronic Fake" ### self._accumulator = processor.dict_accumulator({ ##photon histograms 'photon_pt': hist.Hist("Counts", dataset_axis, pt_axis, phoCategory_axis, lep_axis), 'photon_eta': hist.Hist("Counts", dataset_axis, eta_axis, phoCategory_axis, lep_axis), 'photon_chIso': hist.Hist("Counts", dataset_axis, chIso_axis, phoCategory_axis, lep_axis), 'photon_chIsoSideband': hist.Hist("Counts", dataset_axis, chIso_axis, phoCategory_axis, lep_axis), 'photon_lepton_mass': hist.Hist("Counts", dataset_axis, mass_axis, phoCategory_axis, lep_axis), 'photon_lepton_mass_3j0t': hist.Hist("Counts", dataset_axis, mass_axis, phoCategory_axis, lep_axis), 'M3': hist.Hist("Counts", dataset_axis, m3_axis, phoCategory_axis, lep_axis), 'M3Presel': hist.Hist("Counts", dataset_axis, m3_axis, lep_axis), 'EventCount': processor.value_accumulator(int) }) self.eventNum = eventNum self.runNum = runNum ext = extractor() ext.add_weight_sets([ f"btag2016 * {cwd}/ScaleFactors/Btag/DeepCSV_2016LegacySF_V1.btag.csv" ]) ext.finalize() self.evaluator = ext.make_evaluator() ele_id_file = uproot.open( f'{cwd}/ScaleFactors/MuEGammaScaleFactors/ele2016/2016LegacyReReco_ElectronTight_Fall17V2.root' ) self.ele_id_sf = dense_lookup.dense_lookup( ele_id_file["EGamma_SF2D"].values, ele_id_file["EGamma_SF2D"].edges) self.ele_id_err = dense_lookup.dense_lookup( ele_id_file["EGamma_SF2D"].variances**0.5, ele_id_file["EGamma_SF2D"].edges) ele_reco_file = uproot.open( f'{cwd}/ScaleFactors/MuEGammaScaleFactors/ele2016/egammaEffi.txt_EGM2D_runBCDEF_passingRECO.root' ) self.ele_reco_sf = dense_lookup.dense_lookup( ele_reco_file["EGamma_SF2D"].values, ele_reco_file["EGamma_SF2D"].edges) self.ele_reco_err = dense_lookup.dense_lookup( ele_reco_file["EGamma_SF2D"].variances**.5, ele_reco_file["EGamma_SF2D"].edges) mu_id_vals = 0 mu_id_err = 0 mu_iso_vals = 0 mu_iso_err = 0 mu_trig_vals = 0 mu_trig_err = 0 for scaleFactors in muSFFileList: id_file = uproot.open(scaleFactors['id'][0]) iso_file = uproot.open(scaleFactors['iso'][0]) trig_file = uproot.open(scaleFactors['trig'][0]) mu_id_vals += id_file[scaleFactors['id'] [1]].values * scaleFactors['scale'] mu_id_err += id_file[scaleFactors['id'] [1]].variances**0.5 * scaleFactors['scale'] mu_id_edges = id_file[scaleFactors['id'][1]].edges mu_iso_vals += iso_file[scaleFactors['iso'] [1]].values * scaleFactors['scale'] mu_iso_err += iso_file[scaleFactors['iso'] [1]].variances**0.5 * scaleFactors['scale'] mu_iso_edges = iso_file[scaleFactors['iso'][1]].edges mu_trig_vals += trig_file[scaleFactors['trig'] [1]].values * scaleFactors['scale'] mu_trig_err += trig_file[ scaleFactors['trig'][1]].variances**0.5 * scaleFactors['scale'] mu_trig_edges = trig_file[scaleFactors['trig'][1]].edges self.mu_id_sf = dense_lookup.dense_lookup(mu_id_vals, mu_id_edges) self.mu_id_err = dense_lookup.dense_lookup(mu_id_err, mu_id_edges) self.mu_iso_sf = dense_lookup.dense_lookup(mu_iso_vals, mu_iso_edges) self.mu_iso_err = dense_lookup.dense_lookup(mu_iso_err, mu_iso_edges) self.mu_trig_sf = dense_lookup.dense_lookup(mu_trig_vals, mu_trig_edges) self.mu_trig_err = dense_lookup.dense_lookup(mu_trig_err, mu_trig_edges)
def find_alpha_correction(medians, xbins, output_xbins, errors=None, ybins=None, output_ybins=None, degree=None, Fit=None): #set_trace() if np.ndim(medians) == 1: if (medians < 0).sum() > 0: print("Not all median input values are valid!") # raise ValueError("Not all median input values are valid!") #set_trace() valid_medians = medians[medians != -10.] valid_xbins = xbins[medians != -10.] if Fit is None: deg = 1 if degree is None else degree #set_trace() np_fit = np.polyfit( valid_xbins, valid_medians, deg, w=np.reciprocal(errors[medians != -10.]), full=True) if errors is not None else np.polyfit( valid_xbins, valid_medians, deg, full=True) chisq_ndof = np_fit[1] / (len(valid_xbins) - (deg + 1)) fitvals = np.poly1d(np_fit[0])(output_xbins) lookup = dense_lookup(*(fitvals, output_xbins)) return lookup, fitvals, chisq_ndof elif Fit == 'Sqrt': #set_trace() p0 = [0.5, 0.5, 0.5] popt, pcov = curve_fit(sqrt_x, valid_xbins, valid_medians, p0, method='dogbox') #popt, pcov = curve_fit(sqrt_x, xbins, medians, p0, method='dogbox') #popt, pcov = curve_fit(sqrt_x, xbins, medians, p0, bounds=(xbins[0], xbins[-1]), method='dogbox') fitvals = sqrt_x(output_xbins, *popt) lookup = dense_lookup(*(fitvals, output_xbins)) return lookup, fitvals elif Fit == 'Sigmoid': #set_trace() set_trace() p0 = [1., 1., 1., 0.5] # this is an mandatory initial guess #p0 = [max(medians), min(xbins), 1, min(medians)] # this is an mandatory initial guess #p0 = [max(medians), np.median(xbins), 1, min(medians)] # this is an mandatory initial guess popt, pcov = curve_fit(sigmoid, xbins, medians, method='dogbox') #popt, pcov = curve_fit(sigmoid, xbins, medians, p0, bounds=(xbins[0], xbins[-1]), method='dogbox') fitvals = sigmoid(output_xbins, *popt) lookup = dense_lookup(*(fitvals, output_xbins)) return lookup, fitvals else: # get x bincenter range by finding first and last bin that has valid medians for all mtt bins first_xbin, last_xbin = np.where( (medians > 0).all(axis=0))[0][0], np.where( (medians > 0).all(axis=0))[0][-1] fit_ybins = np.array([ (ybins[i + 1] + ybins[i]) / 2 for i in range(len(ybins) - 1) ]) # ybins to be used in interpolation valid_medians = medians[:, first_xbin:last_xbin + 1] deg = 'linear' if degree is None else degree fit = interpolate.interp2d(xbins, fit_ybins, valid_medians, kind=deg) fitvals = fit(output_xbins, output_ybins) lookup = dense_lookup(*(fitvals, (output_xbins, output_ybins))) return lookup, fitvals
fig, ax = plt.subplots() fig.subplots_adjust(hspace=.07) hslice = h_tot[lepcat].integrate('lepcat') hslice = hslice.group( pcat_cat, pcat, pcat_groups) ## make groups based on perm category if rebinning != 1: xaxis_name = hslice.dense_axes()[0].name hslice = hslice.rebin(xaxis_name, rebinning) # save distribution to dict if save_dist and (lepcat == 'Tight'): hcor = hslice['Correct'].integrate('permcat') edges = hcor.dense_axes()[0].edges() lookup = dense_lookup(*(hcor.values().values()), edges) # not normalized permProbs[year]['3Jets'].update({hname: lookup}) ## plot comparison of perm categories plot.plot1d( hslice, overlay=hslice.axes()[0].name, ax=ax, clear=False, line_opts={'linestyle': '-'}, density=True, # normalized to 1, ) ax.autoscale() #, tight=True) ax.set_ylim(0, ax.get_ylim()[1] * 1.15) ax.set_ylabel('Probability Density') ax.set_xlabel(xtitle)
ID_DEN_genTracks_eta_pt"), 'iso': (f"mu2016/EfficienciesStudies_2016_legacy_rereco_rootfiles_RunGH_SF_ISO.root", "NUM_Tight\ RelIso_DEN_TightIDandIPCut_eta_pt"), 'trig': (f"mu2016/EfficienciesStudies_2016_trigger_EfficienciesAndSF_RunGtoH.root", "IsoMu24_OR_I\ soTkMu24_PtEtaBins/abseta_pt_ratio"), 'scale': 16.226452636 / 35.882515396 }] ele_id_file = uproot.open( f'ele2016/2016LegacyReReco_ElectronTight_Fall17V2.root') ele_id_sf = dense_lookup.dense_lookup(ele_id_file["EGamma_SF2D"].values, ele_id_file["EGamma_SF2D"].edges) ele_id_err = dense_lookup.dense_lookup( ele_id_file["EGamma_SF2D"].variances**0.5, ele_id_file["EGamma_SF2D"].edges) ele_reco_file = uproot.open( f'ele2016/egammaEffi.txt_EGM2D_runBCDEF_passingRECO.root') ele_reco_sf = dense_lookup.dense_lookup(ele_reco_file["EGamma_SF2D"].values, ele_reco_file["EGamma_SF2D"].edges) ele_reco_err = dense_lookup.dense_lookup( ele_reco_file["EGamma_SF2D"].variances**.5, ele_reco_file["EGamma_SF2D"].edges) mu_id_vals = 0 mu_id_err = 0 mu_iso_vals = 0
Plotter.plot_1D(orig_vals, orig_bins, xlabel=var_opts[var]["xtitle"], ylabel=var_opts[var]["ytitle"], color=year_opts[year]["col"], ax=ax, label="%s Original" % year_opts[year]["leg_title"]) # get interpolated values from ROOT Interpolate orig_ratio_hist = Hist(orig_bins, name="", title="") for xbin in range(1, orig_bins.size): orig_ratio_hist[xbin] = orig_vals[xbin-1] output_bins = np.arange(min(orig_bins), max(orig_bins)+10, 10) interped_array = np.zeros(output_bins.size-1) for xbin in range(output_bins.size-1): interped_array[xbin] = orig_ratio_hist.Interpolate(output_bins[xbin]) Plotter.plot_1D(interped_array, output_bins, xlabel=var_opts[var]["xtitle"], ylabel=var_opts[var]["ytitle"], color=year_opts[year]["col"], ax=ax, label="%s Interp" % (year_opts[year]["leg_title"]), linestyle="--") if args.save_ratios: lookup = dense_lookup(*(interped_array, output_bins)) ratios[year].update({"%s_Interp" % var : lookup}) else: (orig_xbins, orig_ybins), orig_vals = histo._axes, histo._values orig_ratio_hist = Hist2D(orig_xbins, orig_ybins, name="mtt_ctstar", title="mtt_ctstar") for ybin in range(1, orig_ybins.size): for xbin in range(1, orig_xbins.size): orig_ratio_hist[xbin, ybin] = orig_vals[xbin-1][ybin-1] output_xbins = np.arange(min(orig_xbins), max(orig_xbins)+10, 10) output_ybins = np.arange(min(orig_ybins), max(orig_ybins)+0.05, 0.05) interped_array = np.zeros((output_xbins.size-1, output_ybins.size-1)) for ybin in range(output_ybins.size-1): for xbin in range(output_xbins.size-1): interped_array[xbin, ybin] = orig_ratio_hist.Interpolate(output_xbins[xbin], output_ybins[ybin])
b_total = output['hJets'].integrate('jetFlav', slice(5, 6)).values() l_tagged = output['hBJets'].integrate('jetFlav', slice(0, 4)).values() c_tagged = output['hBJets'].integrate('jetFlav', slice(4, 5)).values() b_tagged = output['hBJets'].integrate('jetFlav', slice(5, 6)).values() for k in l_total.keys(): l_total[k] = np.maximum(1, l_total[k]) c_total[k] = np.maximum(1, c_total[k]) b_total[k] = np.maximum(1, b_total[k]) if 0 in l_total[k]: print(k, 'light', l_total[k]) if 0 in l_total[k]: print(k, 'charm', c_total[k]) if 0 in l_total[k]: print(k, 'b', b_total[k]) btagEff = [] samples = [] for k in l_total.keys(): btagEff.append( np.array([ l_tagged[k] / l_total[k], c_tagged[k] / c_total[k], b_tagged[k] / b_total[k] ])) samples.append(k[0]) taggingEffLookup = dense_lookup.dense_lookup( np.array(btagEff), (samples, [0, 4, 5], btagEff_ptBins, btagEff_etaBins)) with open('taggingEfficienciesDenseLookup.pkl', 'wb') as _file: pickle.dump(taggingEffLookup, _file)
sf_file = convert_histo_root_file( os.path.join(proj_dir, 'inputs', 'data', base_jobid, 'lepSFs', fname)) eta_binning = sf_file[(leptons[lep]['eta'], 'dense_lookup')][1][0] #if lep == 'Muons': set_trace() sf_output[year][lep]['eta_ranges'] = [ (eta_binning[idx], eta_binning[idx + 1]) for idx in range(len(eta_binning) - 1) ] for idx in range(len(eta_binning) - 1): # reco/ID SFs sf_output[year][lep]['Reco_ID']['Central'][ 'eta_bin%i' % idx] = dense_lookup( *(sf_file[(leptons[lep]['pt']['reco_id'][idx], 'dense_lookup')][0], sf_file[(leptons[lep]['pt']['reco_id'][idx], 'dense_lookup')][1][0])) sf_output[year][lep]['Reco_ID']['Error'][ 'eta_bin%i' % idx] = dense_lookup( *(sf_file[('%s_error' % leptons[lep]['pt']['reco_id'][idx], 'dense_lookup')][0], sf_file[('%s_error' % leptons[lep]['pt']['reco_id'][idx], 'dense_lookup')][1][0])) # trigger SFs sf_output[year][lep]['Trig']['Central'][ 'eta_bin%i' % idx] = dense_lookup(*(sf_file[(leptons[lep]['pt']['trig'][idx], 'dense_lookup')][0], sf_file[(leptons[lep]['pt']['trig'][idx], 'dense_lookup')][1][0]))
# sig_dname = "_".join([boson, pos_evt_fraction_name]) # name of signal dist # vals = dense_lookup(*fdict[(sig_dname, "dense_lookup")]) # errs = dense_lookup(*fdict[(f"{sig_dname}_error", "dense_lookup")]) # create dict of LO xsection values and errors #set_trace() LO_outdict = {} for boson in bosons: for proc, proc_name in procs.items(): for scale in scales: for xsec_type in types: for channel, chan_name in channels.items(): sig_dname = "_".join([ boson, proc, mg5_LO_xsecs_name, scale, xsec_type, channel ]) vals = dense_lookup(*fdict[(sig_dname, "dense_lookup")]) errs = dense_lookup(*fdict[(f"{sig_dname}_error", "dense_lookup")]) for mtt in masses: for width in widths: outname = f"{boson}toTTJets{chan_name}_M{mtt}_W{widthTOname(width)}_{proc_name}" if scale != "nominal": outname = f"{outname}_{scale}" LO_outdict[outname] = vals(mtt, width) lo_xsec_fname = os.path.join(proj_dir, "inputs", "signal_xsecs.json") with open(lo_xsec_fname, "w") as out: out.write(prettyjson.dumps(LO_outdict)) print(f"{lo_xsec_fname} written")
## plot ratios normed_ratio_vals, normed_ratio_bins = Plotter.get_ratio_arrays(num_vals=nnlo_normed_histo.values()[()], denom_vals=tune_normed_histo.values()[()], input_bins=nnlo_normed_histo.dense_axes()[0].edges()) # orig rax_norm.step(normed_ratio_bins, normed_ratio_vals, where="post", **{"linestyle" : "-", "color" : style_dict[year][1]}) # logy rax_norm_logy.step(normed_ratio_bins, normed_ratio_vals, where="post", **{"linestyle" : "-", "color" : style_dict[year][1]}) ## update min/max values if np.min(tune_histo.values()[()]) < logy_min: logy_min = np.min(tune_histo.values()[()]) if np.max(tune_histo.values()[()]) > logy_max: logy_max = np.max(tune_histo.values()[()]) if np.min(tune_normed_histo.values()[()]) < normed_logy_min: normed_logy_min = np.min(tune_normed_histo.values()[()]) if np.max(tune_normed_histo.values()[()]) > normed_logy_max: normed_logy_max = np.max(tune_normed_histo.values()[()]) if args.save_ratios: set_trace() save_dict[year][tune_var] = dense_lookup(normed_ratio_vals[:-1], (nnlo_binning)) if vlines is None else dense_lookup(normed_ratio_vals[:-1].reshape(len(mtt_binning)-1,len(ctstar_binning)-1), (mtt_binning, ctstar_binning)) # plot yields # format axes ax.autoscale()#axis="x", tight=True) ax.set_ylim(None, ax.get_ylim()[1]*1.15) ax.set_xlabel(None) ax.set_ylabel("%s [pb/GeV]" % ytitle) rax.axhline(1, **{"linestyle": "--", "color": (0, 0, 0, 0.5), "linewidth": 1}) rax.set_ylabel("NNLO/Tune") if vlines is None: rax.set_xlabel(xtitle) # set plotting styles ## set legend and corresponding colors