def __init__(self, region='SR', data_type='bkg'): self.region = region self.data_type = data_type dataset_axis = hist.Cat('dataset', 'dataset') pt_axis = hist.Bin('pt', '$p_T$ [GeV]', 100, 0, 200) invm_axis = hist.Bin('invm', 'mass [GeV]', 100, 0, 200) mass_axis = hist.Bin('mass', 'mass [GeV]', 100, 0, 200) channel_axis = hist.Bin('channel', 'channel', 3, 0, 3) self._accumulator = processor.dict_accumulator({ 'pt0': hist.Hist('Counts', dataset_axis, pt_axis, channel_axis), 'pt1': hist.Hist('Counts', dataset_axis, pt_axis, channel_axis), 'ptegm': hist.Hist('Counts', dataset_axis, pt_axis, channel_axis), # leading EGM-type for 2mu2e channel 'ptmu': hist.Hist('Counts', dataset_axis, pt_axis, channel_axis), # leading mu-type for 2mu2e channel 'invm': hist.Hist('Counts', dataset_axis, invm_axis, channel_axis), 'massmu': hist.Hist('Counts', dataset_axis, mass_axis, channel_axis), # mass of mu-type leptonjet }) self.pucorrs = get_pu_weights_function() ## NOT applied for now self.nlo_w = get_nlo_weight_function('w') self.nlo_z = get_nlo_weight_function('z')
def __init__(self, year='2018', corrections={}): self._year = year self._corrections = corrections self._rochester = lookup_tools.rochester_lookup.rochester_lookup( corrections['rochester_data']) dataset_axis = hist.Cat("dataset", "Primary dataset") channel_axis = hist.Cat("channel", "Channel") zmass_axis = hist.Bin("mass", r"$m_{2\ell}$ [GeV]", 240, 0, 120) met_axis = hist.Bin("met", r"$E_{T}^{miss}$ [GeV]", 3000, 0, 3000) npvs_axis = hist.Bin("npvs", "Number of Vertices", 120, 0, 120) self._selections = ['massWindow'] hist.Hist.DEFAULT_DTYPE = 'f' # save some space by keeping float bin counts instead of double self._accumulator = processor.dict_accumulator() for sel in self._selections: self._accumulator[sel + '_zmass'] = hist.Hist( "Counts", dataset_axis, channel_axis, zmass_axis) self._accumulator[sel + '_met'] = hist.Hist( "Counts", dataset_axis, channel_axis, met_axis) self._accumulator[sel + '_pileup'] = hist.Hist( "Counts", dataset_axis, channel_axis, npvs_axis) self._accumulator['cutflow'] = processor.defaultdict_accumulator(int) self._accumulator['sumw'] = processor.defaultdict_accumulator(int)
def __init__(self): ## make binning for hists self.dataset_axis = hist.Cat("dataset", "Event Process") self.pu_nTrueInt_axis = hist.Bin("pu_nTrueInt", "nTrueInt", 100, 0, 100) self.pu_nPU_axis = hist.Bin("pu_nPU", "nPU", 100, 0, 100) ## make dictionary of hists histo_dict = {} histo_dict['PU_nTrueInt'] = hist.Hist("PU_nTrueInt", self.dataset_axis, self.pu_nTrueInt_axis) histo_dict['PU_nPU'] = hist.Hist("PU_nPU", self.dataset_axis, self.pu_nPU_axis) #set_trace() ## construct dictionary of dictionaries to hold meta info for each sample for sample in fileset.keys(): if 'Int' in sample: histo_dict['%s_pos' % sample] = processor.defaultdict_accumulator(int) histo_dict['%s_pos_runs_to_lumis' % sample] = processor.value_accumulator(list) histo_dict['%s_neg' % sample] = processor.defaultdict_accumulator(int) histo_dict['%s_neg_runs_to_lumis' % sample] = processor.value_accumulator(list) else: histo_dict[sample] = processor.defaultdict_accumulator(int) histo_dict['%s_runs_to_lumis' % sample] = processor.value_accumulator(list) self._accumulator = processor.dict_accumulator(histo_dict) self.sample_name = ''
def __init__(self): # we can use a large number of bins and rebin later dataset_axis = hist.Cat("dataset", "Primary dataset") pt_axis = hist.Bin("pt", r"$p_{T}$ (GeV)", 600, 0, 1000) eta_axis = hist.Bin("eta", r"$\eta$", 60, -5.5, 5.5) multiplicity_axis = hist.Bin("multiplicity", r"N", 20, -0.5, 19.5) self._accumulator = processor.dict_accumulator({ "MET_pt" : hist.Hist("Counts", dataset_axis, pt_axis), "Jet_pt" : hist.Hist("Counts", dataset_axis, pt_axis), "Jet_pt_fwd" : hist.Hist("Counts", dataset_axis, pt_axis), "Jet_eta" : hist.Hist("Counts", dataset_axis, eta_axis), "GenJet_pt_fwd" : hist.Hist("Counts", dataset_axis, pt_axis), "Spectator_pt" : hist.Hist("Counts", dataset_axis, pt_axis), "Spectator_eta" : hist.Hist("Counts", dataset_axis, eta_axis), "W_pt_notFromTop" : hist.Hist("Counts", dataset_axis, pt_axis), "Top_pt" : hist.Hist("Counts", dataset_axis, pt_axis), "Top_eta" : hist.Hist("Counts", dataset_axis, eta_axis), "Antitop_pt" : hist.Hist("Counts", dataset_axis, pt_axis), "Antitop_eta" : hist.Hist("Counts", dataset_axis, eta_axis), "W_pt" : hist.Hist("Counts", dataset_axis, pt_axis), "W_eta" : hist.Hist("Counts", dataset_axis, eta_axis), "N_b" : hist.Hist("Counts", dataset_axis, multiplicity_axis), "N_jet" : hist.Hist("Counts", dataset_axis, multiplicity_axis), 'cutflow_bkg': processor.defaultdict_accumulator(int), 'cutflow_signal': processor.defaultdict_accumulator(int), })
def __init__(self): # dataset_axis = hist.Cat("dataset", "Primary dataset") # pt_axis = hist.Bin("pt", r"$p_{T}$ [GeV]", 40, 0, 3500) ntrack_axis = hist.Bin("ntracks", "Number of Tracks", 20, 0.0, 500.0) njet_axis = hist.Bin("njets", "Number of Jets", 20, 0.0, 20.0) ht_axis = hist.Bin("ht", "H_{T} (GeV)", 500, 0.0, 5000.0) st_axis = hist.Bin("st", "S_{T} (GeV)", 500, 0.0, 5000.0) met_axis = hist.Bin("MET", "E_{T}^{miss} (GeV)", 200, 0.0, 2000.0) self._accumulator = processor.dict_accumulator({ # 'jtpt':hist.Hist("Counts", dataset_axis, pt_axis), # 'jteta':hist.Hist("Counts",dataset_axis,eta_axis), 'h_ntracks': hist.Hist("h_ntracks", ntrack_axis), 'h_njets': hist.Hist("h_njets", njet_axis), 'h_ht': hist.Hist("h_ht", ht_axis), 'h_st': hist.Hist("h_st", st_axis), 'h_met': hist.Hist("h_met", met_axis), 'cutflow': processor.defaultdict_accumulator(int), 'trigger': processor.defaultdict_accumulator(int), })
def get_scaled_yield(hin_dict, year, proc, cat): #h = hin_dict["ht"] h = hin_dict["njets"] h = integrate_out_cats(h, CATEGORIES[cat]) h = h.integrate("systematic", "nominal") if '2l' in cat: h = h.rebin( 'njets', hist.Bin("njets", "Jet multiplicity ", [4, 5, 6, 7, 8, 9, 10])) elif '3l' in cat: h = h.rebin( 'njets', hist.Bin("njets", "Jet multiplicity ", [2, 3, 4, 5, 6, 7, 8, 9, 10])) elif '4l' in cat: h = h.rebin( 'njets', hist.Bin("njets", "Jet multiplicity ", [2, 3, 4, 5, 6, 7, 8, 9, 10])) lumi = 1000.0 * get_lumi(year) h_sow = hin_dict["SumOfEFTweights"] nwc = h_sow._nwc if nwc > 0: sow = get_yield(h_sow, proc) h.scale(1.0 / sow) # Divide EFT samples by sum of weights at SM #print("Num of WCs:",nwc) #print("Sum of weights:",sow) yld = lumi * get_yield(h, proc) return yld
def __init__(self, year, ids, xsec, common): self._year = year self._lumi = 1000. * float(PhotonPurity.lumis[year]) self._xsec = xsec self._accumulator = processor.dict_accumulator({ 'sumw': hist.Hist('sumw', hist.Cat('dataset', 'Dataset'), hist.Bin('sumw', 'Weight value', [0.])), 'count': hist.Hist('Events', hist.Cat('dataset', 'Dataset'), hist.Cat('cat', 'Cat'), hist.Bin('pt', 'Photon pT', 50, 200, 1200), hist.Bin('sieie', 'sieie', 100, 0, 0.02)) }) self._singlephoton_triggers = { '2016': ['Photon175', 'Photon165_HE10'], '2017': ['Photon200'], '2018': ['Photon200'] } self._ids = ids self._common = common
def __init__(self, data_type='bkg', bothNeutral=True): dataset_axis = hist.Cat('dataset', 'dataset') sumpt_axis = hist.Bin('sumpt', '$\sum p_T$ [GeV]', 50, 0, 50) iso_axis = hist.Bin('iso', 'Isolation', np.arange(0, 1, 0.04)) channel_axis = hist.Bin('channel', 'channel', 3, 0, 3) self._accumulator = processor.dict_accumulator({ 'sumpt': hist.Hist('Counts', dataset_axis, sumpt_axis, channel_axis), 'pfiso': hist.Hist('Counts', dataset_axis, iso_axis, channel_axis), 'isodbeta': hist.Hist('Counts', dataset_axis, iso_axis, channel_axis), 'minpfiso': hist.Hist('Counts', dataset_axis, iso_axis, channel_axis), 'maxpfiso': hist.Hist('Counts', dataset_axis, iso_axis, channel_axis), 'lj0pfiso': hist.Hist('Counts', dataset_axis, iso_axis, channel_axis), }) self.pucorrs = get_pu_weights_function() ## NOT applied for now self.nlo_w = get_nlo_weight_function('w') self.nlo_z = get_nlo_weight_function('z') self.data_type = data_type self.bothNeutral = bothNeutral
def __init__(self): dataset_axis = hist.Cat("dataset", "Primary dataset") mass_axis = hist.Bin("mass", r"$m$", 50, 0., 500.) pt_axis = hist.Bin("pt", r"$p_{T,h}$ [GeV]", 120, 0., 1200.) self._accumulator = processor.dict_accumulator({ "hmass":hist.Hist("Counts", dataset_axis, mass_axis), 'hpt': hist.Hist("Counts", dataset_axis, pt_axis), })
def __init__(self): dataset_axis = hist.Cat('dataset', 'dataset') sumpt_axis = hist.Bin('sumpt', '$\sum p_T$ [GeV]', 50, 0, 50) iso_axis = hist.Bin('iso', 'Isolation', 50, 0, 1) self._accumulator = processor.dict_accumulator({ 'sumpt': hist.Hist('Counts', dataset_axis, sumpt_axis), 'pfiso': hist.Hist('Counts', dataset_axis, iso_axis), })
def __init__(self): dataset_axis = hist.Cat('dataset', 'dataset') ms_axis = hist.Bin('mass_s', 'mass [GeV]', 50, 0, 200) mm_axis = hist.Bin('mass_m', 'mass [GeV]', 50, 250, 750) ml_axis = hist.Bin('mass_l', 'mass [GeV]', 50, 500, 1500) self._accumulator = processor.dict_accumulator({ 'invm_s': hist.Hist('Norm. Frequency', dataset_axis, ms_axis), 'invm_m': hist.Hist('Norm. Frequency', dataset_axis, mm_axis), 'invm_l': hist.Hist('Norm. Frequency', dataset_axis, ml_axis), })
def __init__(self, year='2017'): self._year = year self._accumulator = hist.Hist( 'Events', hist.Cat('btag', 'BTag WP pass/fail'), hist.Bin('flavor', 'Jet hadronFlavour', [0, 4, 5, 6]), hist.Bin('pt', 'Jet pT', [20, 30, 50, 70, 100, 140, 200, 300, 600, 1000]), hist.Bin('abseta', 'Jet abseta', [0, 1.4, 2.0, 2.5]), )
def __init__(self, year='2017'): self._year = year self._triggers = { '2017': [ 'PFHT1050', 'AK8PFJet400_TrimMass30', 'AK8PFJet420_TrimMass30', 'AK8PFHT800_TrimMass50', 'PFJet500', 'AK8PFJet500', 'AK8PFJet550', 'CaloJet500_NoJetID', 'CaloJet550_NoJetID', ] } self._muontriggers = { '2017': [ 'Mu50', #'TkMu50', ] } self._accumulator = processor.dict_accumulator({ 'sumw': processor.defaultdict_accumulator(float), 'templates': hist.Hist( 'Events', hist.Cat('dataset', 'Dataset'), hist.Cat('region', 'Region'), #hist.Cat('systematic', 'Systematic'), hist.Bin('pt', r'Jet $p_{T}$ [GeV]', 25,500,1000),#[525,575,625,700,800,1500]),#np.arange(525,2000,50)), hist.Bin('msd', r'Jet $m_{sd}$', 23, 40, 300), #hist.Bin('gru', 'GRU value',20,0.,1.), #hist.Bin('gruddt', 'GRU$^{DDT}$ value',[-1,0,1]), #hist.Bin('rho', 'jet rho', 20,-5.5,-2.),#[-5.5,-5.,-4.5,-4.,-3.5,-3.,-2.5,-2.]), #hist.Bin('n2', 'N$_2$ value', 20, 0., 0.5), #hist.Bin('n2ddt', 'N$_2^{DDT}$ value', 21, -0.3, 0.3), #hist.Bin('Vmatch', 'Matched to V', [-1,0,1]), hist.Bin('in_v3_ddt', 'IN$^{DDT}$ value', 20, -1, 0.5), hist.Bin('mu_pt', 'Leading muon p_{T}', 20,50., 700.), hist.Bin('mu_pfRelIso04_all', 'Muon pfRelIso04 isolation', 20,0.,1.), #hist.Bin('nPFConstituents', 'Number of PF candidates',41,20,60), #hist.Bin('nJet', 'Number of fat jets', 10,0,9), ), #'gruddt' : hist.Hist( # hist.Cat('dataset', 'Dataset'), # hist.Cat('region', 'Region'), #'cutflow': hist.Hist( # 'Events', # hist.Cat('dataset', 'Dataset'), # hist.Cat('region', 'Region'), # hist.Bin('cut', 'Cut index', 11, 0, 11), #), 'cutflow_signal' : processor.defaultdict_accumulator(partial(processor.defaultdict_accumulator, float)), 'cutflow_ttbar_muoncontrol' : processor.defaultdict_accumulator(partial(processor.defaultdict_accumulator, float)), })
def __init__(self, columns=[]): self._columns = columns dataset_axis = hist.Cat("dataset", "Primary dataset") mass_axis = hist.Bin("mass", r"$m_{\mu\mu}$ [GeV]", 30000, 0.25, 300) pt_axis = hist.Bin("pt", r"$p_{T}$ [GeV]", 30000, 0.25, 300) self._accumulator = processor.dict_accumulator({ 'mass': hist.Hist("Counts", dataset_axis, mass_axis), 'pt': hist.Hist("Counts", dataset_axis, pt_axis), 'cutflow': processor.defaultdict_accumulator(int), })
def fill_lepton_kinematics(): import uproot import uproot_methods import awkward # histogram creation and manipulation from coffea import hist fin = uproot.open("HZZ.root") tree = fin["events"] arrays = { k.replace('Electron_', ''): v for k, v in tree.arrays("Electron_*", namedecode='ascii').items() } p4 = uproot_methods.TLorentzVectorArray.from_cartesian( arrays.pop('Px'), arrays.pop('Py'), arrays.pop('Pz'), arrays.pop('E'), ) electrons = awkward.JaggedArray.zip(p4=p4, **arrays) arrays = { k.replace('Muon_', ''): v for k, v in tree.arrays("Muon_*", namedecode='ascii').items() } p4 = uproot_methods.TLorentzVectorArray.from_cartesian( arrays.pop('Px'), arrays.pop('Py'), arrays.pop('Pz'), arrays.pop('E'), ) muons = awkward.JaggedArray.zip(p4=p4, **arrays) # Two types of axes exist presently: bins and categories lepton_kinematics = hist.Hist( "Events", hist.Cat("flavor", "Lepton flavor"), hist.Bin("pt", "$p_{T}$", 19, 10, 100), hist.Bin("eta", r"$\eta$", [-2.5, -1.4, 0, 1.4, 2.5]), ) # Pass keyword arguments to fill, all arrays must be flat numpy arrays # User is responsible for ensuring all arrays have same jagged structure! lepton_kinematics.fill(flavor="electron", pt=electrons['p4'].pt.flatten(), eta=electrons['p4'].eta.flatten()) lepton_kinematics.fill(flavor="muon", pt=muons['p4'].pt.flatten(), eta=muons['p4'].eta.flatten()) return lepton_kinematics
def pdf_plot(acc): outdir = './output/photon_pt_cut/' if not os.path.exists(outdir): os.makedirs(outdir) for year in [2017,2018]: fig = plt.gcf() fig.clf() ax = plt.gca() h = copy.deepcopy(acc['photon_pt0_recoil']) h=h.rebin(h.axis('pt'), hist.Bin("pt",r"$p_{T}^{\gamma}$ (GeV)", [0,175,215,10000])) h=h.rebin(h.axis('recoil'),hist.Bin('recoil','recoil',list(range(200,500,50)) + list(range(500,1000,100)) + list(range(1000,2000,250)))) h = merge_extensions(h, acc, reweight_pu=False) scale_xs_lumi(h) h = merge_datasets(h) # hlow = h.integrate(h.axis('pt'),) pprint(h.axis('dataset').identifiers()) # h = h.integrate(h.axis('dataset'),f'GJets_HT_MLM_{year}') h = h.integrate(h.axis('dataset'),f'GJets_HT_MLM_{year}') h = h.integrate(h.axis('region'),'tr_g_notrig_num') pprint(h) hist.plot1d( h, overlay='pt', # error_opts=data_err_opts, ax=ax, overflow='all', clear=False) ax.set_ylim(0,2e5) ax.set_xlim(200,500) ax.set_ylabel('Expected GJets events (a.u.)') # rax.set_ylim(0.9,1.6) # ax.set_yscale('log') leg=ax.legend(['< 175', '175 - 215', '> 215'],title='Photon $p_{T}$') # for i, pdf in enumerate(h.axis('pdf').identifiers()): # if str(pdf)=='none': # continue # leg.get_texts()[i].set_text(str(pdf)) ax.text(0.97, 0.65, 'Photon CR, no trigger applied', fontsize=10, horizontalalignment='right', verticalalignment='bottom', transform=ax.transAxes ) ax.plot([250,250],[0,1e8],'--',color='grey') fig.savefig(pjoin(outdir,f'photon_pt_cut_{year}.pdf')) plt.close(fig)
def __init__(self, year, xsec, corrections): self._year = year self._lumi = 1000. * float(AnalysisProcessor.lumis[year]) self._xsec = xsec self._corrections = corrections self._accumulator = processor.dict_accumulator({ 'sumw': hist.Hist('sumw', hist.Cat('dataset', 'Dataset'), hist.Bin('sumw', 'Weight value', [0.])), 'yields': hist.Hist('Events', hist.Cat('dataset', 'Dataset'), hist.Bin('yields', 'Yield', [0, 1])), })
def __init__(self): # we can use a large number of bins and rebin later dataset_axis = hist.Cat("dataset", "Primary dataset") pt_axis = hist.Bin("pt", r"$p_{T}$ (GeV)", 600, 0, 1000) mass_axis = hist.Bin("mass", r"$p_{T}$ (GeV)", 250, 0, 500) eta_axis = hist.Bin("eta", r"$\eta$", 60, -5.5, 5.5) multiplicity_axis = hist.Bin("multiplicity", r"N", 20, -0.5, 19.5) self._accumulator = processor.dict_accumulator({ "MET_pt": hist.Hist("Counts", dataset_axis, pt_axis), })
def __init__(self): dataset_axis = hist.Cat("dataset", "Dataset") dataset_axis = hist.Cat("dataset", "Dataset") jetPt_axis = hist.Bin('jetPt', 'jetPt', btagEff_ptBins) jetEta_axis = hist.Bin('jetEta', 'jetEta', btagEff_etaBins) jetFlav_axis = hist.Bin('jetFlav', 'jetFlav', [0, 4, 5, 6]) self._accumulator = processor.dict_accumulator({ 'hJets': hist.Hist("Counts", dataset_axis, jetPt_axis, jetEta_axis, jetFlav_axis), 'hBJets': hist.Hist("Counts", dataset_axis, jetPt_axis, jetEta_axis, jetFlav_axis), })
def __init__(self, isMC): self._isMC = isMC # Histograms dataset_axis = hist.Cat("dataset", "Primary dataset") selection_axis = hist.Cat("selection", "Selection name") self._accumulator = processor.dict_accumulator() self._accumulator["total_events"] = processor.defaultdict_accumulator( int) # Define histograms here self._accumulator["mjjj"] = hist.Hist( "Events", dataset_axis, selection_axis, hist.Bin("mjjj", r"$M_{jjj}$ [GeV]", dijet_binning), ) for pair in [(0, 1), (1, 2), (2, 0)]: self._accumulator[f"m{pair[0]}{pair[1]}"] = hist.Hist( "Events", dataset_axis, selection_axis, hist.Bin(f"m{pair[0]}{pair[1]}", f"$m_{{{pair[0]}{pair[1]}}}$ [GeV]", dijet_binning)) self._accumulator[f"dR{pair[0]}{pair[1]}"] = hist.Hist( "Events", dataset_axis, selection_axis, hist.Bin(f"dR{pair[0]}{pair[1]}", f"$\\Delta R_{{{pair[0]}{pair[1]}}}$ [GeV]", 100, 0., 4)) self._accumulator[f"dEta{pair[0]}{pair[1]}"] = hist.Hist( "Events", dataset_axis, selection_axis, hist.Bin(f"dEta{pair[0]}{pair[1]}", f"$\\Delta \\eta_{{{pair[0]}{pair[1]}}}$ [GeV]", 100, 0., 2)) self._accumulator[f"m{pair[0]}{pair[1]}overM"] = hist.Hist( "Events", dataset_axis, selection_axis, hist.Bin( f"m{pair[0]}{pair[1]}overM", r"$m_{{{pair0}{pair1}}}/M_{{jjj}}$".format(T="T", pair0=pair[0], pair1=pair[1], jjj="jjj"), 100, 0, 1)) for jet in [0, 1, 2]: self._accumulator[f"pt{jet}"] = hist.Hist( "Events", dataset_axis, selection_axis, hist.Bin(f"pt{jet}", r"$p^{T}_{jet}$ [GeV]".format(T="T", jet=jet), dijet_binning)) self._accumulator[f"eta{jet}"] = hist.Hist( "Events", dataset_axis, selection_axis, hist.Bin(f"eta{jet}", f"$\\eta_{jet}$", 100, -3, 3)) self._accumulator[f"ptoverM{jet}"] = hist.Hist( "Events", dataset_axis, selection_axis, hist.Bin( f"ptoverM{jet}", r"$p^{T}_{jet}/M_{{jjj}}$".format(T="T", jet=jet, jjj="jjj"), 100, 0, 2.5))
def __init__(self, samples, objects, selection, corrections, functions, columns): self._samples = samples self._columns = columns self._objects = objects self._selection = selection self._corrections = corrections self._functions = functions # Object variables self._e = {} self._mu = {} self._jet = {} self._e['id'] = 'Electron_cutBased' self._e['dxy'] = 'Electron_dxy' self._e['dz'] = 'Electron_dz' self._mu['tight_id'] = 'Muon_tightId' self._mu['mediumId'] = 'Muon_mediumId' self._mu['dxy'] = 'Muon_dxy' self._mu['dz'] = 'Muon_dz' self._mu['iso'] = 'Muon_pfRelIso04_all' self._jet['id'] = 'Jet_jetId' # Create the histograms # 'name' : hist.Hist("Ytitle", hist.Cat("sample", "sample"), hist.Cat("channel", "channel"), hist.Cat("level", "level"), hist.Cat("syst", "syst"), hist.Bin("name", "X axis (GeV)", 20, 0, 100)), self._accumulator = processor.dict_accumulator({ 'dummy': hist.Hist("Dummy", hist.Cat("sample", "sample"), hist.Bin("dummy", "Number of events", 1, 0, 1)), 'lep0pt': hist.Hist( "Events", hist.Cat("sample", "sample"), hist.Cat("channel", "channel"), hist.Cat("level", "level"), hist.Bin("lep0pt", "Leading lepton $p_{T}$ (GeV)", 20, 0, 200)), 'lep0eta': hist.Hist( "Events", hist.Cat("sample", "sample"), hist.Cat("channel", "channel"), hist.Cat("level", "level"), hist.Bin("lep0eta", "Leading lepton $\eta$ ", 15, -2.5, 2.50)), 'invmass': hist.Hist("Events", hist.Cat("sample", "sample"), hist.Cat("channel", "channel"), hist.Cat("level", "level"), hist.Bin("invmass", "$m_{\ell\ell}$ (GeV) ", 20, 0, 200)), })
def __init__(self, columns=[], canaries=[]): self._columns = columns self._canaries = canaries dataset_axis = hist.Cat("dataset", "Primary dataset") mass_axis = hist.Bin("mass", r"$m_{\mu\mu}$ [GeV]", 30000, 0.25, 300) pt_axis = hist.Bin("pt", r"$p_{T}$ [GeV]", 30000, 0.25, 300) self._accumulator = processor.dict_accumulator( { "mass": hist.Hist("Counts", dataset_axis, mass_axis), "pt": hist.Hist("Counts", dataset_axis, pt_axis), "cutflow": processor.defaultdict_accumulator(int), "worker": processor.set_accumulator(), } )
def __init__(self, data_type='bkg'): self.data_type = data_type dataset_axis = hist.Cat('dataset', 'dataset') pt_axis = hist.Bin('pt', '$p_T$ [GeV]', 100, 0, 200) ljmass_axis = hist.Bin('ljmass', 'mass [GeV]', 100, 0, 20) pairmass_axis = hist.Bin('pairmass', 'mass [GeV]', 100, 0, 200) vxy_axis = hist.Bin('vxy', 'vxy [cm]', 100, 0, 20) error_axis = hist.Bin('error', '$\sigma_{lxy}$', 100, 0, 100) sig_axis = hist.Bin('sig', 'lxy/$\sigma_{lxy}$', 50, 0, 50) cos_axis = hist.Bin('cos', r'$cos(\theta)$', 100, -1, 1) qsum_axis = hist.Bin('qsum', '$\sum$q', 2, 0, 2) dphi_axis = hist.Bin('dphi', '$\Delta\phi$', 50, 0, np.pi) channel_axis = hist.Bin('channel', 'channel', 3, 0, 3) self._accumulator = processor.dict_accumulator({ 'lj0pt': hist.Hist('Counts/2GeV', dataset_axis, pt_axis, channel_axis), 'lj1pt': hist.Hist('Counts/2GeV', dataset_axis, pt_axis, channel_axis), 'muljmass': hist.Hist('Counts/0.2GeV', dataset_axis, ljmass_axis, channel_axis), 'muljvxy': hist.Hist('Counts/0.2cm', dataset_axis, vxy_axis, channel_axis), 'muljlxyerr': hist.Hist('Norm. Frequency/1', dataset_axis, error_axis, channel_axis), 'muljlxysig': hist.Hist('Norm. Frequency/1', dataset_axis, sig_axis, channel_axis), 'muljcostheta': hist.Hist('Norm. Frequency/0.02', dataset_axis, cos_axis, channel_axis), 'muljqsum': hist.Hist('Counts', dataset_axis, qsum_axis, channel_axis), 'ljpairmass': hist.Hist('Counts/2GeV', dataset_axis, pairmass_axis, channel_axis), 'ljpairdphi': hist.Hist('Counts/$\pi$/50', dataset_axis, dphi_axis, channel_axis), }) self.pucorrs = get_pu_weights_function() ## NOT applied for now self.nlo_w = get_nlo_weight_function('w') self.nlo_z = get_nlo_weight_function('z')
def __init__(self, data_type='bkg'): self.data_type = data_type dataset_axis = hist.Cat('dataset', 'dataset') iso_axis = hist.Bin('iso', 'min pfIso', 50, 0, 0.5) bin_axis = hist.Bin('val', 'binary value', 3, 0, 3) self._accumulator = processor.dict_accumulator({ 'chan-4mu': hist.Hist('Counts', dataset_axis, iso_axis, bin_axis), 'chan-2mu2e': hist.Hist('Counts', dataset_axis, iso_axis, bin_axis), }) self.pucorrs = get_pu_weights_function() ## NOT applied for now self.nlo_w = get_nlo_weight_function('w') self.nlo_z = get_nlo_weight_function('z')
def __init__(self): # Create the histograms self._accumulator = processor.dict_accumulator({ 'dummy': hist.Hist("Dummy", hist.Cat("sample", "sample"), hist.Bin("dummy", "Number of events", 1, 0, 1)), })
def test_export1d(): import uproot import os from coffea.hist import export1d counts, test_eta, test_pt = dummy_jagged_eta_pt() h_regular_bins = hist.Hist("regular_joe", hist.Bin("x", "x", 20, 0, 200)) h_regular_bins.fill(x=test_pt) hout = export1d(h_regular_bins) filename = 'test_export1d.root' with uproot.create(filename) as fout: fout['regular_joe'] = hout fout.close() with uproot.open(filename) as fin: hin = fin['regular_joe'] assert (np.all(hin.edges == hout.edges)) assert (np.all(hin.values == hout.values)) del hin del fin if os.path.exists(filename): os.remove(filename)
def __init__(self): ## load b-tag SFs #self.btag_sf = BTagScaleFactor(os.path.expandvars("$TWHOME/data/DeepCSV_102XSF_V1.btag.csv.gz", "reshape") # we can use a large number of bins and rebin later dataset_axis = hist.Cat("dataset", "Primary dataset") pt_axis = hist.Bin("pt", r"$p_{T}$ (GeV)", 1000, 0, 1000) self._accumulator = processor.dict_accumulator({ 'diboson': processor.defaultdict_accumulator(int), 'ttbar': processor.defaultdict_accumulator(int), 'TTW': processor.defaultdict_accumulator(int), 'TTZ': processor.defaultdict_accumulator(int), 'TTH': processor.defaultdict_accumulator(int), 'TTTT': processor.defaultdict_accumulator(int), 'tW_scattering': processor.defaultdict_accumulator(int), 'DY': processor.defaultdict_accumulator(int), 'totalEvents': processor.defaultdict_accumulator(int), 'passedEvents': processor.defaultdict_accumulator(int), })
def test_issue_394(): dummy = hist.Hist( "Dummy", hist.Cat("sample", "sample"), hist.Bin("dummy", "Number of events", 1, 0, 1), ) dummy.fill(sample="test", dummy=1, weight=0.5)
def plot_ht_dist(acc, regex, tag): '''Given the accumulator and the dataset regex, plot the HT distribution.''' acc.load('lhe_ht') h = acc['lhe_ht'] h = merge_extensions(h, acc, reweight_pu=False) scale_xs_lumi(h) h = merge_datasets(h) # Choose the relevant dataset(s) h = h[re.compile(regex)] new_ht_bins = hist.Bin('ht', r'$H_T \ (GeV)$', 50, 0, 4000) h = h.rebin('ht', new_ht_bins) # Plot the HT distribution fig, ax = plt.subplots(1, 1) hist.plot1d(h, ax=ax, overflow='all', binwnorm=True, overlay='dataset') ax.set_yscale('log') ax.set_ylim(1e-3, 1e6) if 'gjets' in tag: ax.plot([600, 600], [1e-3, 1e6]) if not os.path.exists('./output'): os.mkdir('output') fig.savefig(f'./output/{tag}_lhe_ht.pdf')
def __init__(self, year): self._year = year self._trigger = { 2016: { "e": [ "Ele27_WPTight_Gsf", "Ele45_WPLoose_Gsf", "Ele25_eta2p1_WPTight_Gsf", "Ele115_CaloIdVT_GsfTrkIdT", "Ele15_IsoVVL_PFHT350", "Ele15_IsoVVVL_PFHT400", "Ele45_CaloIdVT_GsfTrkIdT_PFJet200_PFJet50", "Ele50_CaloIdVT_GsfTrkIdT_PFJet165", ], "mu": [ "IsoMu24", "IsoTkMu24", "Mu50", "TkMu50", "Mu15_IsoVVVL_PFHT400", "Mu15_IsoVVVL_PFHT350", ], } } self._trigger = self._trigger[int(self._year)] self._accumulator = processor.dict_accumulator({ 'sumw': processor.defaultdict_accumulator(float), 'cutflow': hist.Hist( 'Events', hist.Cat('dataset', 'Dataset'), hist.Cat('channel', 'Channel'), hist.Bin('cut', 'Cut index', 9, 0, 9), ), })