def nearest(
self,
other,
axis=1,
metric=lambda a, b: a.delta_r(b),
return_metric=False,
threshold=None,
):
"""Return nearest object to this one
Finds item in ``other`` satisfying ``min(metric(self, other))``.
The two arrays should be broadcast-compatible on all axes other than the specified
axis, which will be used to form a cartesian product. If axis=None, broadcast arrays directly.
The return shape will be that of ``self``.
Parameters
----------
other : awkward1.Array
Another array with same shape in all but ``axis``
axis : int, optional
The axis to form the cartesian product (default 1). If None, the metric
is directly evaluated on the input arrays (i.e. they should broadcast)
metric : callable
A function of two arguments, returning a scalar. The default metric is `delta_r`.
return_metric : bool, optional
If true, return both the closest object and its metric (default false)
threshold : Number, optional
If set, any objects with ``metric > threshold`` will be masked from the result
"""
if axis is None:
a, b = self, other
# NotImplementedError: ak.firsts with axis=-1
axis = other.layout.purelist_depth - 2
else:
a, b = awkward1.unzip(
awkward1.cartesian([self, other], axis=axis, nested=True)
)
mval = metric(a, b)
# prefer keepdims=True: awkward-1.0 #434
mmin = awkward1.singletons(awkward1.argmin(mval, axis=axis + 1))
out = awkward1.firsts(b[mmin], axis=axis + 1)
metric = awkward1.firsts(mval[mmin], axis=axis + 1)
if threshold is not None:
out = out.mask[metric <= threshold]
if return_metric:
return out, metric
return out
def test_firsts_singletons():
array = awkward1.Array([None, 1.1, 2.2, None, 3.3, None, None, 4.4, 5.5, None])
one = awkward1.singletons(array)
assert awkward1.to_list(one) == [[], [1.1], [2.2], [], [3.3], [], [], [4.4], [5.5], []]
two = awkward1.firsts(one)
assert awkward1.to_list(two) == [None, 1.1, 2.2, None, 3.3, None, None, 4.4, 5.5, None]
array = awkward1.repartition(array, 3)
assert isinstance(array.layout, awkward1.partition.PartitionedArray)
one = awkward1.singletons(array)
assert isinstance(one.layout, awkward1.partition.PartitionedArray)
assert awkward1.to_list(one) == [[], [1.1], [2.2], [], [3.3], [], [], [4.4], [5.5], []]
two = awkward1.firsts(one)
assert isinstance(two.layout, awkward1.partition.PartitionedArray)
assert awkward1.to_list(two) == [None, 1.1, 2.2, None, 3.3, None, None, 4.4, 5.5, None]
def test_firsts():
array = awkward1.singletons(
awkward1.Array([1.1, 2.2, None, 3.3, None, None, 4.4, 5.5]))
assert awkward1.to_list(
awkward1.firsts(
awkward1.singletons(
awkward1.Array([1.1, 2.2, None, 3.3, None, None, 4.4, 5.5])),
axis=1)) == [1.1, 2.2, None, 3.3, None, None, 4.4, 5.5]
assert awkward1.to_list(
awkward1.firsts(awkward1.singletons(
awkward1.Array([[1.1, 2.2, None], [3.3, None], [None], [4.4,
5.5]])),
axis=2)) == [[1.1, 2.2, None], [3.3, None], [None],
[4.4, 5.5]]
assert awkward1.to_list(
awkward1.firsts(awkward1.singletons(
awkward1.Array([[[1.1, 2.2, None]], [[3.3, None]], [[None]],
[[4.4, 5.5]]])),
axis=3)) == [[[1.1, 2.2, None]], [[3.3, None]],
[[None]], [[4.4, 5.5]]]
def process(self, events):
# get meta infos
dataset = events.metadata["dataset"]
isRealData = not hasattr(events, "genWeight")
n_events = len(events)
selection = processor.PackedSelection()
weights = processor.Weights(n_events)
output = self.accumulator.identity()
# weights
if not isRealData:
output['sumw'][dataset] += awkward1.sum(events.genWeight)
# trigger
triggers = {}
for channel in ["e","mu"]:
trigger = np.zeros(len(events), dtype='bool')
for t in self._trigger[channel]:
try:
trigger = trigger | events.HLT[t]
except:
warnings.warn("Missing trigger %s" % t, RuntimeWarning)
triggers[channel] = trigger
# met filter
met_filters = ["goodVertices",
"globalSuperTightHalo2016Filter",
"HBHENoiseFilter",
"HBHENoiseIsoFilter",
"EcalDeadCellTriggerPrimitiveFilter",
"BadPFMuonFilter",
]
met_filters_mask = np.ones(len(events), dtype='bool')
for t in met_filters:
met_filters_mask = met_filters_mask & events.Flag[t]
selection.add("met_filter", awkward1.to_numpy(met_filters_mask))
# load objects
muons = events.Muon
electrons = events.Electron
jets = events.Jet
fatjets = events.FatJet
subjets = events.SubJet
fatjetsLS = events.FatJetLS
met = events.MET
# muons
goodmuon = (
(muons.mediumId)
& (muons.miniPFRelIso_all <= 0.2)
& (muons.pt >= 27)
& (abs(muons.eta) <= 2.4)
& (abs(muons.dz) < 0.1)
& (abs(muons.dxy) < 0.05)
& (muons.sip3d < 4)
)
good_muons = muons[goodmuon]
ngood_muons = awkward1.sum(goodmuon, axis=1)
# electrons
goodelectron = (
(electrons.mvaFall17V2noIso_WP90)
& (electrons.pt >= 30)
& (abs(electrons.eta) <= 1.479)
& (abs(electrons.dz) < 0.1)
& (abs(electrons.dxy) < 0.05)
& (electrons.sip3d < 4)
)
good_electrons = electrons[goodelectron]
ngood_electrons = awkward1.sum(goodelectron, axis=1)
# good leptons
good_leptons = awkward1.concatenate([good_muons, good_electrons], axis=1)
good_leptons = good_leptons[awkward1.argsort(good_leptons.pt)]
# lepton candidate
candidatelep = awkward1.firsts(good_leptons)
# lepton channel selection
selection.add("ch_e", awkward1.to_numpy((triggers["e"]) & (ngood_electrons==1) & (ngood_muons==0))) # not sure if need to require 0 muons or 0 electrons in the next line
selection.add("ch_mu", awkward1.to_numpy((triggers["mu"]) & (ngood_electrons==0) & (ngood_muons==1)))
# jets
ht = awkward1.sum(jets[jets.pt > 30].pt,axis=1)
selection.add("ht_400", awkward1.to_numpy(ht>=400))
goodjet = (
(jets.isTight)
& (jets.pt > 30)
& (abs(jets.eta) <= 2.5)
)
good_jets = jets[goodjet]
# fat jets
jID = "isTight"
# TODO: add mass correction
# a way to get the first two subjets
# cart = awkward1.cartesian([fatjets, subjets], nested=True)
# idxes = awkward1.pad_none(awkward1.argsort(cart['0'].delta_r(cart['1'])), 2, axis=2)
# sj1 = subjets[idxes[:,:,0]]
# sj2 = subjets[idxes[:,:,1]]
good_fatjet = (
(getattr(fatjets, jID))
& (abs(fatjets.eta) <= 2.4)
& (fatjets.pt > 50)
& (fatjets.msoftdrop > 30)
& (fatjets.msoftdrop < 210)
#& (fatjets.pt.copy(content=fatjets.subjets.content.counts) == 2) # TODO: require 2 subjets?
# this can probably be done w FatJet_subJetIdx1 or FatJet_subJetIdx2
& (awkward1.all(fatjets.subjets.pt >= 20))
& (awkward1.all(abs(fatjets.subjets.eta) <= 2.4))
)
good_fatjets = fatjets[good_fatjet]
# hbb candidate
mask_hbb = (
(good_fatjets.pt > 200)
& (good_fatjets.delta_r(candidatelep) > 2.0)
)
candidateHbb = awkward1.firsts(good_fatjets[mask_hbb])
# b-tag #& (good_fatjets.particleNetMD_Xbb > 0.9)
selection.add('hbb_btag',awkward1.to_numpy(candidateHbb.deepTagMD_ZHbbvsQCD >= 0.8)) # score would be larger for tight category (0.97)
# No AK4 b-tagged jets away from bb jet
jets_HbbV = jets[good_jets.delta_r(candidateHbb) >= 1.2]
selection.add('hbb_vetobtagaway', awkward1.to_numpy(awkward1.max(jets_HbbV.btagDeepB, axis=1, mask_identity=False) > BTagEfficiency.btagWPs[self._year]['medium']))
# fat jets Lepton Subtracted
# wjj candidate
mask_wjj = (
(fatjetsLS.pt > 50)
& (fatjetsLS.delta_r(candidatelep) > 1.2)
# need to add 2 subjets w pt > 20 & eta<2.4
# need to add ID?
)
candidateWjj = awkward1.firsts(fatjetsLS[mask_wjj][awkward1.argmin(fatjetsLS[mask_wjj].delta_r(candidatelep),axis=1,keepdims=True)])
# add t2/t1 <= 0.75 (0.45 HP)
selection.add('hww_mass', awkward1.to_numpy(candidateWjj.mass >= 10))
print('met ',met)
# wjjlnu info
#HSolverLiInfo hwwInfoLi;
# qqSDmass = candidateWjj.msoftdrop
# hwwLi = hSolverLi->minimize(candidatelep.p4(), met.p4(), wjjcand.p4(), qqSDmass, hwwInfoLi)
#neutrino = hwwInfoLi.neutrino;
#wlnu = hwwInfoLi.wlnu;
#wqq = hwwInfoLi.wqqjet;
#hWW = hwwInfoLi.hWW;
#wwDM = PhysicsUtilities::deltaR( wlnu,wqq) * hWW.pt()/2.0;
# add dlvqq <= 11 (2.5 HP)
# in the meantime let's add the mass
'''
mm = (candidatejet - candidatelep).mass2
jmass = (mm>0)*np.sqrt(np.maximum(0, mm)) + (mm<0)*candidatejet.mass
joffshell = jmass < 62.5
massassumption = 80.*joffshell + (125 - 80.)*~joffshell
x = massassumption**2/(2*candidatelep.pt*met.pt) + np.cos(candidatelep.phi - met.phi)
met_eta = (
(x < 1)*np.arcsinh(x*np.sinh(candidatelep.eta))
+ (x > 1)*(
candidatelep.eta - np.sign(candidatelep.eta)*np.arccosh(candidatelep.eta)
)
)
met_p4 = TLorentzVectorArray.from_ptetaphim(np.array([0.]),np.array([0.]),np.array([0.]),np.array([0.]))
if met.size > 0:
met_p4 = TLorentzVectorArray.from_ptetaphim(met.pt, met_eta.fillna(0.), met.phi, np.zeros(met.size))
# hh system
candidateHH = candidateWjj + met_p4 + candidateHbb
selection.add('hh_mass', candidateHH.mass >= 700)
selection.add('hh_centrality', candidateHH.pt/candidateHH.mass >= 0.3)
'''
channels = {"e": ["met_filter","ch_e","ht_400","hbb_btag","hbb_vetobtagaway","hww_mass"], #,"hh_mass","hh_centrality"],
"mu": ["met_filter","ch_mu","ht_400","hbb_btag","hbb_vetobtagaway","hww_mass"] #,"hh_mass","hh_centrality"],
}
# need to add gen info
if not isRealData:
weights.add('genweight', events.genWeight)
add_pileup_weight(weights, events.Pileup.nPU, self._year, dataset)
for channel, cuts in channels.items():
allcuts = set()
output['cutflow'].fill(dataset=dataset, channel=channel, cut=0, weight=weights.weight())
for i, cut in enumerate(cuts):
allcuts.add(cut)
cut = selection.all(*allcuts)
output['cutflow'].fill(dataset=dataset, channel=channel, cut=i + 1, weight=weights.weight()[cut])
return output
def runOneFile(filename):
#print ("filename: ", filename)
#inputfile=filename
outputfile = "output/" + inputfile.split("/")[-1]
#outputfile = "tmp.root"
mycache = uproot4.LRUArrayCache("1 MB")
file_ = uproot4.open(inputfile, num_workers=10)
#print ("root file opened: ", filename)
nevents = ak.to_list(file_["h_total_mcweight"].values())[2]
#nevents = 1000000
print("histogram opened: ", nevents)
#tree_ = uproot4.open(inputfile, num_workers=10)["outTree"].arrays(array_cache=mycache)
tree_ = file_["outTree"].arrays(array_cache=mycache)
print("tree length", len(tree_))
#tree_ = uproot4.open(inputfile)[trees[0]].arrays()
#tree_ = uproot4.open(inputfile)["outTree"].arrays(array_cache=mycache)
#tree_ = uproot4.open("Merged_WJetsInclusiveSkim.root")["outTree"].arrays(array_cache=mycache)
#tree_ = uproot4.open("/eos/cms/store/group/phys_exotica/bbMET/2016_SkimmedFiles/skim_setup_2016_v16_07-00/crab_DYJetsToLL_M-50_HT-400to600_TuneCUETP8M1_13TeV-madgraphMLM-pythia8_200918_215129_0000_0.root")["outTree"].arrays(array_cache=mycache)
#tree_ = uproot4.open("/eos/cms/store/group/phys_exotica/bbMET/2016_SkimmedFiles/skim_setup_2016_v16_07-00/crab_ttHTobb_M125_13TeV_powheg_pythia8_200918_215950_0000_0.root")["outTree"].arrays(array_cache=mycache)
#print ((tree_))
cms_events = ak.zip(
{
"run":
tree_["st_runId"],
"lumi":
tree_["st_lumiSection"],
"event":
tree_["st_eventId"],
"jetpx":
tree_["st_THINjetPx"],
"jetpy":
tree_["st_THINjetPy"],
"jetpz":
tree_["st_THINjetPz"],
"jete":
tree_["st_THINjetEnergy"],
"jetpt":
getpt(tree_["st_THINjetPx"], tree_["st_THINjetPy"]),
"jeteta":
geteta(tree_["st_THINjetPx"], tree_["st_THINjetPy"],
tree_["st_THINjetPz"]),
"jetphi":
getphi(tree_["st_THINjetPx"], tree_["st_THINjetPy"]),
"jetcsv":
tree_["st_THINjetDeepCSV"],
"jetflav":
tree_["st_THINjetHadronFlavor"],
"metpt":
tree_["st_pfMetCorrPt"],
"metphi":
tree_["st_pfMetCorrPhi"],
"mettrig":
tree_["st_mettrigdecision"],
"elepx":
tree_["st_elePx"],
"elepy":
tree_["st_elePy"],
"elepz":
tree_["st_elePz"],
"elee":
tree_["st_eleEnergy"],
"eleidL":
tree_["st_eleIsPassLoose"],
"eleidT":
tree_["st_eleIsPassTight"],
"eleq":
tree_["st_eleCharge"],
"elept":
getpt(tree_["st_elePx"], tree_["st_elePy"]),
"eleeta":
geteta(tree_["st_elePx"], tree_["st_elePy"], tree_["st_elePz"]),
"elephi":
getphi(tree_["st_elePx"], tree_["st_elePy"]),
"mupx":
tree_["st_muPx"],
"mupy":
tree_["st_muPy"],
"mupz":
tree_["st_muPz"],
"mue":
tree_["st_muEnergy"],
"muidT":
tree_["st_isTightMuon"],
"muq":
tree_["st_muCharge"],
"mupt":
getpt(tree_["st_muPx"], tree_["st_muPy"]),
"mueta":
geteta(tree_["st_muPx"], tree_["st_muPy"], tree_["st_muPz"]),
"muphi":
getphi(tree_["st_muPx"], tree_["st_muPy"]),
"ntau":
tree_["st_nTau_discBased_TightEleTightMuVeto"],
"npho":
tree_["st_nPho"],
"phopx":
tree_["st_phoPx"],
"phopy":
tree_["st_phoPy"],
"phopz":
tree_["st_phoPz"],
"phoe":
tree_["st_phoEnergy"],
"phopt":
getpt(tree_["st_phoPx"], tree_["st_phoPy"]),
"phoeta":
geteta(tree_["st_phoPx"], tree_["st_phoPy"], tree_["st_phoPz"]),
"nTrueInt":
tree_["st_pu_nTrueInt"],
"nPUVert":
tree_["st_pu_nPUVert"],
"genpt":
tree_["st_genParPt"]
},
depth_limit=1)
out_events = ak.zip(
{
"run": tree_["st_runId"],
"lumi": tree_["st_lumiSection"],
"event": tree_["st_eventId"]
},
depth_limit=1)
print("event loading done")
print("# of events: ", len(cms_events))
## add more columns/properties to the event
cms_events["mu_sel_tight"] = (cms_events.mupt > 30) & (
cms_events.muidT == True) & (numpy.abs(cms_events.mueta) < 2.4)
cms_events["mu_sel_tight0"] = ak.Array(getN(cms_events.mu_sel_tight, 0))
cms_events["nMuTight"] = ak.sum(cms_events.mu_sel_tight, axis=-1)
cms_events["nMuLoose"] = ak.sum((cms_events.mupt > 10), axis=-1)
cms_events["mu_q0"] = ak.Array(getN(cms_events.muq, 0))
cms_events["mu_q1"] = ak.Array(getN(cms_events.muq, 1))
cms_events["ele_sel_tight"] = (cms_events.eleidT == True) & (
cms_events.elept > 30) & (numpy.abs(cms_events.eleeta) < 2.5)
cms_events["ele_sel_tight0"] = ak.Array(getN(cms_events.ele_sel_tight, 0))
cms_events["nEleTight"] = ak.sum(cms_events.ele_sel_tight, axis=-1)
cms_events["nEleLoose"] = ak.sum((cms_events.elept > 10), axis=-1)
cms_events["ele_q0"] = ak.Array(getN(cms_events.eleq, 0))
cms_events["ele_q1"] = ak.Array(getN(cms_events.eleq, 1))
cms_events["recoil_Wmunu"] = getrecoil(cms_events.nMuTight,
cms_events.mupt, cms_events.muphi,
cms_events.mupx, cms_events.mupy,
cms_events.metpt, cms_events.metphi)
cms_events["recoil_Wmunu0"] = ak.firsts(cms_events.recoil_Wmunu)
cms_events["recoil_Wenu"] = getrecoil(cms_events.nEleTight,
cms_events.elept, cms_events.elephi,
cms_events.elepx, cms_events.elepy,
cms_events.metpt, cms_events.metphi)
cms_events["recoil_Wenu0"] = ak.firsts(cms_events.recoil_Wenu)
elepx0 = ak.Array(getN(cms_events.elepx, 0))
elepx1 = ak.Array(getN(cms_events.elepx, 1))
elepy0 = ak.Array(getN(cms_events.elepy, 0))
elepy1 = ak.Array(getN(cms_events.elepy, 1))
elepz0 = ak.Array(getN(cms_events.elepz, 0))
elepz1 = ak.Array(getN(cms_events.elepz, 1))
elee0 = ak.Array(getN(cms_events.elee, 0))
elee1 = ak.Array(getN(cms_events.elee, 1))
cms_events["Zee_mass"] = numpy.sqrt((elee0 + elee1)**2 -
(elepx0 + elepx1)**2 -
(elepy0 + elepy1)**2 -
(elepz0 + elepz1)**2)
cms_events["Zee_pt"] = numpy.sqrt((elepx0 + elepx1)**2 +
(elepy0 + elepy1)**2)
cms_events["Zee_recoil"] = getrecoil1((elepx0 + elepx1), (elepy0 + elepy1),
cms_events.metpt, cms_events.metphi)
mupx0 = ak.Array(getN(cms_events.mupx, 0))
mupx1 = ak.Array(getN(cms_events.mupx, 1))
mupy0 = ak.Array(getN(cms_events.mupy, 0))
mupy1 = ak.Array(getN(cms_events.mupy, 1))
mupz0 = ak.Array(getN(cms_events.mupz, 0))
mupz1 = ak.Array(getN(cms_events.mupz, 1))
mue0 = ak.Array(getN(cms_events.mue, 0))
mue1 = ak.Array(getN(cms_events.mue, 1))
cms_events["Zmumu_mass"] = numpy.sqrt((mue0 + mue1)**2 -
(mupx0 + mupx1)**2 -
(mupy0 + mupy1)**2 -
(mupz0 + mupz1)**2)
cms_events["Zmumu_pt"] = numpy.sqrt((mupx0 + mupx1)**2 +
(mupy0 + mupy1)**2)
cms_events["Zmumu_recoil"] = getrecoil1(
(mupx0 + mupx1), (mupy0 + mupy1), cms_events.metpt, cms_events.metphi)
#cms_events["recoil_Zmumu"] = getrecoil
cms_events["recoil_WmunuPhi"] = getRecoilPhi(
cms_events.nMuTight, cms_events.mupt, cms_events.muphi,
cms_events.mupx, cms_events.mupy, cms_events.metpt, cms_events.metphi)
cms_events["recoil_WmunuPhi0"] = ak.firsts(cms_events.recoil_WmunuPhi)
cms_events["recoil_WenuPhi"] = getRecoilPhi(
cms_events.nEleTight, cms_events.elept, cms_events.elephi,
cms_events.elepx, cms_events.elepy, cms_events.metpt,
cms_events.metphi)
cms_events["recoil_WenuPhi0"] = ak.firsts(cms_events.recoil_WenuPhi)
cms_events["mt_Wmunu"] = getMT(cms_events.nMuTight, cms_events.mupt,
cms_events.muphi, cms_events.mupx,
cms_events.mupy, cms_events.metpt,
cms_events.metphi)
cms_events["mt_Wmunu0"] = ak.firsts(cms_events.mt_Wmunu)
cms_events["mt_Wenu"] = getMT(cms_events.nEleTight, cms_events.elept,
cms_events.elephi, cms_events.elepx,
cms_events.elepy, cms_events.metpt,
cms_events.metphi)
cms_events["mt_Wenu0"] = ak.firsts(cms_events.mt_Wenu)
cms_events["jet_sel_loose"] = (cms_events.jetpt > 30.0) & (numpy.abs(
cms_events.jeteta) < 2.5)
cms_events["jet_sel_tight"] = (cms_events.jetpt > 50.0) & (numpy.abs(
cms_events.jeteta) < 2.5)
#cms_events["jet_sel_b"] = (cms_events.jetcsv > 0.6321) & (numpy.abs(cms_events.jeteta)<2.4)
cms_events["jet_sel_b"] = (
cms_events.jetcsv[cms_events.jet_sel_loose == True] > 0.6321
) & (numpy.abs(cms_events.jeteta[cms_events.jet_sel_loose == True]) < 2.4)
cms_events["jetptTight"] = cms_events.jetpt[cms_events.jet_sel_tight ==
True]
cms_events["jetetaTight"] = cms_events.jeteta[cms_events.jet_sel_tight ==
True]
cms_events["jetphiTight"] = cms_events.jetphi[cms_events.jet_sel_tight ==
True]
cms_events["jetptLoose"] = cms_events.jetpt[cms_events.jet_sel_loose ==
True]
cms_events["jetetaLoose"] = cms_events.jeteta[cms_events.jet_sel_loose ==
True]
cms_events["jetphiLoose"] = cms_events.jetphi[cms_events.jet_sel_loose ==
True]
cms_events["jet_sel_tight0"] = ak.Array(
getN(cms_events.jet_sel_tight[cms_events.jet_sel_loose == True], 0))
cms_events["jet_sel_b_0"] = ak.Array(getN(cms_events.jet_sel_b, 0))
cms_events["jet_sel_b_1"] = ak.Array(getN(cms_events.jet_sel_b, 1))
cms_events["nJetLoose"] = ak.sum(cms_events.jet_sel_loose, axis=-1)
cms_events["nJetTight"] = ak.sum(cms_events.jet_sel_tight, axis=-1)
cms_events["nJetb"] = ak.sum(cms_events.jet_sel_b, axis=-1)
cms_events["dphi_jet_met"] = DeltaPhi(
cms_events.jetphi[cms_events.jet_sel_loose == True], cms_events.metphi)
cms_events["min_dphi_jet_met"] = ak.min(cms_events.dphi_jet_met, axis=-1)
#--------------------------------------------------------------------------------------------------
## W --> lepton + nu
#--------------------------------------------------------------------------------------------------
from regions import get_mask_wmunu1b, get_mask_wmunu2b, get_mask_wenu1b, get_mask_wenu2b, get_mask_topmunu1b, get_mask_topmunu2b, get_mask_topenu1b, get_mask_topenu2b, get_mask_Zmumu1b, get_mask_Zmumu2b, get_mask_Zee1b, get_mask_Zee2b, get_mask_SR1b, get_mask_SR2b
cms_events["mask_wmunu1b"] = get_mask_wmunu1b(cms_events)
cms_events["mask_wmunu2b"] = get_mask_wmunu2b(cms_events)
cms_events["mask_wenu1b"] = get_mask_wenu1b(cms_events)
cms_events["mask_wenu2b"] = get_mask_wenu2b(cms_events)
cms_events["mask_topmunu1b"] = get_mask_topmunu1b(cms_events)
cms_events["mask_topmunu2b"] = get_mask_topmunu2b(cms_events)
cms_events["mask_topenu1b"] = get_mask_topenu1b(cms_events)
cms_events["mask_topenu2b"] = get_mask_topenu2b(cms_events)
cms_events["mask_Zmumu1b"] = get_mask_Zmumu1b(cms_events)
cms_events["mask_Zmumu2b"] = get_mask_Zmumu2b(cms_events)
cms_events["mask_Zee1b"] = get_mask_Zee1b(cms_events)
cms_events["mask_Zee2b"] = get_mask_Zee2b(cms_events)
cms_events["mask_SR1b"] = get_mask_SR1b(cms_events)
cms_events["mask_SR2b"] = get_mask_SR2b(cms_events)
'''
wm = cms_events.event[mask_SR2b]
wm[~ak.is_none(wm)]
'''
###############
out_events["metpt"] = cms_events["metpt"]
out_events["metphi"] = cms_events["metphi"]
out_events["nTrueInt"] = cms_events["nTrueInt"]
out_events["nJetLoose"] = cms_events["nJetLoose"]
out_events["mu_sel_tight0"] = cms_events["mu_sel_tight0"]
out_events["nMuTight"] = cms_events["nMuTight"]
out_events["nMuLoose"] = cms_events["nMuLoose"]
out_events["mu_q0"] = cms_events["mu_q0"]
out_events["mu_q1"] = cms_events["mu_q1"]
out_events["mupt0"] = ak.Array(getN(cms_events.mupt, 0))
out_events["mupt1"] = ak.Array(getN(cms_events.mupt, 1))
out_events["mueta0"] = ak.Array(getN(cms_events.mueta, 0))
out_events["mueta1"] = ak.Array(getN(cms_events.mueta, 1))
out_events["muphi0"] = ak.Array(getN(cms_events.muphi, 0))
out_events["muphi1"] = ak.Array(getN(cms_events.muphi, 1))
out_events["ele_sel_tight0"] = cms_events["ele_sel_tight0"]
out_events["nEleTight"] = cms_events["nEleTight"]
out_events["nEleLoose"] = cms_events["nEleLoose"]
out_events["ele_q0"] = cms_events["ele_q0"]
out_events["ele_q1"] = cms_events["ele_q1"]
out_events["elept0"] = ak.Array(getN(cms_events.elept, 0))
out_events["elept1"] = ak.Array(getN(cms_events.elept, 1))
out_events["eleeta0"] = ak.Array(getN(cms_events.eleeta, 0))
out_events["eleeta1"] = ak.Array(getN(cms_events.eleeta, 1))
out_events["elephi0"] = ak.Array(getN(cms_events.elephi, 0))
out_events["elephi1"] = ak.Array(getN(cms_events.elephi, 1))
out_events["recoil_Wmunu0"] = cms_events["recoil_Wmunu0"]
out_events["recoil_Wenu0"] = cms_events["recoil_Wenu0"]
out_events["recoil_WmunuPhi0"] = cms_events["recoil_WmunuPhi0"]
out_events["recoil_WenuPhi0"] = cms_events["recoil_WenuPhi0"]
out_events["mt_Wmunu0"] = cms_events["mt_Wmunu0"]
out_events["mt_Wenu0"] = cms_events["mt_Wenu0"]
out_events["Zee_mass"] = cms_events["Zee_mass"]
out_events["Zee_pt"] = cms_events["Zee_pt"]
out_events["Zee_recoil"] = cms_events["Zee_recoil"]
out_events["Zmumu_mass"] = cms_events["Zmumu_mass"]
out_events["Zmumu_pt"] = cms_events["Zmumu_pt"]
out_events["Zmumu_recoil"] = cms_events["Zmumu_recoil"]
out_events["nJetLoose"] = cms_events["nJetLoose"]
out_events["nJetTight"] = cms_events["nJetTight"]
out_events["nJetb"] = cms_events["nJetb"]
out_events["min_dphi_jet_met"] = cms_events["min_dphi_jet_met"]
cms_events["jet_sel_tight0"] = cms_events["jet_sel_tight0"]
cms_events["jet_sel_b_0"] = cms_events["jet_sel_b_0"]
cms_events["jet_sel_b_1"] = cms_events["jet_sel_b_1"]
out_events["jetpt0"] = ak.Array(getN(cms_events.jetptTight, 0))
out_events["jetpt1"] = ak.Array(getN(cms_events.jetptLoose, 1))
out_events["jetpt2"] = ak.Array(getN(cms_events.jetptLoose, 2))
out_events["jetpt3"] = ak.Array(getN(cms_events.jetptLoose, 3))
out_events["jetpt4"] = ak.Array(getN(cms_events.jetptLoose, 4))
out_events["jetpt5"] = ak.Array(getN(cms_events.jetptLoose, 5))
out_events["jetpt6"] = ak.Array(getN(cms_events.jetptLoose, 6))
out_events["jeteta0"] = ak.Array(getN(cms_events.jetetaTight, 0))
out_events["jeteta1"] = ak.Array(getN(cms_events.jetetaLoose, 1))
out_events["jeteta2"] = ak.Array(getN(cms_events.jetetaLoose, 2))
out_events["jeteta3"] = ak.Array(getN(cms_events.jetetaLoose, 3))
out_events["jeteta4"] = ak.Array(getN(cms_events.jetetaLoose, 4))
out_events["jeteta5"] = ak.Array(getN(cms_events.jetetaLoose, 5))
out_events["jeteta6"] = ak.Array(getN(cms_events.jetetaLoose, 6))
out_events["jetphi0"] = ak.Array(getN(cms_events.jetphiTight, 0))
out_events["jetphi1"] = ak.Array(getN(cms_events.jetphiLoose, 1))
out_events["jetphi2"] = ak.Array(getN(cms_events.jetphiLoose, 2))
out_events["jetflav0"] = ak.Array(
getN(cms_events.jetflav[cms_events.jet_sel_tight == True], 0))
out_events["jetflav1"] = ak.Array(
getN(cms_events.jetflav[cms_events.jet_sel_loose == True], 1))
out_events["jetflav2"] = ak.Array(
getN(cms_events.jetflav[cms_events.jet_sel_loose == True], 2))
out_events["jetflav3"] = ak.Array(
getN(cms_events.jetflav[cms_events.jet_sel_loose == True], 3))
out_events["jetflav4"] = ak.Array(
getN(cms_events.jetflav[cms_events.jet_sel_loose == True], 4))
out_events["jetflav5"] = ak.Array(
getN(cms_events.jetflav[cms_events.jet_sel_loose == True], 5))
out_events["jetflav6"] = ak.Array(
getN(cms_events.jetflav[cms_events.jet_sel_loose == True], 6))
out_events["csv0"] = ak.Array(
getN(cms_events.jetcsv[cms_events.jet_sel_tight == True], 0))
out_events["csv1"] = ak.Array(
getN(cms_events.jetcsv[cms_events.jet_sel_loose == True], 1))
out_events["csv2"] = ak.Array(
getN(cms_events.jetcsv[cms_events.jet_sel_loose == True], 2))
out_events["csv3"] = ak.Array(
getN(cms_events.jetcsv[cms_events.jet_sel_loose == True], 3))
out_events["SR_2b"] = cms_events["mask_SR2b"]
out_events["SR_1b"] = cms_events["mask_SR1b"]
out_events["ZeeCR_2b"] = cms_events["mask_Zee2b"]
out_events["ZeeCR_1b"] = cms_events["mask_Zee1b"]
out_events["ZmumuCR_2b"] = cms_events["mask_Zmumu2b"]
out_events["ZmumuCR_1b"] = cms_events["mask_Zmumu1b"]
out_events["TopenuCR_2b"] = cms_events["mask_topenu2b"]
out_events["TopenuCR_1b"] = cms_events["mask_topenu1b"]
out_events["TopmunuCR_2b"] = cms_events["mask_topmunu2b"]
out_events["TopmunuCR_1b"] = cms_events["mask_topmunu1b"]
out_events["WenuCR_1b"] = cms_events["mask_wenu1b"]
out_events["WenuCR_2b"] = cms_events["mask_wenu2b"]
out_events["WmunuCR_1b"] = cms_events["mask_wmunu1b"]
out_events["WmunuCR_2b"] = cms_events["mask_wmunu2b"]
## btagging SFs
from read_sfs import btag_sf
from read_sfs import evaluator
out_events["btagsf0"] = btag_sf.eval("central", out_events.jetflav0,
abs(out_events.jeteta0),
out_events.jetpt0)
out_events["btagsf1"] = btag_sf.eval("central", out_events.jetflav1,
abs(out_events.jeteta1),
out_events.jetpt1)
out_events["btagsf2"] = btag_sf.eval("central", out_events.jetflav2,
abs(out_events.jeteta2),
out_events.jetpt2)
out_events["btagsf3"] = btag_sf.eval("central", out_events.jetflav3,
abs(out_events.jeteta3),
out_events.jetpt3)
out_events["btagsf4"] = btag_sf.eval("central", out_events.jetflav4,
abs(out_events.jeteta4),
out_events.jetpt4)
out_events["btagsf5"] = btag_sf.eval("central", out_events.jetflav5,
abs(out_events.jeteta5),
out_events.jetpt5)
out_events["btagsf6"] = btag_sf.eval("central", out_events.jetflav6,
abs(out_events.jeteta6),
out_events.jetpt6)
## btag efficiency
out_events["btag_eff_lwp_0"] = evaluator["btag_eff_lwp"](
out_events.jeteta0, out_events.jetpt0)
out_events["btag_eff_lwp_1"] = evaluator["btag_eff_lwp"](
out_events.jeteta1, out_events.jetpt1)
out_events["ctag_eff_lwp_0"] = evaluator["ctag_eff_lwp"](
out_events.jeteta0, out_events.jetpt0)
out_events["ctag_eff_lwp_1"] = evaluator["ctag_eff_lwp"](
out_events.jeteta1, out_events.jetpt1)
out_events["ltag_eff_lwp_0"] = evaluator["ltag_eff_lwp"](
out_events.jeteta0, out_events.jetpt0)
out_events["ltag_eff_lwp_1"] = evaluator["ltag_eff_lwp"](
out_events.jeteta1, out_events.jetpt1)
out_events["btag_eff_mwp_0"] = evaluator["btag_eff_mwp"](
out_events.jeteta0, out_events.jetpt0)
out_events["btag_eff_mwp_1"] = evaluator["btag_eff_mwp"](
out_events.jeteta1, out_events.jetpt1)
out_events["ctag_eff_mwp_0"] = evaluator["ctag_eff_mwp"](
out_events.jeteta0, out_events.jetpt0)
out_events["ctag_eff_mwp_1"] = evaluator["ctag_eff_mwp"](
out_events.jeteta1, out_events.jetpt1)
out_events["ltag_eff_mwp_0"] = evaluator["ltag_eff_mwp"](
out_events.jeteta0, out_events.jetpt0)
out_events["ltag_eff_mwp_1"] = evaluator["ltag_eff_mwp"](
out_events.jeteta1, out_events.jetpt1)
## ele sfs
out_events["eleTightSF0"] = evaluator["EGamma_SF2D_T"](out_events.eleeta0,
out_events.elept0)
out_events["eleLooseSF1"] = evaluator["EGamma_SF2D_L"](out_events.eleeta1,
out_events.elept1)
out_events["eleTrigSF0"] = evaluator["EGamma_SF2D_Trig"](
out_events.eleeta0, out_events.elept0)
out_events["eleRecoSF0"] = evaluator["EGamma_SF2D_Reco"](
out_events.eleeta0, out_events.elept0)
eleRecoSF1_hi = evaluator["EGamma_SF2D_Reco"](out_events.eleeta1,
out_events.elept1)
eleRecoSF1_lo = evaluator["EGamma_SF2D_Reco_lowpt"](out_events.eleeta1,
out_events.elept1)
eleRecoSF1_hi_ = ak.fill_none(
ak.mask(eleRecoSF1_hi, out_events.elept1 > 20.), 0)
eleRecoSF1_lo_ = ak.fill_none(
ak.mask(eleRecoSF1_lo, out_events.elept1 > 20.), 0)
out_events["eleRecoSF1"] = eleRecoSF1_hi_ + eleRecoSF1_lo_
## muon sfs
bcdef_lumi = 19.554725529
gh_lumi = 16.224846377
total_lumi = bcdef_lumi + gh_lumi
##--------low pt Loose
muonLooseIDSF_lowpt1 = (
(bcdef_lumi * evaluator["muon_lowpt_BCDEF_LooseID"]
(out_events.mupt1, abs(out_events.mueta1))) +
(gh_lumi * evaluator["muon_lowpt_GH_LooseID"]
(out_events.mupt1, abs(out_events.mueta1)))) / total_lumi
##----------- medium pt Loose
muonLooseIDSF1 = ((bcdef_lumi * evaluator["muon_highpt_BCDEF_LooseID"]
(out_events.mueta1, out_events.mupt1)) +
(gh_lumi * evaluator["muon_highpt_GH_LooseID"]
(out_events.mueta1, out_events.mupt1))) / total_lumi
muonLooseISOSF1 = ((bcdef_lumi * evaluator["muon_highpt_BCDEF_LooseISO"]
(out_events.mueta1, out_events.mupt1)) +
(gh_lumi * evaluator["muon_highpt_GH_LooseISO"]
(out_events.mueta1, out_events.mupt1))) / total_lumi
muon_loose_ID_low_SF_1 = ak.fill_none(
ak.mask(muonLooseIDSF_lowpt1, out_events.mupt1 < 20.), 0)
muon_loose_ID_high_SF_1 = ak.fill_none(
ak.mask(muonLooseIDSF1, out_events.mupt1 > 20.), 0)
muon_loose_ID_SF_1 = muon_loose_ID_low_SF_1 + muon_loose_ID_high_SF_1
out_events["muLooseSF1"] = muon_loose_ID_SF_1 * muonLooseISOSF1
##------------medium pt tight
muonTightIDSF0 = ((bcdef_lumi * evaluator["muon_highpt_BCDEF_TightID"]
(out_events.mueta0, out_events.mupt0)) +
(gh_lumi * evaluator["muon_highpt_GH_TightID"]
(out_events.mueta0, out_events.mupt0))) / total_lumi
muonTightISOSF0 = ((bcdef_lumi * evaluator["muon_highpt_BCDEF_TightISO"]
(out_events.mueta0, out_events.mupt0)) +
(gh_lumi * evaluator["muon_highpt_GH_TightISO"]
(out_events.mueta0, out_events.mupt0))) / total_lumi
out_events["muTightSF0"] = muonTightIDSF0 * muonTightISOSF0
out_events["puweight"] = evaluator["pu_weight"](cms_events.nTrueInt)
## trigger sfs
out_events["mettrigWeight"] = evaluator["met_trig"](cms_events.metpt)
out_events["recoilWmunutrigWeight"] = evaluator["met_trig"](
cms_events.recoil_Wmunu0)
out_events["recoilWenutrigWeight"] = evaluator["met_trig"](
cms_events.recoil_Wenu0)
out_events["recoilZmumutrigWeight"] = evaluator["met_trig"](
cms_events.Zmumu_recoil)
out_events["recoilZeetrigWeight"] = evaluator["met_trig"](
cms_events.Zee_recoil)
## Fill weights for each CR so that we don't need to worry later
out_events["weight_SR_2b"] = out_events.puweight * out_events.mettrigWeight
out_events["weight_SR_1b"] = out_events.puweight * out_events.mettrigWeight
out_events["weight_ZeeCR_2b"] = out_events.puweight * out_events.eleTrigSF0
out_events["weight_ZeeCR_1b"] = out_events.puweight * out_events.eleTrigSF0
out_events[
"weight_ZmumuCR_2b"] = out_events.puweight * out_events.recoilZmumutrigWeight
out_events[
"weight_ZmumuCR_1b"] = out_events.puweight * out_events.recoilZmumutrigWeight
out_events[
"weight_TopenuCR_2b"] = out_events.puweight * out_events.eleTrigSF0
out_events[
"weight_TopenuCR_1b"] = out_events.puweight * out_events.eleTrigSF0
out_events[
"weight_TopmunuCR_2b"] = out_events.puweight * out_events.recoilWmunutrigWeight
out_events[
"weight_TopmunuCR_1b"] = out_events.puweight * out_events.recoilWmunutrigWeight
out_events[
"weight_WenuCR_1b"] = out_events.puweight * out_events.eleTrigSF0
out_events[
"weight_WenuCR_2b"] = out_events.puweight * out_events.eleTrigSF0
out_events[
"weight_WmunuCR_1b"] = out_events.puweight * out_events.recoilWmunutrigWeight
out_events[
"weight_WmunuCR_2b"] = out_events.puweight * out_events.recoilWmunutrigWeight
## Fill Histograms
from variables import vardict, regions, variables_common
from binning import binning
f = TFile(outputfile, "RECREATE")
for ireg in regions:
thisregion = out_events[out_events[ireg] == True]
thisregion_ = thisregion[~(ak.is_none(thisregion))]
weight_ = "weight_" + ireg
for ivar in variables_common[ireg]:
hist_name_ = "h_reg_" + ireg + "_" + vardict[ivar]
h = VarToHist(thisregion_[ivar], thisregion_[weight_], hist_name_,
binning[ireg][ivar])
f.cd()
h.Write()
h_total = TH1F("h_total_mcweight", "h_total_mcweight", 2, 0, 2)
h_total.SetBinContent(1, nevents)
f.cd()
h_total.Write()
write_parquet = False
if write_parquet:
ak.to_parquet(out_events, "analysis_wjets_allevents.parquet")
def process(self, events):
dataset = events.metadata['dataset']
isRealData = not hasattr(events, "genWeight")
selection = PackedSelection()
weights = Weights(len(events))
output = self.accumulator.identity()
if not isRealData:
output['sumw'][dataset] += ak.sum(events.genWeight)
if isRealData:
trigger = np.zeros(len(events), dtype='bool')
for t in self._triggers[self._year]:
trigger = trigger | events.HLT[t]
else:
trigger = np.ones(len(events), dtype='bool')
selection.add('trigger', trigger)
if isRealData:
trigger = np.zeros(len(events), dtype='bool')
for t in self._muontriggers[self._year]:
trigger = trigger | events.HLT[t]
else:
trigger = np.ones(len(events), dtype='bool')
selection.add('muontrigger', trigger)
fatjets = events.FatJet
fatjets['msdcorr'] = corrected_msoftdrop(fatjets)
fatjets['qcdrho'] = 2 * np.log(fatjets.msdcorr / fatjets.pt)
fatjets['n2ddt'] = fatjets.n2b1 - n2ddt_shift(fatjets, year=self._year)
fatjets['msdcorr_full'] = fatjets['msdcorr'] * self._msdSF[self._year]
candidatejet = fatjets[
# https://github.com/DAZSLE/BaconAnalyzer/blob/master/Analyzer/src/VJetLoader.cc#L269
(fatjets.pt > 200)
& (abs(fatjets.eta) < 2.5)
& fatjets.isTight # this is loose in sampleContainer
]
if self._jet_arbitration == 'pt':
candidatejet = ak.firsts(candidatejet)
elif self._jet_arbitration == 'mass':
candidatejet = candidatejet[ak.argmax(candidatejet.msdcorr)]
elif self._jet_arbitration == 'n2':
candidatejet = candidatejet[ak.argmin(candidatejet.n2ddt)]
elif self._jet_arbitration == 'ddb':
candidatejet = candidatejet[ak.argmax(candidatejet.btagDDBvL)]
else:
raise RuntimeError("Unknown candidate jet arbitration")
selection.add('minjetkin', (candidatejet.pt >= 450)
& (candidatejet.msdcorr >= 40.)
& (abs(candidatejet.eta) < 2.5))
selection.add('jetacceptance', (candidatejet.msdcorr >= 47.)
& (candidatejet.pt < 1200)
& (candidatejet.msdcorr < 201.))
selection.add('jetid', candidatejet.isTight)
selection.add('n2ddt', (candidatejet.n2ddt < 0.))
selection.add('ddbpass', (candidatejet.btagDDBvL >= 0.89))
jets = events.Jet[(events.Jet.pt > 30.)
& (abs(events.Jet.eta) < 2.5)
& events.Jet.isTight]
# only consider first 4 jets to be consistent with old framework
jets = jets[:, :4]
dphi = abs(jets.delta_phi(candidatejet))
selection.add(
'antiak4btagMediumOppHem',
ak.max(
jets[dphi > np.pi / 2].btagDeepB, axis=1, mask_identity=False)
< BTagEfficiency.btagWPs[self._year]['medium'])
ak4_away = jets[dphi > 0.8]
selection.add(
'ak4btagMedium08',
ak.max(ak4_away.btagDeepB, axis=1, mask_identity=False) >
BTagEfficiency.btagWPs[self._year]['medium'])
selection.add('met', events.MET.pt < 140.)
goodmuon = ((events.Muon.pt > 10)
& (abs(events.Muon.eta) < 2.4)
& (events.Muon.pfRelIso04_all < 0.25)
& events.Muon.looseId)
nmuons = ak.sum(goodmuon, axis=1)
leadingmuon = ak.firsts(events.Muon[goodmuon])
nelectrons = ak.sum(
(events.Electron.pt > 10)
& (abs(events.Electron.eta) < 2.5)
& (events.Electron.cutBased >= events.Electron.LOOSE),
axis=1,
)
ntaus = ak.sum(
(events.Tau.pt > 20)
& events.Tau.idDecayMode, # bacon iso looser than Nano selection
axis=1,
)
selection.add('noleptons',
(nmuons == 0) & (nelectrons == 0) & (ntaus == 0))
selection.add('onemuon',
(nmuons == 1) & (nelectrons == 0) & (ntaus == 0))
selection.add('muonkin',
(leadingmuon.pt > 55.) & (abs(leadingmuon.eta) < 2.1))
selection.add('muonDphiAK8',
abs(leadingmuon.delta_phi(candidatejet)) > 2 * np.pi / 3)
if isRealData:
genflavor = 0
else:
weights.add('genweight', events.genWeight)
add_pileup_weight(weights, events.Pileup.nPU, self._year, dataset)
bosons = getBosons(events.GenPart)
matchedBoson = candidatejet.nearest(bosons,
axis=None,
threshold=0.8)
genflavor = bosonFlavor(matchedBoson)
genBosonPt = ak.fill_none(ak.firsts(bosons.pt), 0)
add_VJets_NLOkFactor(weights, genBosonPt, self._year, dataset)
add_jetTriggerWeight(weights, candidatejet.msdcorr,
candidatejet.pt, self._year)
output['btagWeight'].fill(dataset=dataset,
val=self._btagSF.addBtagWeight(
weights, ak4_away))
logger.debug("Weight statistics: %r" % weights.weightStatistics)
msd_matched = candidatejet.msdcorr * self._msdSF[self._year] * (
genflavor > 0) + candidatejet.msdcorr * (genflavor == 0)
regions = {
'signal': [
'trigger', 'minjetkin', 'jetacceptance', 'jetid', 'n2ddt',
'antiak4btagMediumOppHem', 'met', 'noleptons'
],
'muoncontrol': [
'muontrigger', 'minjetkin', 'jetacceptance', 'jetid', 'n2ddt',
'ak4btagMedium08', 'onemuon', 'muonkin', 'muonDphiAK8'
],
'noselection': [],
}
for region, cuts in regions.items():
allcuts = set()
output['cutflow'].fill(dataset=dataset,
region=region,
genflavor=genflavor,
cut=0,
weight=weights.weight())
for i, cut in enumerate(cuts + ['ddbpass']):
allcuts.add(cut)
cut = selection.all(*allcuts)
output['cutflow'].fill(dataset=dataset,
region=region,
genflavor=genflavor[cut],
cut=i + 1,
weight=weights.weight()[cut])
systematics = [
None,
'jet_triggerUp',
'jet_triggerDown',
'btagWeightUp',
'btagWeightDown',
'btagEffStatUp',
'btagEffStatDown',
]
def normalize(val, cut):
return ak.to_numpy(ak.fill_none(val[cut], np.nan))
def fill(region, systematic, wmod=None):
selections = regions[region]
cut = selection.all(*selections)
sname = 'nominal' if systematic is None else systematic
if wmod is None:
weight = weights.weight(modifier=systematic)[cut]
else:
weight = weights.weight()[cut] * wmod[cut]
output['templates'].fill(
dataset=dataset,
region=region,
systematic=sname,
genflavor=genflavor[cut],
pt=normalize(candidatejet.pt, cut),
msd=normalize(msd_matched, cut),
ddb=normalize(candidatejet.btagDDBvL, cut),
weight=weight,
)
if wmod is not None:
output['genresponse_noweight'].fill(
dataset=dataset,
region=region,
systematic=sname,
pt=normalize(candidatejet.pt, cut),
genpt=normalize(genBosonPt, cut),
weight=events.genWeight[cut] * wmod[cut],
)
output['genresponse'].fill(
dataset=dataset,
region=region,
systematic=sname,
pt=normalize(candidatejet.pt, cut),
genpt=normalize(genBosonPt, cut),
weight=weight,
)
for region in regions:
cut = selection.all(*(set(regions[region]) - {'n2ddt'}))
output['nminus1_n2ddt'].fill(
dataset=dataset,
region=region,
n2ddt=normalize(candidatejet.n2ddt, cut),
weight=weights.weight()[cut],
)
for systematic in systematics:
fill(region, systematic)
if 'GluGluHToBB' in dataset:
for i in range(9):
fill(region, 'LHEScale_%d' % i, events.LHEScaleWeight[:,
i])
for c in events.LHEWeight.columns[1:]:
fill(region, 'LHEWeight_%s' % c, events.LHEWeight[c])
output["weightStats"] = weights.weightStatistics
return output
cms_events["mu_q0"] = ak.Array(getN(cms_events.muq, 0))
cms_events["mu_q1"] = ak.Array(getN(cms_events.muq, 1))
cms_events["ele_sel_tight"] = (cms_events.eleidT == True) & (
cms_events.elept > 30) & (numpy.abs(cms_events.eleeta) < 2.5)
cms_events["ele_sel_tight0"] = ak.Array(getN(cms_events.ele_sel_tight, 0))
cms_events["nEleTight"] = ak.sum(cms_events.ele_sel_tight, axis=-1)
cms_events["nEleLoose"] = ak.sum((cms_events.elept > 10), axis=-1)
cms_events["ele_q0"] = ak.Array(getN(cms_events.eleq, 0))
cms_events["ele_q1"] = ak.Array(getN(cms_events.eleq, 1))
cms_events["recoil_Wmunu"] = getrecoil(cms_events.nMuTight, cms_events.mupt,
cms_events.muphi, cms_events.mupx,
cms_events.mupy, cms_events.metpt,
cms_events.metphi)
cms_events["recoil_Wmunu0"] = ak.firsts(cms_events.recoil_Wmunu)
cms_events["recoil_Wenu"] = getrecoil(cms_events.nEleTight, cms_events.elept,
cms_events.elephi, cms_events.elepx,
cms_events.elepy, cms_events.metpt,
cms_events.metphi)
cms_events["recoil_Wenu0"] = ak.firsts(cms_events.recoil_Wenu)
elepx0 = ak.Array(getN(cms_events.elepx, 0))
elepx1 = ak.Array(getN(cms_events.elepx, 1))
elepy0 = ak.Array(getN(cms_events.elepy, 0))
elepy1 = ak.Array(getN(cms_events.elepy, 1))
elepz0 = ak.Array(getN(cms_events.elepz, 0))
elepz1 = ak.Array(getN(cms_events.elepz, 1))
