def test_packed_selection():
from coffea.analysis_tools import PackedSelection
sel = PackedSelection()
shape = (10, )
all_true = np.full(shape=shape, fill_value=True, dtype=np.bool)
all_false = np.full(shape=shape, fill_value=False, dtype=np.bool)
fizz = np.arange(shape[0]) % 3 == 0
buzz = np.arange(shape[0]) % 5 == 0
ones = np.ones(shape=shape, dtype=np.uint64)
wrong_shape = ones = np.ones(shape=(shape[0] - 5, ), dtype=np.bool)
sel.add("all_true", all_true)
sel.add("all_false", all_false)
sel.add("fizz", fizz)
sel.add("buzz", buzz)
assert np.all(sel.require(all_true=True, all_false=False) == all_true)
# allow truthy values
assert np.all(sel.require(all_true=1, all_false=0) == all_true)
assert np.all(sel.all("all_true", "all_false") == all_false)
assert np.all(sel.any("all_true", "all_false") == all_true)
assert np.all(
sel.all("fizz", "buzz") == np.array([
True, False, False, False, False, False, False, False, False, False
]))
assert np.all(
sel.any("fizz", "buzz") == np.array(
[True, False, False, True, False, True, True, False, False, True]))
with pytest.raises(ValueError):
sel.add("wrong_shape", wrong_shape)
with pytest.raises(ValueError):
sel.add("ones", ones)
with pytest.raises(RuntimeError):
overpack = PackedSelection()
for i in range(65):
overpack.add("sel_%d", all_true)
def test_packed_selection():
from coffea.analysis_tools import PackedSelection
sel = PackedSelection()
counts, test_eta, test_pt = dummy_jagged_eta_pt()
all_true = np.full(shape=counts.shape, fill_value=True, dtype=np.bool)
all_false = np.full(shape=counts.shape, fill_value=False, dtype=np.bool)
ones = np.ones(shape=counts.shape, dtype=np.uint64)
wrong_shape = ones = np.ones(shape=(counts.shape[0] - 5, ), dtype=np.bool)
sel.add("all_true", all_true)
sel.add("all_false", all_false)
assert np.all(sel.require(all_true=True, all_false=False) == all_true)
assert np.all(sel.all("all_true", "all_false") == all_false)
try:
sel.require(all_true=1, all_false=0)
except ValueError:
pass
try:
sel.add("wrong_shape", wrong_shape)
except ValueError:
pass
try:
sel.add("ones", ones)
except ValueError:
pass
try:
overpack = PackedSelection()
for i in range(65):
overpack.add("sel_%d", all_true)
except RuntimeError:
pass
def process_shift(self, events, shift_name):
dataset = events.metadata['dataset']
isRealData = not hasattr(events, "genWeight")
selection = PackedSelection()
weights = Weights(len(events), storeIndividual=True)
output = self.make_output()
if shift_name is None and not isRealData:
output['sumw'] = ak.sum(events.genWeight)
if isRealData or self._newTrigger:
trigger = np.zeros(len(events), dtype='bool')
for t in self._triggers[self._year]:
if t in events.HLT.fields:
trigger = trigger | events.HLT[t]
selection.add('trigger', trigger)
del trigger
else:
selection.add('trigger', np.ones(len(events), dtype='bool'))
if isRealData:
selection.add(
'lumimask', lumiMasks[self._year](events.run,
events.luminosityBlock))
else:
selection.add('lumimask', np.ones(len(events), dtype='bool'))
if isRealData and self._skipRunB and self._year == '2017':
selection.add('dropB', events.run > 299329)
else:
selection.add('dropB', np.ones(len(events), dtype='bool'))
if isRealData:
trigger = np.zeros(len(events), dtype='bool')
for t in self._muontriggers[self._year]:
if t in events.HLT.fields:
trigger |= np.array(events.HLT[t])
selection.add('muontrigger', trigger)
del trigger
else:
selection.add('muontrigger', np.ones(len(events), dtype='bool'))
metfilter = np.ones(len(events), dtype='bool')
for flag in self._met_filters[
self._year]['data' if isRealData else 'mc']:
metfilter &= np.array(events.Flag[flag])
selection.add('metfilter', metfilter)
del metfilter
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
]
candidatejet = candidatejet[:, :
2] # Only consider first two to match generators
if self._jet_arbitration == 'pt':
candidatejet = ak.firsts(candidatejet)
elif self._jet_arbitration == 'mass':
candidatejet = ak.firsts(candidatejet[ak.argmax(
candidatejet.msdcorr, axis=1, keepdims=True)])
elif self._jet_arbitration == 'n2':
candidatejet = ak.firsts(candidatejet[ak.argmin(candidatejet.n2ddt,
axis=1,
keepdims=True)])
elif self._jet_arbitration == 'ddb':
candidatejet = ak.firsts(candidatejet[ak.argmax(
candidatejet.btagDDBvLV2, axis=1, keepdims=True)])
elif self._jet_arbitration == 'ddc':
candidatejet = ak.firsts(candidatejet[ak.argmax(
candidatejet.btagDDCvLV2, axis=1, keepdims=True)])
else:
raise RuntimeError("Unknown candidate jet arbitration")
if self._tagger == 'v1':
bvl = candidatejet.btagDDBvL
cvl = candidatejet.btagDDCvL
cvb = candidatejet.btagDDCvB
elif self._tagger == 'v2':
bvl = candidatejet.btagDDBvLV2
cvl = candidatejet.btagDDCvLV2
cvb = candidatejet.btagDDCvBV2
elif self._tagger == 'v3':
bvl = candidatejet.particleNetMD_Xbb
cvl = candidatejet.particleNetMD_Xcc / (
1 - candidatejet.particleNetMD_Xbb)
cvb = candidatejet.particleNetMD_Xcc / (
candidatejet.particleNetMD_Xcc +
candidatejet.particleNetMD_Xbb)
elif self._tagger == 'v4':
bvl = candidatejet.particleNetMD_Xbb
cvl = candidatejet.btagDDCvLV2
cvb = candidatejet.particleNetMD_Xcc / (
candidatejet.particleNetMD_Xcc +
candidatejet.particleNetMD_Xbb)
else:
raise ValueError("Not an option")
selection.add('minjetkin', (candidatejet.pt >= 450)
& (candidatejet.pt < 1200)
& (candidatejet.msdcorr >= 40.)
& (candidatejet.msdcorr < 201.)
& (abs(candidatejet.eta) < 2.5))
selection.add('_strict_mass', (candidatejet.msdcorr > 85) &
(candidatejet.msdcorr < 130))
selection.add('_high_score', cvl > 0.8)
selection.add('minjetkinmu', (candidatejet.pt >= 400)
& (candidatejet.pt < 1200)
& (candidatejet.msdcorr >= 40.)
& (candidatejet.msdcorr < 201.)
& (abs(candidatejet.eta) < 2.5))
selection.add('minjetkinw', (candidatejet.pt >= 200)
& (candidatejet.pt < 1200)
& (candidatejet.msdcorr >= 40.)
& (candidatejet.msdcorr < 201.)
& (abs(candidatejet.eta) < 2.5))
selection.add('jetid', candidatejet.isTight)
selection.add('n2ddt', (candidatejet.n2ddt < 0.))
if not self._tagger == 'v2':
selection.add('ddbpass', (bvl >= 0.89))
selection.add('ddcpass', (cvl >= 0.83))
selection.add('ddcvbpass', (cvb >= 0.2))
else:
selection.add('ddbpass', (bvl >= 0.7))
selection.add('ddcpass', (cvl >= 0.45))
selection.add('ddcvbpass', (cvb >= 0.03))
jets = events.Jet
jets = jets[(jets.pt > 30.) & (abs(jets.eta) < 2.5) & jets.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][self._ak4tagBranch],
axis=1,
mask_identity=False) <
BTagEfficiency.btagWPs[self._ak4tagger][self._year]['medium'])
ak4_away = jets[dphi > 0.8]
selection.add(
'ak4btagMedium08',
ak.max(ak4_away[self._ak4tagBranch], axis=1, mask_identity=False) >
BTagEfficiency.btagWPs[self._ak4tagger][self._year]['medium'])
met = events.MET
selection.add('met', 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])
if self._looseTau:
goodelectron = ((events.Electron.pt > 10)
& (abs(events.Electron.eta) < 2.5)
&
(events.Electron.cutBased >= events.Electron.VETO))
nelectrons = ak.sum(goodelectron, axis=1)
ntaus = ak.sum(
((events.Tau.pt > 20)
& (abs(events.Tau.eta) < 2.3)
& events.Tau.idDecayMode
& ((events.Tau.idMVAoldDM2017v2 & 2) != 0)
& ak.all(events.Tau.metric_table(events.Muon[goodmuon]) > 0.4,
axis=2)
& ak.all(events.Tau.metric_table(
events.Electron[goodelectron]) > 0.4,
axis=2)),
axis=1,
)
else:
goodelectron = (
(events.Electron.pt > 10)
& (abs(events.Electron.eta) < 2.5)
& (events.Electron.cutBased >= events.Electron.LOOSE))
nelectrons = ak.sum(goodelectron, axis=1)
ntaus = ak.sum(
(events.Tau.pt > 20)
&
events.Tau.idDecayMode # bacon iso looser than Nano selection
& ak.all(events.Tau.metric_table(events.Muon[goodmuon]) > 0.4,
axis=2)
& ak.all(events.Tau.metric_table(events.Electron[goodelectron])
> 0.4,
axis=2),
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)
# W-Tag (Tag and Probe)
# tag side
selection.add(
'ak4btagMediumOppHem',
ak.max(jets[dphi > np.pi / 2][self._ak4tagBranch],
axis=1,
mask_identity=False) >
BTagEfficiency.btagWPs[self._ak4tagger][self._year]['medium'])
selection.add('met40p', met.pt > 40.)
selection.add('tightMuon',
(leadingmuon.tightId) & (leadingmuon.pt > 53.))
# selection.add('ptrecoW', (leadingmuon + met).pt > 250.)
selection.add('ptrecoW200', (leadingmuon + met).pt > 200.)
selection.add(
'ak4btagNearMu',
leadingmuon.delta_r(leadingmuon.nearest(ak4_away, axis=None)) <
2.0)
_bjets = jets[self._ak4tagBranch] > BTagEfficiency.btagWPs[
self._ak4tagger][self._year]['medium']
# _nearAK8 = jets.delta_r(candidatejet) < 0.8
# _nearMu = jets.delta_r(ak.firsts(events.Muon)) < 0.3
# selection.add('ak4btagOld', ak.sum(_bjets & ~_nearAK8 & ~_nearMu, axis=1) >= 1)
_nearAK8 = jets.delta_r(candidatejet) < 0.8
_nearMu = jets.delta_r(leadingmuon) < 0.3
selection.add('ak4btagOld',
ak.sum(_bjets & ~_nearAK8 & ~_nearMu, axis=1) >= 1)
# _nearAK8 = jets.delta_r(candidatejet) < 0.8
# _nearMu = jets.delta_r(candidatejet.nearest(events.Muon[goodmuon], axis=None)) < 0.3
# selection.add('ak4btagNew', ak.sum(_bjets & ~_nearAK8 & ~_nearMu, axis=1) >= 1)
# probe side
selection.add('minWjetpteta',
(candidatejet.pt >= 200) & (abs(candidatejet.eta) < 2.4))
# selection.add('noNearMuon', candidatejet.delta_r(candidatejet.nearest(events.Muon[goodmuon], axis=None)) > 1.0)
selection.add('noNearMuon', candidatejet.delta_r(leadingmuon) > 1.0)
#####
if isRealData:
genflavor = ak.zeros_like(candidatejet.pt)
else:
if 'HToCC' in dataset or 'HToBB' in dataset:
if self._ewkHcorr:
add_HiggsEW_kFactors(weights, events.GenPart, dataset)
weights.add('genweight', events.genWeight)
if "PSWeight" in events.fields:
add_ps_weight(weights, events.PSWeight)
else:
add_ps_weight(weights, None)
if "LHEPdfWeight" in events.fields:
add_pdf_weight(weights, events.LHEPdfWeight)
else:
add_pdf_weight(weights, None)
if "LHEScaleWeight" in events.fields:
add_scalevar_7pt(weights, events.LHEScaleWeight)
add_scalevar_3pt(weights, events.LHEScaleWeight)
else:
add_scalevar_7pt(weights, [])
add_scalevar_3pt(weights, [])
add_pileup_weight(weights, events.Pileup.nPU, self._year, dataset)
bosons = getBosons(events.GenPart)
matchedBoson = candidatejet.nearest(bosons,
axis=None,
threshold=0.8)
if self._tightMatch:
match_mask = (
(candidatejet.pt - matchedBoson.pt) / matchedBoson.pt <
0.5) & ((candidatejet.msdcorr - matchedBoson.mass) /
matchedBoson.mass < 0.3)
selmatchedBoson = ak.mask(matchedBoson, match_mask)
genflavor = bosonFlavor(selmatchedBoson)
else:
genflavor = bosonFlavor(matchedBoson)
genBosonPt = ak.fill_none(ak.firsts(bosons.pt), 0)
if self._newVjetsKfactor:
add_VJets_kFactors(weights, events.GenPart, dataset)
else:
add_VJets_NLOkFactor(weights, genBosonPt, self._year, dataset)
if shift_name is None:
output['btagWeight'].fill(val=self._btagSF.addBtagWeight(
weights, ak4_away, self._ak4tagBranch))
if self._nnlops_rew and dataset in [
'GluGluHToCC_M125_13TeV_powheg_pythia8'
]:
weights.add('minlo_rew',
powheg_to_nnlops(ak.to_numpy(genBosonPt)))
if self._newTrigger:
add_jetTriggerSF(
weights, ak.firsts(fatjets),
self._year if not self._skipRunB else f'{self._year}CDEF',
selection)
else:
add_jetTriggerWeight(weights, candidatejet.msdcorr,
candidatejet.pt, self._year)
add_mutriggerSF(weights, leadingmuon, self._year, selection)
add_mucorrectionsSF(weights, leadingmuon, self._year, selection)
if self._year in ("2016", "2017"):
weights.add("L1Prefiring", events.L1PreFiringWeight.Nom,
events.L1PreFiringWeight.Up,
events.L1PreFiringWeight.Dn)
logger.debug("Weight statistics: %r" % weights.weightStatistics)
msd_matched = candidatejet.msdcorr * self._msdSF[self._year] * (
genflavor > 0) + candidatejet.msdcorr * (genflavor == 0)
regions = {
'signal': [
'noleptons', 'minjetkin', 'met', 'metfilter', 'jetid',
'antiak4btagMediumOppHem', 'n2ddt', 'trigger', 'lumimask'
],
'signal_noddt': [
'noleptons', 'minjetkin', 'met', 'jetid',
'antiak4btagMediumOppHem', 'trigger', 'lumimask', 'metfilter'
],
# 'muoncontrol': ['minjetkinmu', 'jetid', 'n2ddt', 'ak4btagMedium08', 'onemuon', 'muonkin', 'muonDphiAK8', 'muontrigger', 'lumimask', 'metfilter'],
'muoncontrol': [
'onemuon', 'muonkin', 'muonDphiAK8', 'metfilter',
'minjetkinmu', 'jetid', 'ak4btagMedium08', 'n2ddt',
'muontrigger', 'lumimask'
],
'muoncontrol_noddt': [
'onemuon', 'muonkin', 'muonDphiAK8', 'jetid', 'metfilter',
'minjetkinmu', 'jetid', 'ak4btagMedium08', 'muontrigger',
'lumimask'
],
'wtag': [
'onemuon', 'tightMuon', 'minjetkinw', 'jetid', 'met40p',
'metfilter', 'ptrecoW200', 'ak4btagOld', 'muontrigger',
'lumimask'
],
'wtag0': [
'onemuon', 'tightMuon', 'met40p', 'metfilter', 'ptrecoW200',
'ak4btagOld', 'muontrigger', 'lumimask'
],
'wtag2': [
'onemuon', 'tightMuon', 'minjetkinw', 'jetid',
'ak4btagMediumOppHem', 'met40p', 'metfilter', 'ptrecoW200',
'ak4btagOld', 'muontrigger', 'lumimask'
],
'noselection': [],
}
def normalize(val, cut):
if cut is None:
ar = ak.to_numpy(ak.fill_none(val, np.nan))
return ar
else:
ar = ak.to_numpy(ak.fill_none(val[cut], np.nan))
return ar
import time
tic = time.time()
if shift_name is None:
for region, cuts in regions.items():
allcuts = set([])
cut = selection.all(*allcuts)
output['cutflow_msd'].fill(region=region,
genflavor=normalize(
genflavor, None),
cut=0,
weight=weights.weight(),
msd=normalize(msd_matched, None))
output['cutflow_eta'].fill(region=region,
genflavor=normalize(genflavor, cut),
cut=0,
weight=weights.weight()[cut],
eta=normalize(
candidatejet.eta, cut))
output['cutflow_pt'].fill(region=region,
genflavor=normalize(genflavor, cut),
cut=0,
weight=weights.weight()[cut],
pt=normalize(candidatejet.pt, cut))
for i, cut in enumerate(cuts + ['ddcvbpass', 'ddcpass']):
allcuts.add(cut)
cut = selection.all(*allcuts)
output['cutflow_msd'].fill(region=region,
genflavor=normalize(
genflavor, cut),
cut=i + 1,
weight=weights.weight()[cut],
msd=normalize(msd_matched, cut))
output['cutflow_eta'].fill(
region=region,
genflavor=normalize(genflavor, cut),
cut=i + 1,
weight=weights.weight()[cut],
eta=normalize(candidatejet.eta, cut))
output['cutflow_pt'].fill(
region=region,
genflavor=normalize(genflavor, cut),
cut=i + 1,
weight=weights.weight()[cut],
pt=normalize(candidatejet.pt, cut))
if self._evtVizInfo and 'ddcpass' in allcuts and isRealData and region == 'signal':
if 'event' not in events.fields:
continue
_cut = selection.all(*allcuts, '_strict_mass',
'_high_score')
# _cut = selection.all('_strict_mass'')
output['to_check'][
'mass'] += processor.column_accumulator(
normalize(msd_matched, _cut))
nfatjet = ak.sum(
((fatjets.pt > 200) &
(abs(fatjets.eta) < 2.5) & fatjets.isTight),
axis=1)
output['to_check'][
'njet'] += processor.column_accumulator(
normalize(nfatjet, _cut))
output['to_check'][
'fname'] += processor.column_accumulator(
np.array([events.metadata['filename']] *
len(normalize(msd_matched, _cut))))
output['to_check'][
'event'] += processor.column_accumulator(
normalize(events.event, _cut))
output['to_check'][
'luminosityBlock'] += processor.column_accumulator(
normalize(events.luminosityBlock, _cut))
output['to_check'][
'run'] += processor.column_accumulator(
normalize(events.run, _cut))
if shift_name is None:
systematics = [None] + list(weights.variations)
else:
systematics = [shift_name]
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:
if systematic in weights.variations:
weight = weights.weight(modifier=systematic)[cut]
else:
weight = weights.weight()[cut]
else:
weight = weights.weight()[cut] * wmod[cut]
output['templates'].fill(
region=region,
systematic=sname,
runid=runmap(events.run)[cut],
genflavor=normalize(genflavor, cut),
pt=normalize(candidatejet.pt, cut),
msd=normalize(msd_matched, cut),
ddb=normalize(bvl, cut),
ddc=normalize(cvl, cut),
ddcvb=normalize(cvb, cut),
weight=weight,
)
if region in [
'wtag', 'wtag0', 'wtag2', 'wtag3', 'wtag4', 'wtag5',
'wtag6', 'wtag7', 'noselection'
]: # and sname in ['nominal', 'pileup_weightDown', 'pileup_weightUp', 'jet_triggerDown', 'jet_triggerUp']:
output['wtag'].fill(
region=region,
systematic=sname,
genflavor=normalize(genflavor, cut),
pt=normalize(candidatejet.pt, cut),
msd=normalize(msd_matched, cut),
n2ddt=normalize(candidatejet.n2ddt, cut),
ddc=normalize(cvl, cut),
ddcvb=normalize(cvb, cut),
weight=weight,
)
# if region in ['signal', 'noselection']:
# output['etaphi'].fill(
# region=region,
# systematic=sname,
# runid=runmap(events.run)[cut],
# genflavor=normalize(genflavor, cut),
# pt=normalize(candidatejet.pt, cut),
# eta=normalize(candidatejet.eta, cut),
# phi=normalize(candidatejet.phi, cut),
# ddc=normalize(cvl, cut),
# ddcvb=normalize(cvb, cut),
# ),
if not isRealData:
if wmod is not None:
_custom_weight = events.genWeight[cut] * wmod[cut]
else:
_custom_weight = np.ones_like(weight)
output['genresponse_noweight'].fill(
region=region,
systematic=sname,
pt=normalize(candidatejet.pt, cut),
genpt=normalize(genBosonPt, cut),
weight=_custom_weight,
)
output['genresponse'].fill(
region=region,
systematic=sname,
pt=normalize(candidatejet.pt, cut),
genpt=normalize(genBosonPt, cut),
weight=weight,
)
if systematic is None:
output['signal_opt'].fill(
region=region,
genflavor=normalize(genflavor, cut),
ddc=normalize(cvl, cut),
ddcvb=normalize(cvb, cut),
msd=normalize(msd_matched, cut),
weight=weight,
)
output['signal_optb'].fill(
region=region,
genflavor=normalize(genflavor, cut),
ddb=normalize(bvl, cut),
msd=normalize(msd_matched, cut),
weight=weight,
)
for region in regions:
cut = selection.all(*(set(regions[region]) - {'n2ddt'}))
if shift_name is None:
output['nminus1_n2ddt'].fill(
region=region,
n2ddt=normalize(candidatejet.n2ddt, cut),
weight=weights.weight()[cut],
)
for systematic in systematics:
if isRealData and systematic is not None:
continue
fill(region, systematic)
if shift_name is None and 'GluGluH' in dataset and 'LHEWeight' in events.fields:
for i in range(9):
fill(region, 'LHEScale_%d' % i, events.LHEScaleWeight[:,
i])
for c in events.LHEWeight.fields[1:]:
fill(region, 'LHEWeight_%s' % c, events.LHEWeight[c])
toc = time.time()
output["filltime"] = toc - tic
if shift_name is None:
output["weightStats"] = weights.weightStatistics
return {dataset: output}
def process(self, events):
# Dataset parameters
dataset = events.metadata['dataset']
year = self._samples[dataset]['year']
xsec = self._samples[dataset]['xsec']
sow = self._samples[dataset]['nSumOfWeights']
isData = self._samples[dataset]['isData']
datasets = [
'SingleMuon', 'SingleElectron', 'EGamma', 'MuonEG', 'DoubleMuon',
'DoubleElectron'
]
for d in datasets:
if d in dataset: dataset = dataset.split('_')[0]
# Initialize objects
met = events.MET
e = events.Electron
mu = events.Muon
tau = events.Tau
j = events.Jet
# Muon selection
#mu['isGood'] = isMuonMVA(mu.pt, mu.eta, mu.dxy, mu.dz, mu.miniPFRelIso_all, mu.sip3d, mu.mvaTTH, mu.mediumPromptId, mu.tightCharge, minpt=10)
mu['isPres'] = isPresMuon(mu.dxy, mu.dz, mu.sip3d, mu.looseId)
mu['isTight'] = isTightMuon(mu.pt,
mu.eta,
mu.dxy,
mu.dz,
mu.pfRelIso03_all,
mu.sip3d,
mu.mvaTTH,
mu.mediumPromptId,
mu.tightCharge,
mu.looseId,
minpt=10)
mu['isGood'] = mu['isPres'] & mu['isTight']
leading_mu = mu[ak.argmax(mu.pt, axis=-1, keepdims=True)]
leading_mu = leading_mu[leading_mu.isGood]
mu = mu[mu.isGood]
mu_pres = mu[mu.isPres]
# Electron selection
#e['isGood'] = isElecMVA(e.pt, e.eta, e.dxy, e.dz, e.miniPFRelIso_all, e.sip3d, e.mvaTTH, e.mvaFall17V2Iso, e.lostHits, e.convVeto, e.tightCharge, minpt=10)
e['isPres'] = isPresElec(e.pt,
e.eta,
e.dxy,
e.dz,
e.miniPFRelIso_all,
e.sip3d,
e.lostHits,
minpt=15)
e['isTight'] = isTightElec(e.pt,
e.eta,
e.dxy,
e.dz,
e.miniPFRelIso_all,
e.sip3d,
e.mvaTTH,
e.mvaFall17V2Iso,
e.lostHits,
e.convVeto,
e.tightCharge,
e.sieie,
e.hoe,
e.eInvMinusPInv,
minpt=15)
e['isClean'] = isClean(e, mu, drmin=0.05)
e['isGood'] = e['isPres'] & e['isTight'] & e['isClean']
leading_e = e[ak.argmax(e.pt, axis=-1, keepdims=True)]
leading_e = leading_e[leading_e.isGood]
e = e[e.isGood]
e_pres = e[e.isPres & e.isClean]
# Tau selection
tau['isPres'] = isPresTau(tau.pt,
tau.eta,
tau.dxy,
tau.dz,
tau.leadTkPtOverTauPt,
tau.idAntiMu,
tau.idAntiEle,
tau.rawIso,
tau.idDecayModeNewDMs,
minpt=20)
tau['isClean'] = isClean(tau, e_pres, drmin=0.4) & isClean(
tau, mu_pres, drmin=0.4)
tau['isGood'] = tau['isPres'] # & tau['isClean'], for the moment
tau = tau[tau.isGood]
nElec = ak.num(e)
nMuon = ak.num(mu)
nTau = ak.num(tau)
twoLeps = (nElec + nMuon) == 2
threeLeps = (nElec + nMuon) == 3
twoElec = (nElec == 2)
twoMuon = (nMuon == 2)
e0 = e[ak.argmax(e.pt, axis=-1, keepdims=True)]
m0 = mu[ak.argmax(mu.pt, axis=-1, keepdims=True)]
# Jet selection
jetptname = 'pt_nom' if hasattr(j, 'pt_nom') else 'pt'
j['isGood'] = isTightJet(getattr(j,
jetptname), j.eta, j.jetId, j.neHEF,
j.neEmEF, j.chHEF, j.chEmEF, j.nConstituents)
#j['isgood'] = isGoodJet(j.pt, j.eta, j.jetId)
#j['isclean'] = isClean(j, e, mu)
j['isClean'] = isClean(j, e, drmin=0.4) & isClean(
j, mu, drmin=0.4) # & isClean(j, tau, drmin=0.4)
goodJets = j[(j.isClean) & (j.isGood)]
njets = ak.num(goodJets)
ht = ak.sum(goodJets.pt, axis=-1)
j0 = goodJets[ak.argmax(goodJets.pt, axis=-1, keepdims=True)]
#nbtags = ak.num(goodJets[goodJets.btagDeepFlavB > 0.2770])
nbtags = ak.num(goodJets[goodJets.btagDeepB > 0.4941])
##################################################################
### 2 same-sign leptons
##################################################################
# emu
singe = e[(nElec == 1) & (nMuon == 1) & (e.pt > -1)]
singm = mu[(nElec == 1) & (nMuon == 1) & (mu.pt > -1)]
em = ak.cartesian({"e": singe, "m": singm})
emSSmask = (em.e.charge * em.m.charge > 0)
emSS = em[emSSmask]
nemSS = len(ak.flatten(emSS))
# ee and mumu
# pt>-1 to preserve jagged dimensions
ee = e[(nElec == 2) & (nMuon == 0) & (e.pt > -1)]
mm = mu[(nElec == 0) & (nMuon == 2) & (mu.pt > -1)]
eepairs = ak.combinations(ee, 2, fields=["e0", "e1"])
eeSSmask = (eepairs.e0.charge * eepairs.e1.charge > 0)
eeonZmask = (np.abs((eepairs.e0 + eepairs.e1).mass - 91.2) < 10)
eeoffZmask = (eeonZmask == 0)
mmpairs = ak.combinations(mm, 2, fields=["m0", "m1"])
mmSSmask = (mmpairs.m0.charge * mmpairs.m1.charge > 0)
mmonZmask = (np.abs((mmpairs.m0 + mmpairs.m1).mass - 91.2) < 10)
mmoffZmask = (mmonZmask == 0)
eeSSonZ = eepairs[eeSSmask & eeonZmask]
eeSSoffZ = eepairs[eeSSmask & eeoffZmask]
mmSSonZ = mmpairs[mmSSmask & mmonZmask]
mmSSoffZ = mmpairs[mmSSmask & mmoffZmask]
neeSS = len(ak.flatten(eeSSonZ)) + len(ak.flatten(eeSSoffZ))
nmmSS = len(ak.flatten(mmSSonZ)) + len(ak.flatten(mmSSoffZ))
print('Same-sign events [ee, emu, mumu] = [%i, %i, %i]' %
(neeSS, nemSS, nmmSS))
# Cuts
eeSSmask = (ak.num(eeSSmask[eeSSmask]) > 0)
mmSSmask = (ak.num(mmSSmask[mmSSmask]) > 0)
eeonZmask = (ak.num(eeonZmask[eeonZmask]) > 0)
eeoffZmask = (ak.num(eeoffZmask[eeoffZmask]) > 0)
mmonZmask = (ak.num(mmonZmask[mmonZmask]) > 0)
mmoffZmask = (ak.num(mmoffZmask[mmoffZmask]) > 0)
emSSmask = (ak.num(emSSmask[emSSmask]) > 0)
##################################################################
### 3 leptons
##################################################################
# eem
muon_eem = mu[(nElec == 2) & (nMuon == 1) & (mu.pt > -1)]
elec_eem = e[(nElec == 2) & (nMuon == 1) & (e.pt > -1)]
ee_eem = ak.combinations(elec_eem, 2, fields=["e0", "e1"])
ee_eemZmask = (ee_eem.e0.charge * ee_eem.e1.charge < 1) & (np.abs(
(ee_eem.e0 + ee_eem.e1).mass - 91.2) < 10)
ee_eemOffZmask = (ee_eem.e0.charge * ee_eem.e1.charge < 1) & (np.abs(
(ee_eem.e0 + ee_eem.e1).mass - 91.2) > 10)
ee_eemZmask = (ak.num(ee_eemZmask[ee_eemZmask]) > 0)
ee_eemOffZmask = (ak.num(ee_eemOffZmask[ee_eemOffZmask]) > 0)
eepair_eem = (ee_eem.e0 + ee_eem.e1)
trilep_eem = eepair_eem + muon_eem #ak.cartesian({"e0":ee_eem.e0,"e1":ee_eem.e1, "m":muon_eem})
# mme
muon_mme = mu[(nElec == 1) & (nMuon == 2) & (mu.pt > -1)]
elec_mme = e[(nElec == 1) & (nMuon == 2) & (e.pt > -1)]
mm_mme = ak.combinations(muon_mme, 2, fields=["m0", "m1"])
mm_mmeZmask = (mm_mme.m0.charge * mm_mme.m1.charge < 1) & (np.abs(
(mm_mme.m0 + mm_mme.m1).mass - 91.2) < 10)
mm_mmeOffZmask = (mm_mme.m0.charge * mm_mme.m1.charge < 1) & (np.abs(
(mm_mme.m0 + mm_mme.m1).mass - 91.2) > 10)
mm_mmeZmask = (ak.num(mm_mmeZmask[mm_mmeZmask]) > 0)
mm_mmeOffZmask = (ak.num(mm_mmeOffZmask[mm_mmeOffZmask]) > 0)
mmpair_mme = (mm_mme.m0 + mm_mme.m1)
trilep_mme = mmpair_mme + elec_mme
mZ_mme = mmpair_mme.mass
mZ_eem = eepair_eem.mass
m3l_eem = trilep_eem.mass
m3l_mme = trilep_mme.mass
# eee and mmm
eee = e[(nElec == 3) & (nMuon == 0) & (e.pt > -1)]
mmm = mu[(nElec == 0) & (nMuon == 3) & (mu.pt > -1)]
eee_leps = ak.combinations(eee, 3, fields=["e0", "e1", "e2"])
mmm_leps = ak.combinations(mmm, 3, fields=["m0", "m1", "m2"])
ee_pairs = ak.combinations(eee, 2, fields=["e0", "e1"])
mm_pairs = ak.combinations(mmm, 2, fields=["m0", "m1"])
ee_pairs_index = ak.argcombinations(eee, 2, fields=["e0", "e1"])
mm_pairs_index = ak.argcombinations(mmm, 2, fields=["m0", "m1"])
mmSFOS_pairs = mm_pairs[
(np.abs(mm_pairs.m0.pdgId) == np.abs(mm_pairs.m1.pdgId))
& (mm_pairs.m0.charge != mm_pairs.m1.charge)]
offZmask_mm = ak.all(
np.abs((mmSFOS_pairs.m0 + mmSFOS_pairs.m1).mass - 91.2) > 10.,
axis=1,
keepdims=True) & (ak.num(mmSFOS_pairs) > 0)
onZmask_mm = ak.any(
np.abs((mmSFOS_pairs.m0 + mmSFOS_pairs.m1).mass - 91.2) < 10.,
axis=1,
keepdims=True)
eeSFOS_pairs = ee_pairs[
(np.abs(ee_pairs.e0.pdgId) == np.abs(ee_pairs.e1.pdgId))
& (ee_pairs.e0.charge != ee_pairs.e1.charge)]
offZmask_ee = ak.all(
np.abs((eeSFOS_pairs.e0 + eeSFOS_pairs.e1).mass - 91.2) > 10,
axis=1,
keepdims=True) & (ak.num(eeSFOS_pairs) > 0)
onZmask_ee = ak.any(
np.abs((eeSFOS_pairs.e0 + eeSFOS_pairs.e1).mass - 91.2) < 10,
axis=1,
keepdims=True)
# Create masks **for event selection**
eeeOnZmask = (ak.num(onZmask_ee[onZmask_ee]) > 0)
eeeOffZmask = (ak.num(offZmask_ee[offZmask_ee]) > 0)
mmmOnZmask = (ak.num(onZmask_mm[onZmask_mm]) > 0)
mmmOffZmask = (ak.num(offZmask_mm[offZmask_mm]) > 0)
# Now we need to create masks for the leptons in order to select leptons from the Z boson candidate (in onZ categories)
ZeeMask = ak.argmin(np.abs((eeSFOS_pairs.e0 + eeSFOS_pairs.e1).mass -
91.2),
axis=1,
keepdims=True)
ZmmMask = ak.argmin(np.abs((mmSFOS_pairs.m0 + mmSFOS_pairs.m1).mass -
91.2),
axis=1,
keepdims=True)
Zee = eeSFOS_pairs[ZeeMask]
Zmm = mmSFOS_pairs[ZmmMask]
eZ0 = Zee.e0[ak.num(eeSFOS_pairs) > 0]
eZ1 = Zee.e1[ak.num(eeSFOS_pairs) > 0]
eZ = eZ0 + eZ1
mZ0 = Zmm.m0[ak.num(mmSFOS_pairs) > 0]
mZ1 = Zmm.m1[ak.num(mmSFOS_pairs) > 0]
mZ = mZ0 + mZ1
mZ_eee = eZ.mass
mZ_mmm = mZ.mass
# And for the W boson
ZmmIndices = mm_pairs_index[ZmmMask]
ZeeIndices = ee_pairs_index[ZeeMask]
eW = eee[~ZeeIndices.e0 | ~ZeeIndices.e1]
mW = mmm[~ZmmIndices.m0 | ~ZmmIndices.m1]
triElec = eee_leps.e0 + eee_leps.e1 + eee_leps.e2
triMuon = mmm_leps.m0 + mmm_leps.m1 + mmm_leps.m2
m3l_eee = triElec.mass
m3l_mmm = triMuon.mass
# Triggers
trig_eeSS = passTrigger(events, 'ee', isData, dataset)
trig_mmSS = passTrigger(events, 'mm', isData, dataset)
trig_emSS = passTrigger(events, 'em', isData, dataset)
trig_eee = passTrigger(events, 'eee', isData, dataset)
trig_mmm = passTrigger(events, 'mmm', isData, dataset)
trig_eem = passTrigger(events, 'eem', isData, dataset)
trig_mme = passTrigger(events, 'mme', isData, dataset)
# MET filters
# Weights
genw = np.ones_like(
events['MET_pt']) if isData else events['genWeight']
weights = coffea.analysis_tools.Weights(len(events))
weights.add('norm', genw if isData else (xsec / sow) * genw)
eftweights = events['EFTfitCoefficients'] if hasattr(
events, "EFTfitCoefficients") else []
# Selections and cuts
selections = PackedSelection()
channels2LSS = ['eeSSonZ', 'eeSSoffZ', 'mmSSonZ', 'mmSSoffZ', 'emSS']
selections.add('eeSSonZ', (eeonZmask) & (eeSSmask) & (trig_eeSS))
selections.add('eeSSoffZ', (eeoffZmask) & (eeSSmask) & (trig_eeSS))
selections.add('mmSSonZ', (mmonZmask) & (mmSSmask) & (trig_mmSS))
selections.add('mmSSoffZ', (mmoffZmask) & (mmSSmask) & (trig_mmSS))
selections.add('emSS', (emSSmask) & (trig_emSS))
channels3L = ['eemSSonZ', 'eemSSoffZ', 'mmeSSonZ', 'mmeSSoffZ']
selections.add('eemSSonZ', (ee_eemZmask) & (trig_eem))
selections.add('eemSSoffZ', (ee_eemOffZmask) & (trig_eem))
selections.add('mmeSSonZ', (mm_mmeZmask) & (trig_mme))
selections.add('mmeSSoffZ', (mm_mmeOffZmask) & (trig_mme))
channels3L += ['eeeSSonZ', 'eeeSSoffZ', 'mmmSSonZ', 'mmmSSoffZ']
selections.add('eeeSSonZ', (eeeOnZmask) & (trig_eee))
selections.add('eeeSSoffZ', (eeeOffZmask) & (trig_eee))
selections.add('mmmSSonZ', (mmmOnZmask) & (trig_mmm))
selections.add('mmmSSoffZ', (mmmOffZmask) & (trig_mmm))
levels = ['base', '2jets', '4jets', '4j1b', '4j2b']
selections.add('base', (nElec + nMuon >= 2))
selections.add('2jets', (njets >= 2))
selections.add('4jets', (njets >= 4))
selections.add('4j1b', (njets >= 4) & (nbtags >= 1))
selections.add('4j2b', (njets >= 4) & (nbtags >= 2))
# Variables
invMass_eeSSonZ = (eeSSonZ.e0 + eeSSonZ.e1).mass
invMass_eeSSoffZ = (eeSSoffZ.e0 + eeSSoffZ.e1).mass
invMass_mmSSonZ = (mmSSonZ.m0 + mmSSonZ.m1).mass
invMass_mmSSoffZ = (mmSSoffZ.m0 + mmSSoffZ.m1).mass
invMass_emSS = (emSS.e + emSS.m).mass
varnames = {}
varnames['met'] = met.pt
varnames['ht'] = ht
varnames['njets'] = njets
varnames['nbtags'] = nbtags
varnames['invmass'] = {
'eeSSonZ': invMass_eeSSonZ,
'eeSSoffZ': invMass_eeSSoffZ,
'mmSSonZ': invMass_mmSSonZ,
'mmSSoffZ': invMass_mmSSoffZ,
'emSS': invMass_emSS,
'eemSSonZ': mZ_eem,
'eemSSoffZ': mZ_eem,
'mmeSSonZ': mZ_mme,
'mmeSSoffZ': mZ_mme,
'eeeSSonZ': mZ_eee,
'eeeSSoffZ': mZ_eee,
'mmmSSonZ': mZ_mmm,
'mmmSSoffZ': mZ_mmm,
}
varnames['m3l'] = {
'eemSSonZ': m3l_eem,
'eemSSoffZ': m3l_eem,
'mmeSSonZ': m3l_mme,
'mmeSSoffZ': m3l_mme,
'eeeSSonZ': m3l_eee,
'eeeSSoffZ': m3l_eee,
'mmmSSonZ': m3l_mmm,
'mmmSSoffZ': m3l_mmm,
}
varnames['e0pt'] = e0.pt
varnames['e0eta'] = e0.eta
varnames['m0pt'] = m0.pt
varnames['m0eta'] = m0.eta
varnames['j0pt'] = j0.pt
varnames['j0eta'] = j0.eta
varnames['counts'] = np.ones_like(events.MET.pt)
# fill Histos
hout = self.accumulator.identity()
allweights = weights.weight().flatten(
) # Why does it not complain about .flatten() here?
hout['SumOfEFTweights'].fill(eftweights,
sample=dataset,
SumOfEFTweights=varnames['counts'],
weight=allweights)
for var, v in varnames.items():
for ch in channels2LSS + channels3L:
for lev in levels:
weight = weights.weight()
cuts = [ch] + [lev]
cut = selections.all(*cuts)
weights_flat = weight[cut].flatten(
) # Why does it not complain about .flatten() here?
weights_ones = np.ones_like(weights_flat, dtype=np.int)
eftweightsvalues = eftweights[cut] if len(
eftweights) > 0 else []
if var == 'invmass':
if ch in ['eeeSSoffZ', 'mmmSSoffZ']: continue
elif ch in ['eeeSSonZ', 'mmmSSonZ']:
continue #values = v[ch]
else:
values = ak.flatten(v[ch][cut])
hout['invmass'].fill(sample=dataset,
channel=ch,
cut=lev,
invmass=values,
weight=weights_flat)
elif var == 'm3l':
if ch in [
'eeSSonZ', 'eeSSoffZ', 'mmSSonZ', 'mmSSoffZ',
'emSS', 'eeeSSoffZ', 'mmmSSoffZ', 'eeeSSonZ',
'mmmSSonZ'
]:
continue
values = ak.flatten(v[ch][cut])
hout['m3l'].fill(eftweightsvalues,
sample=dataset,
channel=ch,
cut=lev,
m3l=values,
weight=weights_flat)
else:
values = v[cut]
if var == 'ht':
hout[var].fill(eftweightsvalues,
ht=values,
sample=dataset,
channel=ch,
cut=lev,
weight=weights_flat)
elif var == 'met':
hout[var].fill(eftweightsvalues,
met=values,
sample=dataset,
channel=ch,
cut=lev,
weight=weights_flat)
elif var == 'njets':
hout[var].fill(eftweightsvalues,
njets=values,
sample=dataset,
channel=ch,
cut=lev,
weight=weights_flat)
elif var == 'nbtags':
hout[var].fill(eftweightsvalues,
nbtags=values,
sample=dataset,
channel=ch,
cut=lev,
weight=weights_flat)
elif var == 'counts':
hout[var].fill(counts=values,
sample=dataset,
channel=ch,
cut=lev,
weight=weights_ones)
elif var == 'j0eta':
if lev == 'base': continue
values = ak.flatten(values)
#values=np.asarray(values)
hout[var].fill(eftweightsvalues,
j0eta=values,
sample=dataset,
channel=ch,
cut=lev,
weight=weights_flat)
elif var == 'e0pt':
if ch in [
'mmSSonZ', 'mmSSoffZ', 'mmmSSoffZ',
'mmmSSonZ'
]:
continue
values = ak.flatten(values)
#values=np.asarray(values)
hout[var].fill(
eftweightsvalues,
e0pt=values,
sample=dataset,
channel=ch,
cut=lev,
weight=weights_flat
) # Crashing here, not sure why. Related to values?
elif var == 'm0pt':
if ch in [
'eeSSonZ', 'eeSSoffZ', 'eeeSSoffZ',
'eeeSSonZ'
]:
continue
values = ak.flatten(values)
#values=np.asarray(values)
hout[var].fill(eftweightsvalues,
m0pt=values,
sample=dataset,
channel=ch,
cut=lev,
weight=weights_flat)
elif var == 'e0eta':
if ch in [
'mmSSonZ', 'mmSSoffZ', 'mmmSSoffZ',
'mmmSSonZ'
]:
continue
values = ak.flatten(values)
#values=np.asarray(values)
hout[var].fill(eftweightsvalues,
e0eta=values,
sample=dataset,
channel=ch,
cut=lev,
weight=weights_flat)
elif var == 'm0eta':
if ch in [
'eeSSonZ', 'eeSSoffZ', 'eeeSSoffZ',
'eeeSSonZ'
]:
continue
values = ak.flatten(values)
#values=np.asarray(values)
hout[var].fill(eftweightsvalues,
m0eta=values,
sample=dataset,
channel=ch,
cut=lev,
weight=weights_flat)
elif var == 'j0pt':
if lev == 'base': continue
values = ak.flatten(values)
#values=np.asarray(values)
hout[var].fill(eftweightsvalues,
j0pt=values,
sample=dataset,
channel=ch,
cut=lev,
weight=weights_flat)
return hout
def process(self, events):
# Dataset parameters
dataset = events.metadata['dataset']
year = self._samples[dataset]['year']
xsec = self._samples[dataset]['xsec']
sow = self._samples[dataset]['nSumOfWeights']
isData = self._samples[dataset]['isData']
datasets = [
'SingleMuon', 'SingleElectron', 'EGamma', 'MuonEG', 'DoubleMuon',
'DoubleElectron'
]
for d in datasets:
if d in dataset: dataset = dataset.split('_')[0]
# Extract the EFT quadratic coefficients and optionally use them to calculate the coefficients on the w**2 quartic function
# eft_coeffs is never Jagged so convert immediately to numpy for ease of use.
eft_coeffs = ak.to_numpy(events['EFTfitCoefficients']) if hasattr(
events, "EFTfitCoefficients") else None
if eft_coeffs is not None:
# Check to see if the ordering of WCs for this sample matches what want
if self._samples[dataset]['WCnames'] != self._wc_names_lst:
eft_coeffs = efth.remap_coeffs(
self._samples[dataset]['WCnames'], self._wc_names_lst,
eft_coeffs)
eft_w2_coeffs = efth.calc_w2_coeffs(eft_coeffs, self._dtype) if (
self._do_errors and eft_coeffs is not None) else None
# Initialize objects (GEN objects)
e = events.GenPart[abs(events.GenPart.pdgId) == 11]
m = events.GenPart[abs(events.GenPart.pdgId) == 13]
tau = events.GenPart[abs(events.GenPart.pdgId) == 15]
j = events.GenJet
run = events.run
luminosityBlock = events.luminosityBlock
event = events.event
print("\n\nInfo about events:")
print("\trun:", run)
print("\tluminosityBlock:", luminosityBlock)
print("\tevent:", event)
print("\nLeptons before selection:")
print("\te pt", e.pt)
print("\te eta", e.eta)
print("\tm pt", m.pt)
print("\tm eta", m.eta)
######## Lep selection ########
e_selec = ((e.pt > 15) & (abs(e.eta) < 2.5))
m_selec = ((m.pt > 15) & (abs(m.eta) < 2.5))
e = e[e_selec]
m = m[m_selec]
# Put the e and mu togheter
l = ak.concatenate([e, m], axis=1)
n_e = ak.num(e)
n_m = ak.num(m)
n_l = ak.num(l)
at_least_two_leps = (n_l >= 2)
e0 = e[ak.argmax(e.pt, axis=-1, keepdims=True)]
m0 = m[ak.argmax(m.pt, axis=-1, keepdims=True)]
l0 = l[ak.argmax(l.pt, axis=-1, keepdims=True)]
print("\nLeptons after selection:")
print("\te pt", e.pt)
print("\tm pt", m.pt)
print("\tl pt:", l.pt)
print("\tn e", n_e)
print("\tn m", n_m)
print("\tn l", n_l)
print("\nMask for at least two lep:", at_least_two_leps)
print("\nLeading lepton info:")
print("\te0", e0.pt)
print("\tm0", m0.pt)
print("\tl0", l0.pt)
######## Jet selection ########
print("\nJet info:")
print("\tjpt before selection", j.pt)
j_selec = ((j.pt > 30) & (abs(j.eta) < 2.5))
print("\tjselect", j_selec)
j = j[j_selec]
print("\tjpt", j.pt)
j['isClean'] = isClean(j, e, drmin=0.4) & isClean(j, m, drmin=0.4)
j_isclean = isClean(j, e, drmin=0.4) & isClean(j, m, drmin=0.4)
print("\tj is clean", j_isclean)
j = j[j_isclean]
print("\tclean jets pt", j.pt)
n_j = ak.num(j)
print("\tn_j", n_j)
j0 = j[ak.argmax(j.pt, axis=-1, keepdims=True)]
print("\tj0pt", j0.pt)
at_least_two_jets = (n_j >= 2)
print("\tat_least_two_jets", at_least_two_jets)
######## Selections and cuts ########
event_selec = (at_least_two_leps & at_least_two_jets)
print("\nEvent selection:", event_selec, "\n")
selections = PackedSelection()
selections.add('2l2j', event_selec)
varnames = {}
varnames['counts'] = np.ones_like(events.MET.pt)
varnames['njets'] = n_j
varnames['j0pt'] = j0.pt
varnames['j0eta'] = j0.eta
varnames['l0pt'] = l0.pt
######## Fill histos ########
print("\nFilling hists now...\n")
hout = self.accumulator.identity()
for var, v in varnames.items():
cut = selections.all("2l2j")
values = v[cut]
eft_coeffs_cut = eft_coeffs[cut] if eft_coeffs is not None else None
eft_w2_coeffs_cut = eft_w2_coeffs[
cut] if eft_w2_coeffs is not None else None
if var == "counts":
hout[var].fill(counts=values,
sample=dataset,
channel="2l",
cut="2l")
elif var == "njets":
hout[var].fill(njets=values,
sample=dataset,
channel="2l",
cut="2l",
eft_coeff=eft_coeffs_cut,
eft_err_coeff=eft_w2_coeffs_cut)
elif var == "j0pt":
hout[var].fill(j0pt=values,
sample=dataset,
channel="2l",
cut="2l",
eft_coeff=eft_coeffs_cut,
eft_err_coeff=eft_w2_coeffs_cut)
elif var == "j0eta":
hout[var].fill(j0eta=values,
sample=dataset,
channel="2l",
cut="2l",
eft_coeff=eft_coeffs_cut,
eft_err_coeff=eft_w2_coeffs_cut)
elif var == "l0pt":
hout[var].fill(l0pt=values,
sample=dataset,
channel="2l",
cut="2l",
eft_coeff=eft_coeffs_cut,
eft_err_coeff=eft_w2_coeffs_cut)
return hout
def process(self, events):
# Dataset parameters
dataset = events.metadata['dataset']
histAxisName = self._samples[dataset]['histAxisName']
year = self._samples[dataset]['year']
xsec = self._samples[dataset]['xsec']
sow = self._samples[dataset]['nSumOfWeights']
isData = self._samples[dataset]['isData']
datasets = [
'SingleMuon', 'SingleElectron', 'EGamma', 'MuonEG', 'DoubleMuon',
'DoubleElectron'
]
for d in datasets:
if d in dataset: dataset = dataset.split('_')[0]
# Initialize objects
met = events.MET
e = events.Electron
mu = events.Muon
tau = events.Tau
j = events.Jet
# Muon selection
mu['isPres'] = isPresMuon(mu.dxy, mu.dz, mu.sip3d, mu.looseId)
mu['isTight'] = isTightMuon(mu.pt,
mu.eta,
mu.dxy,
mu.dz,
mu.pfRelIso03_all,
mu.sip3d,
mu.mvaTTH,
mu.mediumPromptId,
mu.tightCharge,
mu.looseId,
minpt=10)
mu['isGood'] = mu['isPres'] & mu['isTight']
leading_mu = mu[ak.argmax(mu.pt, axis=-1, keepdims=True)]
leading_mu = leading_mu[leading_mu.isGood]
mu = mu[mu.isGood]
mu_pres = mu[mu.isPres]
# Electron selection
e['isPres'] = isPresElec(e.pt,
e.eta,
e.dxy,
e.dz,
e.miniPFRelIso_all,
e.sip3d,
e.lostHits,
minpt=15)
e['isTight'] = isTightElec(e.pt,
e.eta,
e.dxy,
e.dz,
e.miniPFRelIso_all,
e.sip3d,
e.mvaTTH,
e.mvaFall17V2Iso,
e.lostHits,
e.convVeto,
e.tightCharge,
e.sieie,
e.hoe,
e.eInvMinusPInv,
minpt=15)
e['isClean'] = isClean(e, mu, drmin=0.05)
e['isGood'] = e['isPres'] & e['isTight'] & e['isClean']
leading_e = e[ak.argmax(e.pt, axis=-1, keepdims=True)]
leading_e = leading_e[leading_e.isGood]
e = e[e.isGood]
e_pres = e[e.isPres & e.isClean]
# Tau selection
tau['isPres'] = isPresTau(tau.pt,
tau.eta,
tau.dxy,
tau.dz,
tau.leadTkPtOverTauPt,
tau.idAntiMu,
tau.idAntiEle,
tau.rawIso,
tau.idDecayModeNewDMs,
minpt=20)
tau['isClean'] = isClean(tau, e_pres, drmin=0.4) & isClean(
tau, mu_pres, drmin=0.4)
tau['isGood'] = tau['isPres'] # & tau['isClean'], for the moment
tau = tau[tau.isGood]
nElec = ak.num(e)
nMuon = ak.num(mu)
nTau = ak.num(tau)
twoLeps = (nElec + nMuon) == 2
threeLeps = (nElec + nMuon) == 3
twoElec = (nElec == 2)
twoMuon = (nMuon == 2)
e0 = e[ak.argmax(e.pt, axis=-1, keepdims=True)]
m0 = mu[ak.argmax(mu.pt, axis=-1, keepdims=True)]
# Attach the lepton SFs to the electron and muons collections
AttachElectronSF(e, year=year)
AttachMuonSF(mu, year=year)
# Create a lepton (muon+electron) collection and calculate a per event lepton SF
leps = ak.concatenate([e, mu], axis=-1)
events['lepSF_nom'] = ak.prod(leps.sf_nom, axis=-1)
events['lepSF_hi'] = ak.prod(leps.sf_hi, axis=-1)
events['lepSF_lo'] = ak.prod(leps.sf_lo, axis=-1)
# Jet selection
jetptname = 'pt_nom' if hasattr(j, 'pt_nom') else 'pt'
### Jet energy corrections
if not isData:
j["pt_raw"] = (1 - j.rawFactor) * j.pt
j["mass_raw"] = (1 - j.rawFactor) * j.mass
j["pt_gen"] = ak.values_astype(ak.fill_none(j.matched_gen.pt, 0),
np.float32)
j["rho"] = ak.broadcast_arrays(events.fixedGridRhoFastjetAll,
j.pt)[0]
events_cache = events.caches[0]
corrected_jets = jet_factory.build(j, lazy_cache=events_cache)
#print('jet pt: ',j.pt)
#print('cor pt: ',corrected_jets.pt)
#print('jes up: ',corrected_jets.JES_jes.up.pt)
#print('jes down: ',corrected_jets.JES_jes.down.pt)
#print(ak.fields(corrected_jets))
'''
# SYSTEMATICS
jets = corrected_jets
if(self.jetSyst == 'JERUp'):
jets = corrected_jets.JER.up
elif(self.jetSyst == 'JERDown'):
jets = corrected_jets.JER.down
elif(self.jetSyst == 'JESUp'):
jets = corrected_jets.JES_jes.up
elif(self.jetSyst == 'JESDown'):
jets = corrected_jets.JES_jes.down
'''
j['isGood'] = isTightJet(getattr(j,
jetptname), j.eta, j.jetId, j.neHEF,
j.neEmEF, j.chHEF, j.chEmEF, j.nConstituents)
#j['isgood'] = isGoodJet(j.pt, j.eta, j.jetId)
#j['isclean'] = isClean(j, e, mu)
j['isClean'] = isClean(j, e, drmin=0.4) & isClean(
j, mu, drmin=0.4) # & isClean(j, tau, drmin=0.4)
goodJets = j[(j.isClean) & (j.isGood)]
njets = ak.num(goodJets)
ht = ak.sum(goodJets.pt, axis=-1)
j0 = goodJets[ak.argmax(goodJets.pt, axis=-1, keepdims=True)]
#nbtags = ak.num(goodJets[goodJets.btagDeepFlavB > 0.2770])
# Loose DeepJet WP
if year == 2017: btagwpl = 0.0532 #WP loose
else: btagwpl = 0.0490 #WP loose
isBtagJetsLoose = (goodJets.btagDeepB > btagwpl)
isNotBtagJetsLoose = np.invert(isBtagJetsLoose)
nbtagsl = ak.num(goodJets[isBtagJetsLoose])
# Medium DeepJet WP
if year == 2017: btagwpm = 0.3040 #WP medium
else: btagwpm = 0.2783 #WP medium
isBtagJetsMedium = (goodJets.btagDeepB > btagwpm)
isNotBtagJetsMedium = np.invert(isBtagJetsMedium)
nbtagsm = ak.num(goodJets[isBtagJetsMedium])
# Btag SF following 1a) in https://twiki.cern.ch/twiki/bin/viewauth/CMS/BTagSFMethods
btagSF = np.ones_like(ht)
btagSFUp = np.ones_like(ht)
btagSFDo = np.ones_like(ht)
if not isData:
pt = goodJets.pt
abseta = np.abs(goodJets.eta)
flav = goodJets.hadronFlavour
bJetSF = GetBTagSF(abseta, pt, flav)
bJetSFUp = GetBTagSF(abseta, pt, flav, sys=1)
bJetSFDo = GetBTagSF(abseta, pt, flav, sys=-1)
bJetEff = GetBtagEff(abseta, pt, flav, year)
bJetEff_data = bJetEff * bJetSF
bJetEff_dataUp = bJetEff * bJetSFUp
bJetEff_dataDo = bJetEff * bJetSFDo
pMC = ak.prod(bJetEff[isBtagJetsMedium], axis=-1) * ak.prod(
(1 - bJetEff[isNotBtagJetsMedium]), axis=-1)
pData = ak.prod(bJetEff_data[isBtagJetsMedium], axis=-1) * ak.prod(
(1 - bJetEff_data[isNotBtagJetsMedium]), axis=-1)
pDataUp = ak.prod(
bJetEff_dataUp[isBtagJetsMedium], axis=-1) * ak.prod(
(1 - bJetEff_dataUp[isNotBtagJetsMedium]), axis=-1)
pDataDo = ak.prod(
bJetEff_dataDo[isBtagJetsMedium], axis=-1) * ak.prod(
(1 - bJetEff_dataDo[isNotBtagJetsMedium]), axis=-1)
pMC = ak.where(pMC == 0, 1,
pMC) # removeing zeroes from denominator...
btagSF = pData / pMC
btagSFUp = pDataUp / pMC
btagSFDo = pDataUp / pMC
##################################################################
### 2 same-sign leptons
##################################################################
# emu
singe = e[(nElec == 1) & (nMuon == 1) & (e.pt > -1)]
singm = mu[(nElec == 1) & (nMuon == 1) & (mu.pt > -1)]
em = ak.cartesian({"e": singe, "m": singm})
emSSmask = (em.e.charge * em.m.charge > 0)
emSS = em[emSSmask]
nemSS = len(ak.flatten(emSS))
# ee and mumu
# pt>-1 to preserve jagged dimensions
ee = e[(nElec == 2) & (nMuon == 0) & (e.pt > -1)]
mm = mu[(nElec == 0) & (nMuon == 2) & (mu.pt > -1)]
sumcharge = ak.sum(e.charge, axis=-1) + ak.sum(mu.charge, axis=-1)
eepairs = ak.combinations(ee, 2, fields=["e0", "e1"])
eeSSmask = (eepairs.e0.charge * eepairs.e1.charge > 0)
eeonZmask = (np.abs((eepairs.e0 + eepairs.e1).mass - 91.2) < 10)
eeoffZmask = (eeonZmask == 0)
mmpairs = ak.combinations(mm, 2, fields=["m0", "m1"])
mmSSmask = (mmpairs.m0.charge * mmpairs.m1.charge > 0)
mmonZmask = (np.abs((mmpairs.m0 + mmpairs.m1).mass - 91.2) < 10)
mmoffZmask = (mmonZmask == 0)
eeSSonZ = eepairs[eeSSmask & eeonZmask]
eeSSoffZ = eepairs[eeSSmask & eeoffZmask]
mmSSonZ = mmpairs[mmSSmask & mmonZmask]
mmSSoffZ = mmpairs[mmSSmask & mmoffZmask]
neeSS = len(ak.flatten(eeSSonZ)) + len(ak.flatten(eeSSoffZ))
nmmSS = len(ak.flatten(mmSSonZ)) + len(ak.flatten(mmSSoffZ))
print('Same-sign events [ee, emu, mumu] = [%i, %i, %i]' %
(neeSS, nemSS, nmmSS))
# Cuts
eeSSmask = (ak.num(eeSSmask[eeSSmask]) > 0)
mmSSmask = (ak.num(mmSSmask[mmSSmask]) > 0)
eeonZmask = (ak.num(eeonZmask[eeonZmask]) > 0)
eeoffZmask = (ak.num(eeoffZmask[eeoffZmask]) > 0)
mmonZmask = (ak.num(mmonZmask[mmonZmask]) > 0)
mmoffZmask = (ak.num(mmoffZmask[mmoffZmask]) > 0)
emSSmask = (ak.num(emSSmask[emSSmask]) > 0)
##################################################################
### 3 leptons
##################################################################
# eem
muon_eem = mu[(nElec == 2) & (nMuon == 1) & (mu.pt > -1)]
elec_eem = e[(nElec == 2) & (nMuon == 1) & (e.pt > -1)]
ee_eem = ak.combinations(elec_eem, 2, fields=["e0", "e1"])
ee_eemZmask = (ee_eem.e0.charge * ee_eem.e1.charge < 1) & (np.abs(
(ee_eem.e0 + ee_eem.e1).mass - 91.2) < 10)
ee_eemOffZmask = (ee_eem.e0.charge * ee_eem.e1.charge < 1) & (np.abs(
(ee_eem.e0 + ee_eem.e1).mass - 91.2) > 10)
ee_eemZmask = (ak.num(ee_eemZmask[ee_eemZmask]) > 0)
ee_eemOffZmask = (ak.num(ee_eemOffZmask[ee_eemOffZmask]) > 0)
eepair_eem = (ee_eem.e0 + ee_eem.e1)
trilep_eem = eepair_eem + muon_eem #ak.cartesian({"e0":ee_eem.e0,"e1":ee_eem.e1, "m":muon_eem})
# mme
muon_mme = mu[(nElec == 1) & (nMuon == 2) & (mu.pt > -1)]
elec_mme = e[(nElec == 1) & (nMuon == 2) & (e.pt > -1)]
mm_mme = ak.combinations(muon_mme, 2, fields=["m0", "m1"])
mm_mmeZmask = (mm_mme.m0.charge * mm_mme.m1.charge < 1) & (np.abs(
(mm_mme.m0 + mm_mme.m1).mass - 91.2) < 10)
mm_mmeOffZmask = (mm_mme.m0.charge * mm_mme.m1.charge < 1) & (np.abs(
(mm_mme.m0 + mm_mme.m1).mass - 91.2) > 10)
mm_mmeZmask = (ak.num(mm_mmeZmask[mm_mmeZmask]) > 0)
mm_mmeOffZmask = (ak.num(mm_mmeOffZmask[mm_mmeOffZmask]) > 0)
mmpair_mme = (mm_mme.m0 + mm_mme.m1)
trilep_mme = mmpair_mme + elec_mme
mZ_mme = mmpair_mme.mass
mZ_eem = eepair_eem.mass
m3l_eem = trilep_eem.mass
m3l_mme = trilep_mme.mass
# eee and mmm
eee = e[(nElec == 3) & (nMuon == 0) & (e.pt > -1)]
mmm = mu[(nElec == 0) & (nMuon == 3) & (mu.pt > -1)]
eee_leps = ak.combinations(eee, 3, fields=["e0", "e1", "e2"])
mmm_leps = ak.combinations(mmm, 3, fields=["m0", "m1", "m2"])
ee_pairs = ak.combinations(eee, 2, fields=["e0", "e1"])
mm_pairs = ak.combinations(mmm, 2, fields=["m0", "m1"])
ee_pairs_index = ak.argcombinations(eee, 2, fields=["e0", "e1"])
mm_pairs_index = ak.argcombinations(mmm, 2, fields=["m0", "m1"])
mmSFOS_pairs = mm_pairs[
(np.abs(mm_pairs.m0.pdgId) == np.abs(mm_pairs.m1.pdgId))
& (mm_pairs.m0.charge != mm_pairs.m1.charge)]
offZmask_mm = ak.all(
np.abs((mmSFOS_pairs.m0 + mmSFOS_pairs.m1).mass - 91.2) > 10.,
axis=1,
keepdims=True) & (ak.num(mmSFOS_pairs) > 0)
onZmask_mm = ak.any(
np.abs((mmSFOS_pairs.m0 + mmSFOS_pairs.m1).mass - 91.2) < 10.,
axis=1,
keepdims=True)
eeSFOS_pairs = ee_pairs[
(np.abs(ee_pairs.e0.pdgId) == np.abs(ee_pairs.e1.pdgId))
& (ee_pairs.e0.charge != ee_pairs.e1.charge)]
offZmask_ee = ak.all(
np.abs((eeSFOS_pairs.e0 + eeSFOS_pairs.e1).mass - 91.2) > 10,
axis=1,
keepdims=True) & (ak.num(eeSFOS_pairs) > 0)
onZmask_ee = ak.any(
np.abs((eeSFOS_pairs.e0 + eeSFOS_pairs.e1).mass - 91.2) < 10,
axis=1,
keepdims=True)
# Create masks **for event selection**
eeeOnZmask = (ak.num(onZmask_ee[onZmask_ee]) > 0)
eeeOffZmask = (ak.num(offZmask_ee[offZmask_ee]) > 0)
mmmOnZmask = (ak.num(onZmask_mm[onZmask_mm]) > 0)
mmmOffZmask = (ak.num(offZmask_mm[offZmask_mm]) > 0)
# Now we need to create masks for the leptons in order to select leptons from the Z boson candidate (in onZ categories)
ZeeMask = ak.argmin(np.abs((eeSFOS_pairs.e0 + eeSFOS_pairs.e1).mass -
91.2),
axis=1,
keepdims=True)
ZmmMask = ak.argmin(np.abs((mmSFOS_pairs.m0 + mmSFOS_pairs.m1).mass -
91.2),
axis=1,
keepdims=True)
Zee = eeSFOS_pairs[ZeeMask]
Zmm = mmSFOS_pairs[ZmmMask]
eZ0 = Zee.e0[ak.num(eeSFOS_pairs) > 0]
eZ1 = Zee.e1[ak.num(eeSFOS_pairs) > 0]
eZ = eZ0 + eZ1
mZ0 = Zmm.m0[ak.num(mmSFOS_pairs) > 0]
mZ1 = Zmm.m1[ak.num(mmSFOS_pairs) > 0]
mZ = mZ0 + mZ1
mZ_eee = eZ.mass
mZ_mmm = mZ.mass
# And for the W boson
ZmmIndices = mm_pairs_index[ZmmMask]
ZeeIndices = ee_pairs_index[ZeeMask]
eW = eee[~ZeeIndices.e0 | ~ZeeIndices.e1]
mW = mmm[~ZmmIndices.m0 | ~ZmmIndices.m1]
triElec = eee_leps.e0 + eee_leps.e1 + eee_leps.e2
triMuon = mmm_leps.m0 + mmm_leps.m1 + mmm_leps.m2
m3l_eee = triElec.mass
m3l_mmm = triMuon.mass
##################################################################
### >=4 leptons
##################################################################
# 4lep cat
is4lmask = ((nElec + nMuon) >= 4)
muon_4l = mu[(is4lmask) & (mu.pt > -1)]
elec_4l = e[(is4lmask) & (e.pt > -1)]
# selecting 4 leading leptons
leptons = ak.concatenate([e, mu], axis=-1)
leptons_sorted = leptons[ak.argsort(leptons.pt,
axis=-1,
ascending=False)]
lep4l = leptons_sorted[:, 0:4]
e4l = lep4l[abs(lep4l.pdgId) == 11]
mu4l = lep4l[abs(lep4l.pdgId) == 13]
nElec4l = ak.num(e4l)
nMuon4l = ak.num(mu4l)
# Triggers
trig_eeSS = passTrigger(events, 'ee', isData, dataset)
trig_mmSS = passTrigger(events, 'mm', isData, dataset)
trig_emSS = passTrigger(events, 'em', isData, dataset)
trig_eee = passTrigger(events, 'eee', isData, dataset)
trig_mmm = passTrigger(events, 'mmm', isData, dataset)
trig_eem = passTrigger(events, 'eem', isData, dataset)
trig_mme = passTrigger(events, 'mme', isData, dataset)
trig_4l = triggerFor4l(events, nMuon, nElec, isData, dataset)
# MET filters
# Weights
genw = np.ones_like(events['event']) if (
isData or len(self._wc_names_lst) > 0) else events['genWeight']
### We need weights for: normalization, lepSF, triggerSF, pileup, btagSF...
weights = {}
for r in [
'all', 'ee', 'mm', 'em', 'eee', 'mmm', 'eem', 'mme', 'eeee',
'eeem', 'eemm', 'mmme', 'mmmm'
]:
# weights[r] = coffea.analysis_tools.Weights(len(events))
weights[r] = coffea.analysis_tools.Weights(len(events),
storeIndividual=True)
if len(self._wc_names_lst) > 0:
sow = np.ones_like(
sow
) # Not valid in nanoAOD for EFT samples, MUST use SumOfEFTweights at analysis level
weights[r].add('norm', genw if isData else (xsec / sow) * genw)
weights[r].add('btagSF', btagSF, btagSFUp, btagSFDo)
weights[r].add('lepSF', events.lepSF_nom, events.lepSF_hi,
events.lepSF_lo)
# Extract the EFT quadratic coefficients and optionally use them to calculate the coefficients on the w**2 quartic function
# eft_coeffs is never Jagged so convert immediately to numpy for ease of use.
eft_coeffs = ak.to_numpy(events['EFTfitCoefficients']) if hasattr(
events, "EFTfitCoefficients") else None
if eft_coeffs is not None:
# Check to see if the ordering of WCs for this sample matches what want
if self._samples[dataset]['WCnames'] != self._wc_names_lst:
eft_coeffs = efth.remap_coeffs(
self._samples[dataset]['WCnames'], self._wc_names_lst,
eft_coeffs)
eft_w2_coeffs = efth.calc_w2_coeffs(eft_coeffs, self._dtype) if (
self._do_errors and eft_coeffs is not None) else None
# Selections and cuts
selections = PackedSelection() #(dtype='uint64')
channels2LSS = ['eeSSonZ', 'eeSSoffZ', 'mmSSonZ', 'mmSSoffZ', 'emSS']
selections.add('eeSSonZ', (eeonZmask) & (eeSSmask) & (trig_eeSS))
selections.add('eeSSoffZ', (eeoffZmask) & (eeSSmask) & (trig_eeSS))
selections.add('mmSSonZ', (mmonZmask) & (mmSSmask) & (trig_mmSS))
selections.add('mmSSoffZ', (mmoffZmask) & (mmSSmask) & (trig_mmSS))
selections.add('emSS', (emSSmask) & (trig_emSS))
channels3L = ['eemSSonZ', 'eemSSoffZ', 'mmeSSonZ', 'mmeSSoffZ']
selections.add('eemSSonZ', (ee_eemZmask) & (trig_eem))
selections.add('eemSSoffZ', (ee_eemOffZmask) & (trig_eem))
selections.add('mmeSSonZ', (mm_mmeZmask) & (trig_mme))
selections.add('mmeSSoffZ', (mm_mmeOffZmask) & (trig_mme))
channels3L += ['eeeSSonZ', 'eeeSSoffZ', 'mmmSSonZ', 'mmmSSoffZ']
selections.add('eeeSSonZ', (eeeOnZmask) & (trig_eee))
selections.add('eeeSSoffZ', (eeeOffZmask) & (trig_eee))
selections.add('mmmSSonZ', (mmmOnZmask) & (trig_mmm))
selections.add('mmmSSoffZ', (mmmOffZmask) & (trig_mmm))
channels4L = ['eeee', 'eeem', 'eemm', 'mmme', 'mmmm']
selections.add('eeee', ((nElec4l == 4) & (nMuon4l == 0)) & (trig_4l))
selections.add('eeem', ((nElec4l == 3) & (nMuon4l == 1)) & (trig_4l))
selections.add('eemm', ((nElec4l == 2) & (nMuon4l == 2)) & (trig_4l))
selections.add('mmme', ((nElec4l == 1) & (nMuon4l == 3)) & (trig_4l))
selections.add('mmmm', ((nElec4l == 0) & (nMuon4l == 4)) & (trig_4l))
selections.add('ch+', (sumcharge > 0))
selections.add('ch-', (sumcharge < 0))
selections.add('ch0', (sumcharge == 0))
levels = ['base', '1+bm2+bl', '1bm', '2+bm']
selections.add('base', (nElec + nMuon >= 2))
selections.add('1+bm2+bl', (nElec + nMuon >= 2) & ((nbtagsm >= 1) &
(nbtagsl >= 2)))
selections.add('1bm', (nElec + nMuon >= 2) & (nbtagsm == 1))
selections.add('2+bm', (nElec + nMuon >= 2) & (nbtagsm >= 2))
# Variables
invMass_eeSSonZ = (eeSSonZ.e0 + eeSSonZ.e1).mass
invMass_eeSSoffZ = (eeSSoffZ.e0 + eeSSoffZ.e1).mass
invMass_mmSSonZ = (mmSSonZ.m0 + mmSSonZ.m1).mass
invMass_mmSSoffZ = (mmSSoffZ.m0 + mmSSoffZ.m1).mass
invMass_emSS = (emSS.e + emSS.m).mass
varnames = {}
varnames['met'] = met.pt
varnames['ht'] = ht
varnames['njets'] = njets
varnames['invmass'] = {
'eeSSonZ': invMass_eeSSonZ,
'eeSSoffZ': invMass_eeSSoffZ,
'mmSSonZ': invMass_mmSSonZ,
'mmSSoffZ': invMass_mmSSoffZ,
'emSS': invMass_emSS,
'eemSSonZ': mZ_eem,
'eemSSoffZ': mZ_eem,
'mmeSSonZ': mZ_mme,
'mmeSSoffZ': mZ_mme,
'eeeSSonZ': mZ_eee,
'eeeSSoffZ': mZ_eee,
'mmmSSonZ': mZ_mmm,
'mmmSSoffZ': mZ_mmm,
}
varnames['m3l'] = {
'eemSSonZ': m3l_eem,
'eemSSoffZ': m3l_eem,
'mmeSSonZ': m3l_mme,
'mmeSSoffZ': m3l_mme,
'eeeSSonZ': m3l_eee,
'eeeSSoffZ': m3l_eee,
'mmmSSonZ': m3l_mmm,
'mmmSSoffZ': m3l_mmm,
}
varnames['e0pt'] = e0.pt
varnames['e0eta'] = e0.eta
varnames['m0pt'] = m0.pt
varnames['m0eta'] = m0.eta
varnames['j0pt'] = j0.pt
varnames['j0eta'] = j0.eta
varnames['counts'] = np.ones_like(events['event'])
# systematics
systList = []
if isData == False:
systList = ['nominal']
if self._do_systematics:
systList = systList + [
'lepSFUp', 'lepSFDown', 'btagSFUp', 'btagSFDown'
]
else:
systList = ['noweight']
# fill Histos
hout = self.accumulator.identity()
normweights = weights['all'].weight().flatten(
) # Why does it not complain about .flatten() here?
sowweights = np.ones_like(normweights) if len(
self._wc_names_lst) > 0 else normweights
hout['SumOfEFTweights'].fill(sample=histAxisName,
SumOfEFTweights=varnames['counts'],
weight=sowweights,
eft_coeff=eft_coeffs,
eft_err_coeff=eft_w2_coeffs)
for syst in systList:
for var, v in varnames.items():
for ch in channels2LSS + channels3L + channels4L:
for sumcharge in ['ch+', 'ch-', 'ch0']:
for lev in levels:
#find the event weight to be used when filling the histograms
weightSyst = syst
#in the case of 'nominal', or the jet energy systematics, no weight systematic variation is used (weightSyst=None)
if syst in [
'nominal', 'JERUp', 'JERDown', 'JESUp',
'JESDown'
]:
weightSyst = None # no weight systematic for these variations
if syst == 'noweight':
weight = np.ones(len(events)) # for data
else:
# call weights.weight() with the name of the systematic to be varied
if ch in channels3L: ch_w = ch[:3]
elif ch in channels2LSS: ch_w = ch[:2]
else: ch_w = ch
weight = weights['all'].weight(
weightSyst
) if isData else weights[ch_w].weight(
weightSyst)
cuts = [ch] + [lev] + [sumcharge]
cut = selections.all(*cuts)
weights_flat = weight[cut].flatten(
) # Why does it not complain about .flatten() here?
weights_ones = np.ones_like(weights_flat,
dtype=np.int)
eft_coeffs_cut = eft_coeffs[
cut] if eft_coeffs is not None else None
eft_w2_coeffs_cut = eft_w2_coeffs[
cut] if eft_w2_coeffs is not None else None
# filling histos
if var == 'invmass':
if ((ch in [
'eeeSSoffZ', 'mmmSSoffZ', 'eeeSSonZ',
'mmmSSonZ'
]) or (ch in channels4L)):
continue
else:
values = ak.flatten(v[ch][cut])
hout['invmass'].fill(
eft_coeff=eft_coeffs_cut,
eft_err_coeff=eft_w2_coeffs_cut,
sample=histAxisName,
channel=ch,
cut=lev,
sumcharge=sumcharge,
invmass=values,
weight=weights_flat,
systematic=syst)
elif var == 'm3l':
if ((ch in channels2LSS) or (ch in [
'eeeSSoffZ', 'mmmSSoffZ', 'eeeSSonZ',
'mmmSSonZ'
]) or (ch in channels4L)):
continue
values = ak.flatten(v[ch][cut])
hout['m3l'].fill(
eft_coeff=eft_coeffs_cut,
eft_err_coeff=eft_w2_coeffs_cut,
sample=histAxisName,
channel=ch,
cut=lev,
sumcharge=sumcharge,
m3l=values,
weight=weights_flat,
systematic=syst)
else:
values = v[cut]
# These all look identical, do we need if/else here?
if var == 'ht':
hout[var].fill(
eft_coeff=eft_coeffs_cut,
eft_err_coeff=eft_w2_coeffs_cut,
ht=values,
sample=histAxisName,
channel=ch,
cut=lev,
sumcharge=sumcharge,
weight=weights_flat,
systematic=syst)
elif var == 'met':
hout[var].fill(
eft_coeff=eft_coeffs_cut,
eft_err_coeff=eft_w2_coeffs_cut,
met=values,
sample=histAxisName,
channel=ch,
cut=lev,
sumcharge=sumcharge,
weight=weights_flat,
systematic=syst)
elif var == 'njets':
hout[var].fill(
eft_coeff=eft_coeffs_cut,
eft_err_coeff=eft_w2_coeffs_cut,
njets=values,
sample=histAxisName,
channel=ch,
cut=lev,
sumcharge=sumcharge,
weight=weights_flat,
systematic=syst)
elif var == 'nbtags':
hout[var].fill(
eft_coeff=eft_coeffs_cut,
eft_err_coeff=eft_w2_coeffs_cut,
nbtags=values,
sample=histAxisName,
channel=ch,
cut=lev,
sumcharge=sumcharge,
weight=weights_flat,
systematic=syst)
elif var == 'counts':
hout[var].fill(counts=values,
sample=histAxisName,
channel=ch,
cut=lev,
sumcharge=sumcharge,
weight=weights_ones,
systematic=syst)
elif var == 'j0eta':
if lev == 'base': continue
values = ak.flatten(values)
#values=np.asarray(values)
hout[var].fill(
eft_coeff=eft_coeffs_cut,
eft_err_coeff=eft_w2_coeffs_cut,
j0eta=values,
sample=histAxisName,
channel=ch,
cut=lev,
sumcharge=sumcharge,
weight=weights_flat,
systematic=syst)
elif var == 'e0pt':
if ch in [
'mmSSonZ', 'mmSSoffZ', 'mmmSSoffZ',
'mmmSSonZ', 'mmmm'
]:
continue
values = ak.flatten(values)
#values=np.asarray(values)
hout[var].fill(
eft_coeff=eft_coeffs_cut,
eft_err_coeff=eft_w2_coeffs_cut,
e0pt=values,
sample=histAxisName,
channel=ch,
cut=lev,
sumcharge=sumcharge,
weight=weights_flat,
systematic=syst
) # Crashing here, not sure why. Related to values?
elif var == 'm0pt':
if ch in [
'eeSSonZ', 'eeSSoffZ', 'eeeSSoffZ',
'eeeSSonZ', 'eeee'
]:
continue
values = ak.flatten(values)
#values=np.asarray(values)
hout[var].fill(
eft_coeff=eft_coeffs_cut,
eft_err_coeff=eft_w2_coeffs_cut,
m0pt=values,
sample=histAxisName,
channel=ch,
cut=lev,
sumcharge=sumcharge,
weight=weights_flat,
systematic=syst)
elif var == 'e0eta':
if ch in [
'mmSSonZ', 'mmSSoffZ', 'mmmSSoffZ',
'mmmSSonZ', 'mmmm'
]:
continue
values = ak.flatten(values)
#values=np.asarray(values)
hout[var].fill(
eft_coeff=eft_coeffs_cut,
eft_err_coeff=eft_w2_coeffs_cut,
e0eta=values,
sample=histAxisName,
channel=ch,
cut=lev,
sumcharge=sumcharge,
weight=weights_flat,
systematic=syst)
elif var == 'm0eta':
if ch in [
'eeSSonZ', 'eeSSoffZ', 'eeeSSoffZ',
'eeeSSonZ', 'eeee'
]:
continue
values = ak.flatten(values)
#values=np.asarray(values)
hout[var].fill(
eft_coeff=eft_coeffs_cut,
eft_err_coeff=eft_w2_coeffs_cut,
m0eta=values,
sample=histAxisName,
channel=ch,
cut=lev,
sumcharge=sumcharge,
weight=weights_flat,
systematic=syst)
elif var == 'j0pt':
if lev == 'base': continue
values = ak.flatten(values)
#values=np.asarray(values)
hout[var].fill(
eft_coeff=eft_coeffs_cut,
eft_err_coeff=eft_w2_coeffs_cut,
j0pt=values,
sample=histAxisName,
channel=ch,
cut=lev,
sumcharge=sumcharge,
weight=weights_flat,
systematic=syst)
return hout
def process(self, events):
# Dataset parameters
dataset = events.metadata['dataset']
year = self._samples[dataset]['year']
xsec = self._samples[dataset]['xsec']
sow = self._samples[dataset]['nSumOfWeights' ]
isData = self._samples[dataset]['isData']
datasets = ['SingleMuon', 'SingleElectron', 'EGamma', 'MuonEG', 'DoubleMuon', 'DoubleElectron']
for d in datasets:
if d in dataset: dataset = dataset.split('_')[0]
# Inittialize objects
met = events.GenMET
e = events.GenPart[abs(events.GenPart.pdgId)==11]
mu = events.GenPart[abs(events.GenPart.pdgId)==13]
tau = events.GenPart[abs(events.GenPart.pdgId)==15]
j = events.GenJet
leading_mu = mu[ak.argmax(mu.pt,axis=-1,keepdims=True)]
leading_e = e[ak.argmax(e.pt,axis=-1,keepdims=True)]
nElec = ak.num(e)
nMuon = ak.num(mu)
nTau = ak.num(tau)
twoLeps = (nElec+nMuon) == 2
threeLeps = (nElec+nMuon) == 3
twoElec = (nElec == 2)
twoMuon = (nMuon == 2)
e0 = e[ak.argmax(e.pt,axis=-1,keepdims=True)]
m0 = mu[ak.argmax(mu.pt,axis=-1,keepdims=True)]
elecs = e[ak.argsort(e.pt, ascending=False)]
muons = mu[ak.argsort(mu.pt, ascending=False)]
e1 = elecs
e2 = elecs
m1 = muons
m2 = muons
# Jet selection
jetptname = 'pt_nom' if hasattr(j, 'pt_nom') else 'pt'
njets = ak.num(j)
ht = ak.sum(j.pt,axis=-1)
jets = j[ak.argsort(j.pt, ascending=False)]
j0 = j[ak.argmax(j.pt,axis=-1,keepdims=True)]
j1 = jets
j2 = jets
j3 = jets
nbtags = ak.num(j[abs(j.hadronFlavour)==5])
##################################################################
### 2 same-sign leptons
##################################################################
# emu
singe = e [(nElec==1)&(nMuon==1)&(e .pt>-1)]
singm = mu[(nElec==1)&(nMuon==1)&(mu.pt>-1)]
em = ak.cartesian({"e":singe,"m":singm})
emSSmask = (em.e.pdgId*em.m.pdgId>0)
emSS = em[emSSmask]
nemSS = len(ak.flatten(emSS))
year = 2018
lepSF_emSS = GetLeptonSF(mu.pt, mu.eta, 'm', e.pt, e.eta, 'e', year=year)
# ee and mumu
# pt>-1 to preserve jagged dimensions
ee = e [(nElec==2)&(nMuon==0)&(e.pt>-1)]
mm = mu[(nElec==0)&(nMuon==2)&(mu.pt>-1)]
eepairs = ak.combinations(ee, 2, fields=["e0","e1"])
eeSSmask = (eepairs.e0.pdgId*eepairs.e1.pdgId>0)
eeonZmask = (np.abs((eepairs.e0+eepairs.e1).mass-91.2)<10)
eeoffZmask = (eeonZmask==0)
mmpairs = ak.combinations(mm, 2, fields=["m0","m1"])
mmSSmask = (mmpairs.m0.pdgId*mmpairs.m1.pdgId>0)
mmonZmask = (np.abs((mmpairs.m0+mmpairs.m1).mass-91.2)<10)
mmoffZmask = (mmonZmask==0)
eeSSonZ = eepairs[eeSSmask & eeonZmask]
eeSSoffZ = eepairs[eeSSmask & eeoffZmask]
mmSSonZ = mmpairs[mmSSmask & mmonZmask]
mmSSoffZ = mmpairs[mmSSmask & mmoffZmask]
neeSS = len(ak.flatten(eeSSonZ)) + len(ak.flatten(eeSSoffZ))
nmmSS = len(ak.flatten(mmSSonZ)) + len(ak.flatten(mmSSoffZ))
lepSF_eeSS = GetLeptonSF(eepairs.e0.pt, eepairs.e0.eta, 'e', eepairs.e1.pt, eepairs.e1.eta, 'e', year=year)
lepSF_mumuSS = GetLeptonSF(mmpairs.m0.pt, mmpairs.m0.eta, 'm', mmpairs.m1.pt, mmpairs.m1.eta, 'm', year=year)
print('Same-sign events [ee, emu, mumu] = [%i, %i, %i]'%(neeSS, nemSS, nmmSS))
# Cuts
eeSSmask = (ak.num(eeSSmask[eeSSmask])>0)
mmSSmask = (ak.num(mmSSmask[mmSSmask])>0)
eeonZmask = (ak.num(eeonZmask[eeonZmask])>0)
eeoffZmask = (ak.num(eeoffZmask[eeoffZmask])>0)
mmonZmask = (ak.num(mmonZmask[mmonZmask])>0)
mmoffZmask = (ak.num(mmoffZmask[mmoffZmask])>0)
emSSmask = (ak.num(emSSmask[emSSmask])>0)
##################################################################
### 3 leptons
##################################################################
# eem
muon_eem = mu[(nElec==2)&(nMuon==1)&(mu.pt>-1)]
elec_eem = e[(nElec==2)&(nMuon==1)&( e.pt>-1)]
ee_eem = ak.combinations(elec_eem, 2, fields=["e0", "e1"])
ee_eemZmask = (ee_eem.e0.pdgId*ee_eem.e1.pdgId<1)&(np.abs((ee_eem.e0+ee_eem.e1).mass-91.2)<10)
ee_eemOffZmask = (ee_eem.e0.pdgId*ee_eem.e1.pdgId<1)&(np.abs((ee_eem.e0+ee_eem.e1).mass-91.2)>10)
ee_eemZmask = (ak.num(ee_eemZmask[ee_eemZmask])>0)
ee_eemOffZmask = (ak.num(ee_eemOffZmask[ee_eemOffZmask])>0)
eepair_eem = (ee_eem.e0+ee_eem.e1)
trilep_eem = eepair_eem+muon_eem #ak.cartesian({"e0":ee_eem.e0,"e1":ee_eem.e1, "m":muon_eem})
lepSF_eem = GetLeptonSF(ee_eem.e0.pt, ee_eem.e0.eta, 'e', ee_eem.e1.pt, ee_eem.e1.eta, 'e', mu.pt, mu.eta, 'm', year)
# mme
muon_mme = mu[(nElec==1)&(nMuon==2)&(mu.pt>-1)]
elec_mme = e[(nElec==1)&(nMuon==2)&( e.pt>-1)]
mm_mme = ak.combinations(muon_mme, 2, fields=["m0", "m1"])
mm_mmeZmask = (mm_mme.m0.pdgId*mm_mme.m1.pdgId<1)&(np.abs((mm_mme.m0+mm_mme.m1).mass-91.2)<10)
mm_mmeOffZmask = (mm_mme.m0.pdgId*mm_mme.m1.pdgId<1)&(np.abs((mm_mme.m0+mm_mme.m1).mass-91.2)>10)
mm_mmeZmask = (ak.num(mm_mmeZmask[mm_mmeZmask])>0)
mm_mmeOffZmask = (ak.num(mm_mmeOffZmask[mm_mmeOffZmask])>0)
mmpair_mme = (mm_mme.m0+mm_mme.m1)
trilep_mme = mmpair_mme+elec_mme
mZ_mme = mmpair_mme.mass
mZ_eem = eepair_eem.mass
m3l_eem = trilep_eem.mass
m3l_mme = trilep_mme.mass
lepSF_mme = GetLeptonSF(mm_mme.m0.pt, mm_mme.m0.eta, 'm', mm_mme.m1.pt, mm_mme.m1.eta, 'm', e.pt, e.eta, 'e', year)
# eee and mmm
eee = e[(nElec==3)&(nMuon==0)&( e.pt>-1)]
mmm = mu[(nElec==0)&(nMuon==3)&(mu.pt>-1)]
eee_leps = ak.combinations(eee, 3, fields=["e0", "e1", "e2"])
mmm_leps = ak.combinations(mmm, 3, fields=["m0", "m1", "m2"])
ee_pairs = ak.combinations(eee, 2, fields=["e0", "e1"])
mm_pairs = ak.combinations(mmm, 2, fields=["m0", "m1"])
ee_pairs_index = ak.argcombinations(eee, 2, fields=["e0", "e1"])
mm_pairs_index = ak.argcombinations(mmm, 2, fields=["m0", "m1"])
lepSF_eee = GetLeptonSF(eee_leps.e0.pt, eee_leps.e0.eta, 'e', eee_leps.e1.pt, eee_leps.e1.eta, 'e', eee_leps.e2.pt, eee_leps.e2.eta, 'e', year)
lepSF_mmm = GetLeptonSF(mmm_leps.m0.pt, mmm_leps.m0.eta, 'm', mmm_leps.m1.pt, mmm_leps.m1.eta, 'm', mmm_leps.m2.pt, mmm_leps.m2.eta, 'm', year)
mmSFOS_pairs = mm_pairs[(np.abs(mm_pairs.m0.pdgId) == np.abs(mm_pairs.m1.pdgId)) & (mm_pairs.m0.pdgId != mm_pairs.m1.pdgId)]
offZmask_mm = ak.all(np.abs((mmSFOS_pairs.m0 + mmSFOS_pairs.m1).mass - 91.2)>10., axis=1, keepdims=True) & (ak.num(mmSFOS_pairs)>0)
onZmask_mm = ak.any(np.abs((mmSFOS_pairs.m0 + mmSFOS_pairs.m1).mass - 91.2)<10., axis=1, keepdims=True)
eeSFOS_pairs = ee_pairs[(np.abs(ee_pairs.e0.pdgId) == np.abs(ee_pairs.e1.pdgId)) & (ee_pairs.e0.pdgId != ee_pairs.e1.pdgId)]
offZmask_ee = ak.all(np.abs((eeSFOS_pairs.e0 + eeSFOS_pairs.e1).mass - 91.2)>10, axis=1, keepdims=True) & (ak.num(eeSFOS_pairs)>0)
onZmask_ee = ak.any(np.abs((eeSFOS_pairs.e0 + eeSFOS_pairs.e1).mass - 91.2)<10, axis=1, keepdims=True)
# Create masks **for event selection**
eeeOnZmask = (ak.num(onZmask_ee[onZmask_ee])>0)
eeeOffZmask = (ak.num(offZmask_ee[offZmask_ee])>0)
mmmOnZmask = (ak.num(onZmask_mm[onZmask_mm])>0)
mmmOffZmask = (ak.num(offZmask_mm[offZmask_mm])>0)
# Now we need to create masks for the leptons in order to select leptons from the Z boson candidate (in onZ categories)
ZeeMask = ak.argmin(np.abs((eeSFOS_pairs.e0 + eeSFOS_pairs.e1).mass - 91.2),axis=1,keepdims=True)
ZmmMask = ak.argmin(np.abs((mmSFOS_pairs.m0 + mmSFOS_pairs.m1).mass - 91.2),axis=1,keepdims=True)
Zee = eeSFOS_pairs[ZeeMask]
Zmm = mmSFOS_pairs[ZmmMask]
eZ0= Zee.e0[ak.num(eeSFOS_pairs)>0]
eZ1= Zee.e1[ak.num(eeSFOS_pairs)>0]
eZ = eZ0+eZ1
mZ0= Zmm.m0[ak.num(mmSFOS_pairs)>0]
mZ1= Zmm.m1[ak.num(mmSFOS_pairs)>0]
mZ = mZ0+mZ1
mZ_eee = eZ.mass
mZ_mmm = mZ.mass
# And for the W boson
ZmmIndices = mm_pairs_index[ZmmMask]
ZeeIndices = ee_pairs_index[ZeeMask]
eW = eee[~ZeeIndices.e0 | ~ZeeIndices.e1]
mW = mmm[~ZmmIndices.m0 | ~ZmmIndices.m1]
triElec = eee_leps.e0+eee_leps.e1+eee_leps.e2
triMuon = mmm_leps.m0+mmm_leps.m1+mmm_leps.m2
m3l_eee = triElec.mass
m3l_mmm = triMuon.mass
# Triggers
trig_eeSS = passTrigger(events,'ee',isData,dataset)
trig_mmSS = passTrigger(events,'mm',isData,dataset)
trig_emSS = passTrigger(events,'em',isData,dataset)
trig_eee = passTrigger(events,'eee',isData,dataset)
trig_mmm = passTrigger(events,'mmm',isData,dataset)
trig_eem = passTrigger(events,'eem',isData,dataset)
trig_mme = passTrigger(events,'mme',isData,dataset)
# MET filters
# Weights
genw = np.ones_like(events['MET_pt']) if isData else events['genWeight']
### We need weights for: normalization, lepSF, triggerSF, pileup, btagSF...
weights = {}
for r in ['all', 'ee', 'mm', 'em', 'eee', 'mmm', 'eem', 'mme']:
weights[r] = coffea.analysis_tools.Weights(len(events))
weights[r].add('norm',genw if isData else (xsec/sow)*genw)
weights['ee'].add('lepSF_eeSS', lepSF_eeSS)
weights['em'].add('lepSF_emSS', lepSF_emSS)
weights['mm'].add('lepSF_mmSS', lepSF_mumuSS)
weights['eee'].add('lepSF_eee', lepSF_eee)
weights['mmm'].add('lepSF_mmm', lepSF_mmm)
weights['mme'].add('lepSF_mme', lepSF_mme)
weights['eem'].add('lepSF_eem', lepSF_eem)
# Extract the EFT quadratic coefficients and optionally use them to calculate the coefficients on the w**2 quartic function
# eft_coeffs is never Jagged so convert immediately to numpy for ease of use.
eft_coeffs = ak.to_numpy(events['EFTfitCoefficients']) if hasattr(events, "EFTfitCoefficients") else None
eft_w2_coeffs = efth.calc_w2_coeffs(eft_coeffs,self._dtype) if (self._do_errors and eft_coeffs is not None) else None
# Selections and cuts
selections = PackedSelection()
channels2LSS = ['eeSSonZ', 'eeSSoffZ', 'mmSSonZ', 'mmSSoffZ', 'emSS']
selections.add('eeSSonZ', (eeonZmask)&(eeSSmask)&(trig_eeSS))
selections.add('eeSSoffZ', (eeoffZmask)&(eeSSmask)&(trig_eeSS))
selections.add('mmSSonZ', (mmonZmask)&(mmSSmask)&(trig_mmSS))
selections.add('mmSSoffZ', (mmoffZmask)&(mmSSmask)&(trig_mmSS))
selections.add('emSS', (emSSmask)&(trig_emSS))
channels3L = ['eemSSonZ', 'eemSSoffZ', 'mmeSSonZ', 'mmeSSoffZ']
selections.add('eemSSonZ', (ee_eemZmask)&(trig_eem))
selections.add('eemSSoffZ', (ee_eemOffZmask)&(trig_eem))
selections.add('mmeSSonZ', (mm_mmeZmask)&(trig_mme))
selections.add('mmeSSoffZ', (mm_mmeOffZmask)&(trig_mme))
channels3L += ['eeeSSonZ', 'eeeSSoffZ', 'mmmSSonZ', 'mmmSSoffZ']
selections.add('eeeSSonZ', (eeeOnZmask)&(trig_eee))
selections.add('eeeSSoffZ', (eeeOffZmask)&(trig_eee))
selections.add('mmmSSonZ', (mmmOnZmask)&(trig_mmm))
selections.add('mmmSSoffZ', (mmmOffZmask)&(trig_mmm))
levels = ['base', '2jets', '4jets', '4j1b', '4j2b']
selections.add('base', (nElec+nMuon>=2))
selections.add('2jets',(njets>=2))
selections.add('4jets',(njets>=4))
selections.add('4j1b',(njets>=4)&(nbtags>=1))
selections.add('4j2b',(njets>=4)&(nbtags>=2))
# Variables
invMass_eeSSonZ = ( eeSSonZ.e0+ eeSSonZ.e1).mass
invMass_eeSSoffZ = (eeSSoffZ.e0+eeSSoffZ.e1).mass
invMass_mmSSonZ = ( mmSSonZ.m0+ mmSSonZ.m1).mass
invMass_mmSSoffZ = (mmSSoffZ.m0+mmSSoffZ.m1).mass
invMass_emSS = (emSS.e+emSS.m).mass
varnames = {}
varnames['met'] = met.pt
varnames['ht'] = ht
varnames['njets'] = njets
varnames['nbtags'] = nbtags
varnames['invmass'] = {
'eeSSonZ' : invMass_eeSSonZ,
'eeSSoffZ' : invMass_eeSSoffZ,
'mmSSonZ' : invMass_mmSSonZ,
'mmSSoffZ' : invMass_mmSSoffZ,
'emSS' : invMass_emSS,
'eemSSonZ' : mZ_eem,
'eemSSoffZ' : mZ_eem,
'mmeSSonZ' : mZ_mme,
'mmeSSoffZ' : mZ_mme,
'eeeSSonZ' : mZ_eee,
'eeeSSoffZ' : mZ_eee,
'mmmSSonZ' : mZ_mmm,
'mmmSSoffZ' : mZ_mmm,
}
varnames['m3l'] = {
'eemSSonZ' : m3l_eem,
'eemSSoffZ' : m3l_eem,
'mmeSSonZ' : m3l_mme,
'mmeSSoffZ' : m3l_mme,
'eeeSSonZ' : m3l_eee,
'eeeSSoffZ' : m3l_eee,
'mmmSSonZ' : m3l_mmm,
'mmmSSoffZ' : m3l_mmm,
}
varnames['e0pt' ] = e0.pt
varnames['e0eta'] = e0.eta
varnames['m0pt' ] = m0.pt
varnames['m0eta'] = m0.eta
varnames['e1pt' ] = e1
varnames['e1eta'] = e1
varnames['e2pt' ] = e2
varnames['e2eta'] = e2
varnames['m1pt' ] = m1
varnames['m1eta'] = m1
varnames['m2pt' ] = m2
varnames['m2eta'] = m2
varnames['j0pt' ] = j0.pt
varnames['j0eta'] = j0.eta
varnames['j1pt'] = j1
varnames['j1eta'] = j1
varnames['j2pt'] = j2
varnames['j2eta'] = j2
varnames['j3pt'] = j3
varnames['j3eta'] = j3
varnames['counts'] = np.ones_like(events.GenMET.pt)
# fill Histos
hout = self.accumulator.identity()
normweights = weights['all'].weight().flatten() # Why does it not complain about .flatten() here?
hout['SumOfEFTweights'].fill(sample=dataset, SumOfEFTweights=varnames['counts'], weight=normweights, eft_coeff=eft_coeffs, eft_err_coeff=eft_w2_coeffs)
for var, v in varnames.items():
for ch in channels2LSS+channels3L:
for lev in levels:
weight = weights[ ch[:3] if (ch.startswith('eee') or ch.startswith('mmm') or ch.startswith('eem') or ch.startswith('mme')) else ch[:2]].weight()
cuts = [ch] + [lev]
cut = selections.all(*cuts)
weights_flat = weight[cut].flatten() # Why does it not complain about .flatten() here?
weights_ones = np.ones_like(weights_flat, dtype=np.int)
eft_coeffs_cut = eft_coeffs[cut] if eft_coeffs is not None else None
eft_w2_coeffs_cut = eft_w2_coeffs[cut] if eft_w2_coeffs is not None else None
if var == 'invmass':
if ch in ['eeeSSoffZ', 'mmmSSoffZ']: continue
elif ch in ['eeeSSonZ' , 'mmmSSonZ' ]: continue #values = v[ch]
else : values = ak.flatten(v[ch][cut])
hout['invmass'].fill(eft_coeff=eft_coeffs_cut, eft_err_coeff=eft_w2_coeffs_cut, sample=dataset, channel=ch, cut=lev, invmass=values, weight=weights_flat)
elif var == 'm3l':
if ch in ['eeSSonZ','eeSSoffZ', 'mmSSonZ', 'mmSSoffZ','emSS', 'eeeSSoffZ', 'mmmSSoffZ', 'eeeSSonZ' , 'mmmSSonZ']: continue
values = ak.flatten(v[ch][cut])
hout['m3l'].fill(sample=dataset, channel=ch, cut=lev, m3l=values, weight=weights_flat, eft_coeff=eft_coeffs_cut, eft_err_coeff=eft_w2_coeffs_cut)
else:
values = v[cut]
if var == 'ht' : hout[var].fill(ht=values, sample=dataset, channel=ch, cut=lev, weight=weights_flat, eft_coeff=eft_coeffs_cut, eft_err_coeff=eft_w2_coeffs_cut)
elif var == 'met' : hout[var].fill(met=values, sample=dataset, channel=ch, cut=lev, weight=weights_flat, eft_coeff=eft_coeffs_cut, eft_err_coeff=eft_w2_coeffs_cut)
elif var == 'njets' : hout[var].fill(njets=values, sample=dataset, channel=ch, cut=lev, weight=weights_flat, eft_coeff=eft_coeffs_cut, eft_err_coeff=eft_w2_coeffs_cut)
elif var == 'nbtags': hout[var].fill(nbtags=values, sample=dataset, channel=ch, cut=lev, weight=weights_flat, eft_coeff=eft_coeffs_cut, eft_err_coeff=eft_w2_coeffs_cut)
elif var == 'counts': hout[var].fill(counts=values, sample=dataset, channel=ch, cut=lev, weight=weights_ones)
elif var == 'j0eta' :
if lev == 'base': continue
values = ak.flatten(values)
#values=np.asarray(values)
hout[var].fill(j0eta=values, sample=dataset, channel=ch, cut=lev, weight=weights_flat, eft_coeff=eft_coeffs_cut, eft_err_coeff=eft_w2_coeffs_cut)
elif var == 'e0pt' :
if ch in ['mmSSonZ', 'mmSSoffZ', 'mmmSSoffZ', 'mmmSSonZ']: continue
values = ak.flatten(values)
#values=np.asarray(values)
hout[var].fill(e0pt=values, sample=dataset, channel=ch, cut=lev, weight=weights_flat, eft_coeff=eft_coeffs_cut, eft_err_coeff=eft_w2_coeffs_cut)
elif var == 'm0pt' :
if ch in ['eeSSonZ', 'eeSSoffZ', 'eeeSSoffZ', 'eeeSSonZ']: continue
values = ak.flatten(values)
#values=np.asarray(values)
hout[var].fill(m0pt=values, sample=dataset, channel=ch, cut=lev, weight=weights_flat, eft_coeff=eft_coeffs_cut, eft_err_coeff=eft_w2_coeffs_cut)
elif var == 'e0eta' :
if ch in ['mmSSonZ', 'mmSSoffZ', 'mmmSSoffZ', 'mmmSSonZ']: continue
values = ak.flatten(values)
#values=np.asarray(values)
hout[var].fill(e0eta=values, sample=dataset, channel=ch, cut=lev, weight=weights_flat, eft_coeff=eft_coeffs_cut, eft_err_coeff=eft_w2_coeffs_cut)
elif var == 'm0eta':
if ch in ['eeSSonZ', 'eeSSoffZ', 'eeeSSoffZ', 'eeeSSonZ']: continue
values = ak.flatten(values)
#values=np.asarray(values)
hout[var].fill(m0eta=values, sample=dataset, channel=ch, cut=lev, weight=weights_flat, eft_coeff=eft_coeffs_cut, eft_err_coeff=eft_w2_coeffs_cut)
elif var == 'j0pt' :
if lev == 'base': continue
values = ak.flatten(values)
#values=np.asarray(values)
hout[var].fill(j0pt=values, sample=dataset, channel=ch, cut=lev, weight=weights_flat, eft_coeff=eft_coeffs_cut, eft_err_coeff=eft_w2_coeffs_cut)
elif var == 'j1pt':
if lev == "base": continue
values = values.pt[:,1]
#values = ak.flatten(values)
hout[var].fill(j1pt=values, sample=dataset, channel=ch, cut=lev, weight=weights_flat, eft_coeff=eft_coeffs_cut, eft_err_coeff=eft_w2_coeffs_cut)
elif var =='j1eta':
if lev == 'base': continue
values = values.eta[:,1]
hout[var].fill(j1eta=values, sample=dataset, channel=ch, cut=lev, weight=weights_flat, eft_coeff=eft_coeffs_cut, eft_err_coeff=eft_w2_coeffs_cut)
elif var == 'j2pt':
if lev in ['base', "2jets"]: continue
values = values.pt[:,2]
hout[var].fill(j2pt=values, sample=dataset, channel=ch, cut=lev, weight=weights_flat, eft_coeff=eft_coeffs_cut, eft_err_coeff=eft_w2_coeffs_cut)
elif var == 'j2eta':
if lev in ['base', "2jets"]: continue
values = values.eta[:,2]
hout[var].fill(j2eta=values, sample=dataset, channel=ch, cut=lev, weight=weights_flat, eft_coeff=eft_coeffs_cut, eft_err_coeff=eft_w2_coeffs_cut)
elif var == 'j3pt':
if lev in ['base', "2jets"]: continue
values = values.pt[:,3]
hout[var].fill(j3pt=values, sample=dataset, channel=ch, cut=lev, weight=weights_flat, eft_coeff=eft_coeffs_cut, eft_err_coeff=eft_w2_coeffs_cut)
elif var == 'j3eta':
if lev in ['base', "2jets"]: continue
values = values.eta[:,3]
hout[var].fill(j3eta=values, sample=dataset, channel=ch, cut=lev, weight=weights_flat, eft_coeff=eft_coeffs_cut, eft_err_coeff=eft_w2_coeffs_cut)
elif var == 'e1pt':
if ch in ['mmSSonZ', 'mmSSoffZ', 'mmmSSoffZ', 'mmmSSonZ', 'mmeSSonZ', 'mmeSSoffZ', 'emSS']: continue
values = values.pt[:,1]
hout[var].fill(e1pt=values, sample=dataset, channel=ch, cut=lev, weight=weights_flat, eft_coeff=eft_coeffs_cut, eft_err_coeff=eft_w2_coeffs_cut)
elif var == 'e1eta':
if ch in ['mmSSonZ', 'mmSSoffZ', 'mmmSSoffZ', 'mmmSSonZ', 'mmeSSonZ', 'mmeSSoffZ', 'emSS']: continue
values = values.eta[:,1]
hout[var].fill(e1eta=values, sample=dataset, channel=ch, cut=lev, weight=weights_flat, eft_coeff=eft_coeffs_cut, eft_err_coeff=eft_w2_coeffs_cut)
elif var == 'e2pt':
if ch in ['eeeSSonZ', 'eeeSSoffZ']:
values = values.pt[:,2]
hout[var].fill(e2pt=values, sample=dataset, channel=ch, cut=lev, weight=weights_flat, eft_coeff=eft_coeffs_cut, eft_err_coeff=eft_w2_coeffs_cut)
elif var == 'e2eta':
if ch in ['eeeSSonZ', 'eeeSSoffZ']:
values = values.eta[:,2]
hout[var].fill(e2eta=values, sample=dataset, channel=ch, cut=lev, weight=weights_flat, eft_coeff=eft_coeffs_cut, eft_err_coeff=eft_w2_coeffs_cut)
elif var == 'm1pt':
if ch in ['eeSSonZ', 'eeSSoffZ', 'eeeSSoffZ', 'eeeSSonZ', 'eemSSonZ', 'eemSSoffZ', 'emSS']: continue
values = values.pt[:,1]
hout[var].fill(m1pt=values, sample=dataset, channel=ch, cut=lev, weight=weights_flat, eft_coeff=eft_coeffs_cut, eft_err_coeff=eft_w2_coeffs_cut)
elif var == 'm1eta':
if ch in ['eeSSonZ', 'eeSSoffZ', 'eeeSSoffZ', 'eeeSSonZ', 'eemSSonZ', 'eemSSoffZ', 'emSS']: continue
values = values.eta[:,1]
hout[var].fill(m1eta=values, sample=dataset, channel=ch, cut=lev, weight=weights_flat, eft_coeff=eft_coeffs_cut, eft_err_coeff=eft_w2_coeffs_cut)
elif var == 'm2pt':
if ch in ['mmmSSonZ', 'mmmSSoffZ']:
values = values.pt[:,2]
hout[var].fill(m2pt=values, sample=dataset, channel=ch, cut=lev, weight=weights_flat, eft_coeff=eft_coeffs_cut, eft_err_coeff=eft_w2_coeffs_cut)
elif var == 'm2eta':
if ch in ['mmmSSonZ', 'mmmSSoffZ']:
values = values.eta[:,2]
hout[var].fill(m2eta=values, sample=dataset, channel=ch, cut=lev, weight=weights_flat, eft_coeff=eft_coeffs_cut, eft_err_coeff=eft_w2_coeffs_cut)
return hout
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
def process(self, events):
def normalize(val, cut):
return ak.to_numpy(ak.fill_none(
val[cut],
np.nan)) #val[cut].pad(1, clip=True).fillna(0).flatten()
def fill(region, cuts, systematic=None, wmod=None):
print('filling %s' % region)
selections = cuts
cut = selection.all(*selections)
if 'signal' in region: weight = weights_signal.weight()[cut]
elif 'muonCR' in region: weight = weights_muonCR.weight()[cut]
elif 'VtaggingCR' in region:
weight = weights_VtaggingCR.weight()[cut]
output['templates'].fill(
dataset=dataset,
region=region,
pt=normalize(candidatejet.pt, cut),
msd=normalize(candidatejet.msdcorr, cut),
n2ddt=normalize(candidatejet.n2ddt, cut),
#gruddt=normalize(candidatejet.gruddt, cut),
in_v3_ddt=normalize(candidatejet.in_v3_ddt, cut),
hadW=normalize(candidatejet.nmatcheddau, cut),
weight=weight,
),
output['event'].fill(
dataset=dataset,
region=region,
MET=events.MET.pt[cut],
#nJet=fatjets.counts[cut],
nPFConstituents=normalize(candidatejet.nPFConstituents, cut),
weight=weight,
),
output['deepAK8'].fill(
dataset=dataset,
region=region,
deepTagMDWqq=normalize(candidatejet.deepTagMDWqq, cut),
deepTagMDZqq=normalize(candidatejet.deepTagMDZqq, cut),
msd=normalize(candidatejet.msdcorr, cut),
#genflavor=genflavor[cut],
weight=weight,
),
output['in_v3'].fill(
dataset=dataset,
region=region,
#genflavor=genflavor[cut],
in_v3=normalize(candidatejet.in_v3, cut),
n2=normalize(candidatejet.n2b1, cut),
gru=normalize(candidatejet.gru, cut),
weight=weight,
),
if 'muonCR' in dataset or 'VtaggingCR' in dataset:
output['muon'].fill(
dataset=dataset,
region=region,
mu_pt=normalize(candidatemuon.pt, cut),
mu_eta=normalize(candidatemuon.eta, cut),
mu_pfRelIso04_all=normalize(candidatemuon.pfRelIso04_all,
cut),
weight=weight,
),
#common jet kinematics
gru = events.GRU
IN = events.IN
fatjets = events.FatJet
fatjets['msdcorr'] = corrected_msoftdrop(fatjets)
fatjets['qcdrho'] = 2 * np.log(fatjets.msdcorr / fatjets.pt)
fatjets['gruddt'] = gru.v25 - shift(
fatjets, algo='gruddt', year='2017')
fatjets['gru'] = gru.v25
fatjets['in_v3'] = IN.v3
fatjets['in_v3_ddt'] = IN.v3 - shift(
fatjets, algo='inddt', year='2017')
fatjets['in_v3_ddt_90pctl'] = IN.v3 - shift(
fatjets, algo='inddt90pctl', year='2017')
fatjets['n2ddt'] = fatjets.n2b1 - n2ddt_shift(fatjets, year='2017')
fatjets['nmatcheddau'] = TTsemileptonicmatch(events)
dataset = events.metadata['dataset']
print('process dataset', dataset)
isRealData = not hasattr(events, 'genWeight')
output = self.accumulator.identity()
if (len(events) == 0): return output
selection = PackedSelection('uint64')
weights_signal = Weights(len(events))
weights_muonCR = Weights(len(events))
weights_VtaggingCR = Weights(len(events))
if not isRealData:
output['sumw'][dataset] += ak.sum(events.genWeight)
#######################
if 'signal' in self._region:
if isRealData:
trigger_fatjet = np.zeros(len(events), dtype='bool')
for t in self._triggers[self._year]:
try:
trigger_fatjet = trigger_fatjet | events.HLT[t]
except:
print('trigger %s not available' % t)
continue
else:
trigger_fatjet = np.ones(len(events), dtype='bool')
fatjets["genMatchFull"] = VQQgenmatch(events)
candidatejet = ak.firsts(fatjets)
candidatejet["genMatchFull"] = VQQgenmatch(events)
nelectrons = ak.sum(
(events.Electron.pt > 10.)
& (abs(events.Electron.eta) < 2.5)
& (events.Electron.cutBased >= events.Electron.VETO),
axis=1,
)
nmuons = ak.sum(
(events.Muon.pt > 10)
& (abs(events.Muon.eta) < 2.1)
& (events.Muon.pfRelIso04_all < 0.4)
& (events.Muon.looseId),
axis=1,
)
ntaus = ak.sum(
(events.Tau.pt > 20.)
& (events.Tau.idDecayMode)
& (events.Tau.rawIso < 5)
& (abs(events.Tau.eta) < 2.3),
axis=1,
)
cuts = {
"S_fatjet_trigger":
trigger_fatjet,
"S_pt":
candidatejet.pt > 525,
"S_eta": (abs(candidatejet.eta) < 2.5),
"S_msdcorr": (candidatejet.msdcorr > 40),
"S_rho":
((candidatejet.qcdrho > -5.5) & (candidatejet.qcdrho < -2.)),
"S_jetid": (candidatejet.isTight),
"S_VQQgenmatch": (candidatejet.genMatchFull),
"S_noelectron": (nelectrons == 0),
"S_nomuon": (nmuons == 0),
"S_notau": (ntaus == 0),
}
for name, cut in cuts.items():
print(name, cut)
selection.add(name, cut)
if isRealData:
genflavor = 0 #candidatejet.pt.zeros_like().pad(1, clip=True).fillna(-1).flatten()
if not isRealData:
weights_signal.add('genweight', events.genWeight)
#add_pileup_weight(weights_signal, events.Pileup.nPU, self._year, dataset)
add_jetTriggerWeight(weights_signal, candidatejet.msdcorr,
candidatejet.pt, self._year)
bosons = getBosons(events.GenPart)
genBosonPt = ak.fill_none(ak.firsts(bosons.pt), 0)
add_VJets_NLOkFactor(weights_signal, genBosonPt, self._year,
dataset)
#genflavor = matchedBosonFlavor(candidatejet, bosons).pad(1, clip=True).fillna(-1).flatten()
allcuts_signal = set()
output['cutflow_signal'][dataset]['none'] += float(
weights_signal.weight().sum())
for cut in cuts:
allcuts_signal.add(cut)
output['cutflow_signal'][dataset][cut] += float(
weights_signal.weight()[selection.all(
*allcuts_signal)].sum())
fill('signal', cuts.keys())
#######################
if 'muonCR' in self._region:
if isRealData:
trigger_muon = np.zeros(len(events), dtype='bool')
for t in self._muontriggers[self._year]:
trigger_muon = trigger_muon | events.HLT[t]
else:
trigger_muon = np.ones(len(events), dtype='bool')
candidatejet = ak.firsts(fatjets)
candidatemuon = events.Muon[:, :5]
jets = events.Jet[((events.Jet.pt > 50.)
& (abs(events.Jet.eta) < 2.5)
& (events.Jet.isTight))][:, :4]
dphi = abs(jets.delta_phi(candidatejet))
ak4_away = jets[(dphi > 0.8)]
nelectrons = ak.sum(
(events.Electron.pt > 10.)
& (abs(events.Electron.eta) < 2.5)
& (events.Electron.cutBased >= events.Electron.VETO),
axis=1,
)
nmuons = ak.sum(
(events.Muon.pt > 10)
& (abs(events.Muon.eta) < 2.4)
& (events.Muon.pfRelIso04_all < 0.25)
& (events.Muon.looseId),
axis=1,
)
ntaus = ak.sum(
(events.Tau.pt > 20.)
& (events.Tau.idDecayMode)
& (events.Tau.rawIso < 5)
& (abs(events.Tau.eta) < 2.3)
& (events.Tau.idMVAoldDM2017v1 >= 16),
axis=1,
)
cuts = {
"CR1_muon_trigger":
trigger_muon,
"CR1_jet_pt": (candidatejet.pt > 525),
"CR1_jet_eta": (abs(candidatejet.eta) < 2.5),
"CR1_jet_msd": (candidatejet.msdcorr > 40),
"CR1_jet_rho":
((candidatejet.qcdrho > -5.5) & (candidatejet.qcdrho < -2.)),
"CR1_mu_pt":
ak.any(candidatemuon.pt > 55, axis=1),
"CR1_mu_eta":
ak.any(abs(candidatemuon.eta) < 2.1, axis=1),
"CR1_mu_IDLoose":
ak.any(candidatemuon.looseId, axis=1),
"CR1_mu_isolationTight":
ak.any(candidatemuon.pfRelIso04_all < 0.15, axis=1),
"CR1_muonDphiAK8":
ak.any(
abs(candidatemuon.delta_phi(candidatejet)) > 2 * np.pi / 3,
axis=1),
"CR1_ak4btagMedium08":
(ak.max(ak4_away.btagCSVV2, axis=1, mask_identity=False) >
BTagEfficiency.btagWPs[self._year]['medium']
), #(ak4_away.btagCSVV2.max() > 0.8838),
"CR1_noelectron": (nelectrons == 0),
"CR1_onemuon": (nmuons == 1),
"CR1_notau": (ntaus == 0),
}
for name, cut in cuts.items():
selection.add(name, cut)
if isRealData:
genflavor = 0 #candidatejet.pt.zeros_like().pad(1, clip=True).fillna(-1).flatten()
if not isRealData:
weights_muonCR.add('genweight', events.genWeight)
#add_pileup_weight(weights_muonCR, events.Pileup.nPU, self._year, dataset)
#add_singleMuTriggerWeight(weights, candidatejet.msdcorr, candidatejet.pt, self._year)
bosons = getBosons(events.GenPart)
genBosonPt = ak.fill_none(ak.firsts(bosons.pt), 0)
#add_VJets_NLOkFactor(weights, genBosonPt, self._year, dataset)
#genflavor = matchedBosonFlavor(candidatejet, bosons).pad(1, clip=True).fillna(-1).flatten()
allcuts_ttbar_muoncontrol = set()
output['cutflow_muonCR'][dataset]['none'] += float(
weights_muonCR.weight().sum())
for cut in cuts:
allcuts_ttbar_muoncontrol.add(cut)
output['cutflow_muonCR'][dataset][cut] += float(
weights_muonCR.weight()[selection.all(
*allcuts_ttbar_muoncontrol)].sum())
fill('muonCR', cuts.keys())
#######################
if 'VtaggingCR' in self._region:
if isRealData:
trigger_muon = np.zeros(len(events), dtype='bool')
for t in self._muontriggers[self._year]:
trigger_muon = trigger_muon | events.HLT[t]
else:
trigger_muon = np.ones(len(events), dtype='bool')
candidatejet = ak.firsts(fatjets)
candidatemuon = ak.firsts(events.Muon)
jets = events.Jet[((events.Jet.pt > 30.)
& (abs(events.Jet.eta) < 2.4))][:, :4]
dr_ak4_ak8 = jets.delta_r(candidatejet)
dr_ak4_muon = jets.delta_r(candidatemuon)
ak4_away = jets[(dr_ak4_ak8 > 0.8)] # & (dr_ak4_muon > 0.4)]
mu_p4 = ak.zip(
{
"pt": ak.fill_none(candidatemuon.pt, 0),
"eta": ak.fill_none(candidatemuon.eta, 0),
"phi": ak.fill_none(candidatemuon.phi, 0),
"mass": ak.fill_none(candidatemuon.mass, 0),
},
with_name="PtEtaPhiMLorentzVector")
met_p4 = ak.zip(
{
"pt": ak.from_iter([[v] for v in events.MET.pt]),
"eta": ak.from_iter([[v] for v in np.zeros(len(events))]),
"phi": ak.from_iter([[v] for v in events.MET.phi]),
"mass": ak.from_iter([[v] for v in np.zeros(len(events))]),
},
with_name="PtEtaPhiMLorentzVector")
Wleptoniccandidate = mu_p4 + met_p4
nelectrons = ak.sum(
((events.Electron.pt > 10.)
& (abs(events.Electron.eta) < 2.5)
& (events.Electron.cutBased >= events.Electron.VETO)),
axis=1,
)
n_tight_muon = ak.sum(
((events.Muon.pt > 53)
& (abs(events.Muon.eta) < 2.1)
& (events.Muon.tightId)),
axis=1,
)
n_loose_muon = ak.sum(
((events.Muon.pt > 20)
& (events.Muon.looseId)
& (abs(events.Muon.eta) < 2.4)),
axis=1,
)
ntaus = ak.sum(
((events.Tau.pt > 20.)
& (events.Tau.idDecayMode)
& (events.Tau.rawIso < 5)
& (abs(events.Tau.eta) < 2.3)
& (events.Tau.idMVAoldDM2017v1 >= 16)),
axis=1,
)
cuts = {
"CR2_muon_trigger":
trigger_muon,
"CR2_jet_pt": (candidatejet.pt > 200),
"CR2_jet_eta": (abs(candidatejet.eta) < 2.5),
"CR2_jet_msd": (candidatejet.msdcorr > 40),
"CR2_mu_pt":
candidatemuon.pt > 53,
"CR2_mu_eta": (abs(candidatemuon.eta) < 2.1),
"CR2_mu_IDTight":
candidatemuon.tightId,
"CR2_mu_isolationTight": (candidatemuon.pfRelIso04_all < 0.15),
"CR2_muonDphiAK8":
abs(candidatemuon.delta_phi(candidatejet)) > 2 * np.pi / 3,
"CR2_ak4btagMedium08":
(ak.max(ak4_away.btagCSVV2, axis=1, mask_identity=False) >
BTagEfficiency.btagWPs[self._year]['medium']),
"CR2_leptonicW":
ak.flatten(Wleptoniccandidate.pt > 200),
"CR2_MET": (events.MET.pt > 40.),
"CR2_noelectron": (nelectrons == 0),
"CR2_one_tightMuon": (n_tight_muon == 1),
"CR2_one_looseMuon": (n_loose_muon == 1),
#"CR2_notau" : (ntaus==0),
}
for name, cut in cuts.items():
print(name, cut)
selection.add(name, cut)
#weights.add('metfilter', events.Flag.METFilters)
if isRealData:
genflavor = 0 #candidatejet.pt.zeros_like().pad(1, clip=True).fillna(-1).flatten()
if not isRealData:
weights_VtaggingCR.add('genweight', events.genWeight)
#add_pileup_weight(weights_VtaggingCR, events.Pileup.nPU, self._year, dataset)
#add_singleMuTriggerWeight(weights, abs(candidatemuon.eta), candidatemuon.pt, self._year)
bosons = getBosons(events.GenPart)
genBosonPt = ak.fill_none(ak.firsts(bosons.pt), 0)
#add_VJets_NLOkFactor(weights, genBosonPt, self._year, dataset)
#genflavor = matchedBosonFlavor(candidatejet, bosons).pad(1, clip=True).fillna(-1).flatten()
#b-tag weights
allcuts_vselection = set()
output['cutflow_VtaggingCR'][dataset]['none'] += float(
weights_VtaggingCR.weight().sum())
for cut in cuts:
allcuts_vselection.add(cut)
output['cutflow_VtaggingCR'][dataset][cut] += float(
weights_VtaggingCR.weight()[selection.all(
*allcuts_vselection)].sum())
fill('VtaggingCR', cuts.keys())
return output
