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),
),
})
