def test():
data = ak.Array([[1, 3, 5, 4, 2], [], [2, 3, 1], [5]])
assert ak.min(data, axis=1, initial=4).tolist() == [1, None, 1, 4]
assert ak.max(data, axis=1, initial=4).tolist() == [5, None, 4, 5]
data = ak.Array([[1.1, 3.3, 5.5, 4.4, 2.2], [], [2.2, 3.3, 1.1], [5.5]])
assert ak.min(data, axis=1, initial=4).tolist() == [1.1, None, 1.1, 4]
assert ak.max(data, axis=1, initial=4).tolist() == [5.5, None, 4, 5.5]
def test_date_time():
numpy_array = np.array(
["2020-07-27T10:41:11", "2019-01-01", "2020-01-01"], "datetime64[s]"
)
array = ak.Array(numpy_array)
assert str(array.type) == "3 * datetime64"
assert array.tolist() == [
np.datetime64("2020-07-27T10:41:11"),
np.datetime64("2019-01-01T00:00:00"),
np.datetime64("2020-01-01T00:00:00"),
]
for i in range(len(array)):
assert ak.to_numpy(array)[i] == numpy_array[i]
date_time = np.datetime64("2020-07-27T10:41:11.200000011", "us")
array1 = ak.Array(np.array(["2020-07-27T10:41:11.200000011"], "datetime64[us]"))
assert np.datetime64(array1[0], "us") == date_time
assert ak.to_list(ak.from_iter(array1)) == [
np.datetime64("2020-07-27T10:41:11.200000")
]
assert ak.max(array) == numpy_array[0]
assert ak.min(array) == numpy_array[1]
def test_ByteMaskedArray():
content = ak.Array([1.1, 2.2, 3.3, 999, 999, 4.4, 5.5]).layout
mask = ak.layout.Index8(
np.array([False, False, False, True, True, False, False]))
bytemaskedarray = ak.layout.ByteMaskedArray(mask,
content,
valid_when=False)
array = ak.Array(bytemaskedarray)
assert array.tolist() == [1.1, 2.2, 3.3, None, None, 4.4, 5.5]
assert ak.max(array, axis=0) == 5.5
assert ak.argmax(array, axis=0) == 6
offsets = ak.layout.Index64(np.array([0, 2, 4, 7], dtype=np.int64))
listoffsetarray = ak.layout.ListOffsetArray64(offsets, bytemaskedarray)
array = ak.Array(listoffsetarray)
assert array.tolist() == [[1.1, 2.2], [3.3, None], [None, 4.4, 5.5]]
assert ak.max(array, axis=1).tolist() == [2.2, 3.3, 5.5]
assert ak.argmax(array, axis=1).tolist() == [1, 0, 2]
def test_minmax():
assert ak.min(ak.from_iter([[1 + 5j, 2 + 4j], [], [3 + 3j]])) == 1 + 5j
assert ak.max(ak.from_iter([[1 + 5j, 2 + 4j], [], [3 + 3j]])) == 3 + 3j
assert ak.min(ak.from_iter([[1 + 5j, 2 + 4j], [], [3 + 3j]]),
axis=1).tolist() == [
1 + 5j,
None,
3 + 3j,
]
assert ak.max(ak.from_iter([[1 + 5j, 2 + 4j], [], [3 + 3j]]),
axis=1).tolist() == [
2 + 4j,
None,
3 + 3j,
]
assert ak.argmin(ak.from_iter([[1 + 5j, 2 + 4j], [], [3 + 3j]]),
axis=1).tolist() == [0, None, 0]
assert ak.argmax(ak.from_iter([[1 + 5j, 2 + 4j], [], [3 + 3j]]),
axis=1).tolist() == [1, None, 0]
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):
output = self.accumulator.identity()
output['total']['all'] += len(events)
# use a very loose preselection to filter the events
presel = ak.num(events.Jet) > 2
ev = events[presel]
dataset = ev.metadata['dataset']
# load the config - probably not needed anymore
cfg = loadConfig()
## Muons
muon = Collections(ev, "Muon", "vetoTTH").get()
tightmuon = Collections(ev, "Muon", "tightTTH").get()
dimuon = choose(muon, 2)
SSmuon = ak.any((dimuon['0'].charge * dimuon['1'].charge) > 0, axis=1)
leading_muon_idx = ak.singletons(ak.argmax(muon.pt, axis=1))
leading_muon = muon[leading_muon_idx]
## Electrons
electron = Collections(ev, "Electron", "vetoTTH").get()
tightelectron = Collections(ev, "Electron", "tightTTH").get()
dielectron = choose(electron, 2)
SSelectron = ak.any(
(dielectron['0'].charge * dielectron['1'].charge) > 0, axis=1)
leading_electron_idx = ak.singletons(ak.argmax(electron.pt, axis=1))
leading_electron = electron[leading_electron_idx]
## Merge electrons and muons - this should work better now in ak1
dilepton = cross(muon, electron)
SSlepton = ak.any((dilepton['0'].charge * dilepton['1'].charge) > 0,
axis=1)
lepton = ak.concatenate([muon, electron], axis=1)
leading_lepton_idx = ak.singletons(ak.argmax(lepton.pt, axis=1))
leading_lepton = lepton[leading_lepton_idx]
trailing_lepton_idx = ak.singletons(ak.argmin(lepton.pt, axis=1))
trailing_lepton = lepton[trailing_lepton_idx]
dilepton_mass = (leading_lepton + trailing_lepton).mass
dilepton_pt = (leading_lepton + trailing_lepton).pt
dilepton_dR = delta_r(leading_lepton, trailing_lepton)
mt_lep_met = mt(lepton.pt, lepton.phi, ev.MET.pt, ev.MET.phi)
min_mt_lep_met = ak.min(mt_lep_met, axis=1)
## Jets
jet = getJets(ev, minPt=25, maxEta=4.7, pt_var='pt_nom')
jet = jet[ak.argsort(
jet.pt_nom, ascending=False
)] # need to sort wrt smeared and recorrected jet pt
jet = jet[~match(jet, muon,
deltaRCut=0.4)] # remove jets that overlap with muons
jet = jet[~match(
jet, electron,
deltaRCut=0.4)] # remove jets that overlap with electrons
central = jet[(abs(jet.eta) < 2.4)]
btag = getBTagsDeepFlavB(
jet, year=self.year) # should study working point for DeepJet
light = getBTagsDeepFlavB(jet, year=self.year, invert=True)
fwd = getFwdJet(light)
fwd_noPU = getFwdJet(light, puId=False)
tau = getTaus(ev)
track = getIsoTracks(ev)
## forward jets
j_fwd = fwd[ak.singletons(ak.argmax(
fwd.p, axis=1))] # highest momentum spectator
high_score_btag = central[ak.argsort(central.btagDeepFlavB)][:, :2]
bl = cross(lepton, high_score_btag)
bl_dR = delta_r(bl['0'], bl['1'])
min_bl_dR = ak.min(bl_dR, axis=1)
jf = cross(j_fwd, jet)
mjf = (jf['0'] + jf['1']).mass
j_fwd2 = jf[ak.singletons(
ak.argmax(mjf, axis=1)
)]['1'] # this is the jet that forms the largest invariant mass with j_fwd
delta_eta = ak.fill_none(
ak.pad_none(abs(j_fwd2.eta - j_fwd.eta), 1, clip=True), 0)
## MET -> can switch to puppi MET
met_pt = ev.MET.pt
met_phi = ev.MET.phi
## other variables
ht = ak.sum(jet.pt, axis=1)
st = met_pt + ht + ak.sum(muon.pt, axis=1) + ak.sum(electron.pt,
axis=1)
## event selectors
filters = getFilters(ev, year=self.year, dataset=dataset)
dilep = ((ak.num(tightelectron) + ak.num(tightmuon)) == 2)
lep0pt = ((ak.num(electron[(electron.pt > 25)]) +
ak.num(muon[(muon.pt > 25)])) > 0)
lep1pt = ((ak.num(electron[(electron.pt > 20)]) +
ak.num(muon[(muon.pt > 20)])) > 1)
lepveto = ((ak.num(electron) + ak.num(muon)) == 2)
selection = PackedSelection()
selection.add('lepveto', lepveto)
selection.add('dilep', dilep)
selection.add('filter', (filters))
selection.add('p_T(lep0)>25', lep0pt)
selection.add('p_T(lep1)>20', lep1pt)
selection.add('SS', (SSlepton | SSelectron | SSmuon))
selection.add('N_jet>3', (ak.num(jet) >= 4))
selection.add('N_central>2', (ak.num(central) >= 3))
selection.add('N_btag>0', (ak.num(btag) >= 1))
selection.add('N_fwd>0', (ak.num(fwd) >= 1))
#ss_reqs = ['lepveto', 'dilep', 'filter', 'p_T(lep0)>25', 'p_T(lep1)>20', 'SS']
ss_reqs = [
'lepveto', 'dilep', 'filter', 'p_T(lep0)>25', 'p_T(lep1)>20', 'SS'
]
#bl_reqs = ss_reqs + ['N_jet>3', 'N_central>2', 'N_btag>0', 'N_fwd>0']
bl_reqs = ss_reqs + ['N_jet>3', 'N_central>2', 'N_btag>0']
ss_reqs_d = {sel: True for sel in ss_reqs}
ss_selection = selection.require(**ss_reqs_d)
bl_reqs_d = {sel: True for sel in bl_reqs}
BL = selection.require(**bl_reqs_d)
weight = Weights(len(ev))
if not dataset == 'MuonEG':
# lumi weight
weight.add("weight", ev.weight)
# PU weight - not in the babies...
weight.add("PU",
ev.puWeight,
weightUp=ev.puWeightUp,
weightDown=ev.puWeightDown,
shift=False)
# b-tag SFs
weight.add("btag", self.btagSF.Method1a(btag, light))
# lepton SFs
weight.add("lepton", self.leptonSF.get(electron, muon))
#cutflow = Cutflow(output, ev, weight=weight)
#cutflow_reqs_d = {}
#for req in bl_reqs:
# cutflow_reqs_d.update({req: True})
# cutflow.addRow( req, selection.require(**cutflow_reqs_d) )
labels = {
'topW_v3': 0,
'TTW': 1,
'TTZ': 2,
'TTH': 3,
'ttbar': 4,
'ttbar1l_MG': 4
}
if dataset in labels:
label_mult = labels[dataset]
else:
label_mult = 5
label = np.ones(len(ev[BL])) * label_mult
output["n_lep"] += processor.column_accumulator(
ak.to_numpy((ak.num(electron) + ak.num(muon))[BL]))
output["n_lep_tight"] += processor.column_accumulator(
ak.to_numpy((ak.num(tightelectron) + ak.num(tightmuon))[BL]))
output["lead_lep_pt"] += processor.column_accumulator(
ak.to_numpy(ak.flatten(leading_lepton[BL].pt, axis=1)))
output["lead_lep_eta"] += processor.column_accumulator(
ak.to_numpy(ak.flatten(leading_lepton[BL].eta, axis=1)))
output["lead_lep_phi"] += processor.column_accumulator(
ak.to_numpy(ak.flatten(leading_lepton[BL].phi, axis=1)))
output["lead_lep_charge"] += processor.column_accumulator(
ak.to_numpy(ak.flatten(leading_lepton[BL].charge, axis=1)))
output["sublead_lep_pt"] += processor.column_accumulator(
ak.to_numpy(ak.flatten(trailing_lepton[BL].pt, axis=1)))
output["sublead_lep_eta"] += processor.column_accumulator(
ak.to_numpy(ak.flatten(trailing_lepton[BL].eta, axis=1)))
output["sublead_lep_phi"] += processor.column_accumulator(
ak.to_numpy(ak.flatten(trailing_lepton[BL].phi, axis=1)))
output["sublead_lep_charge"] += processor.column_accumulator(
ak.to_numpy(ak.flatten(trailing_lepton[BL].charge, axis=1)))
output["lead_jet_pt"] += processor.column_accumulator(
ak.to_numpy(ak.flatten(jet[:, 0:1][BL].pt, axis=1)))
output["lead_jet_eta"] += processor.column_accumulator(
ak.to_numpy(ak.flatten(jet[:, 0:1][BL].eta, axis=1)))
output["lead_jet_phi"] += processor.column_accumulator(
ak.to_numpy(ak.flatten(jet[:, 0:1][BL].phi, axis=1)))
output["sublead_jet_pt"] += processor.column_accumulator(
ak.to_numpy(ak.flatten(jet[:, 1:2][BL].pt, axis=1)))
output["sublead_jet_eta"] += processor.column_accumulator(
ak.to_numpy(ak.flatten(jet[:, 1:2][BL].eta, axis=1)))
output["sublead_jet_phi"] += processor.column_accumulator(
ak.to_numpy(ak.flatten(jet[:, 1:2][BL].phi, axis=1)))
output["lead_btag_pt"] += processor.column_accumulator(
ak.to_numpy(ak.flatten(high_score_btag[:, 0:1][BL].pt, axis=1)))
output["lead_btag_eta"] += processor.column_accumulator(
ak.to_numpy(ak.flatten(high_score_btag[:, 0:1][BL].eta, axis=1)))
output["lead_btag_phi"] += processor.column_accumulator(
ak.to_numpy(ak.flatten(high_score_btag[:, 0:1][BL].phi, axis=1)))
output["sublead_btag_pt"] += processor.column_accumulator(
ak.to_numpy(ak.flatten(high_score_btag[:, 1:2][BL].pt, axis=1)))
output["sublead_btag_eta"] += processor.column_accumulator(
ak.to_numpy(ak.flatten(high_score_btag[:, 1:2][BL].eta, axis=1)))
output["sublead_btag_phi"] += processor.column_accumulator(
ak.to_numpy(ak.flatten(high_score_btag[:, 1:2][BL].phi, axis=1)))
output["fwd_jet_p"] += processor.column_accumulator(
ak.to_numpy(
ak.flatten(ak.fill_none(ak.pad_none(j_fwd[BL].p, 1, clip=True),
0),
axis=1)))
output["fwd_jet_pt"] += processor.column_accumulator(
ak.to_numpy(
ak.flatten(ak.fill_none(
ak.pad_none(j_fwd[BL].pt, 1, clip=True), 0),
axis=1)))
output["fwd_jet_eta"] += processor.column_accumulator(
ak.to_numpy(
ak.flatten(ak.fill_none(
ak.pad_none(j_fwd[BL].eta, 1, clip=True), 0),
axis=1)))
output["fwd_jet_phi"] += processor.column_accumulator(
ak.to_numpy(
ak.flatten(ak.fill_none(
ak.pad_none(j_fwd[BL].phi, 1, clip=True), 0),
axis=1)))
output["mjj_max"] += processor.column_accumulator(
ak.to_numpy(ak.fill_none(ak.max(mjf[BL], axis=1), 0)))
output["delta_eta_jj"] += processor.column_accumulator(
ak.to_numpy(ak.flatten(delta_eta[BL], axis=1)))
output["met"] += processor.column_accumulator(ak.to_numpy(met_pt[BL]))
output["ht"] += processor.column_accumulator(ak.to_numpy(ht[BL]))
output["st"] += processor.column_accumulator(ak.to_numpy(st[BL]))
output["n_jet"] += processor.column_accumulator(
ak.to_numpy(ak.num(jet[BL])))
output["n_btag"] += processor.column_accumulator(
ak.to_numpy(ak.num(btag[BL])))
output["n_fwd"] += processor.column_accumulator(
ak.to_numpy(ak.num(fwd[BL])))
output["n_central"] += processor.column_accumulator(
ak.to_numpy(ak.num(central[BL])))
output["n_tau"] += processor.column_accumulator(
ak.to_numpy(ak.num(tau[BL])))
output["n_track"] += processor.column_accumulator(
ak.to_numpy(ak.num(track[BL])))
output["dilepton_pt"] += processor.column_accumulator(
ak.to_numpy(ak.flatten(dilepton_pt[BL], axis=1)))
output["dilepton_mass"] += processor.column_accumulator(
ak.to_numpy(ak.flatten(dilepton_mass[BL], axis=1)))
output["min_bl_dR"] += processor.column_accumulator(
ak.to_numpy(min_bl_dR[BL]))
output["min_mt_lep_met"] += processor.column_accumulator(
ak.to_numpy(min_mt_lep_met[BL]))
output["label"] += processor.column_accumulator(label)
output["weight"] += processor.column_accumulator(weight.weight()[BL])
output["presel"]["all"] += len(ev[ss_selection])
output["sel"]["all"] += len(ev[BL])
return output
def __init__(self, ev, obj, wp, year=2018, verbose=0):
self.obj = obj
self.wp = wp
if self.wp == None:
self.selection_dict = {}
else:
self.selection_dict = obj_def[self.obj][self.wp]
self.v = verbose
self.year = year
id_level = None
if wp.lower().count('veto') or wp.lower().count('loose'):
id_level = 0
elif wp.lower().count('fake'):
id_level = 1
elif wp.lower().count('tight'):
id_level = 2
if self.obj == "Muon":
# collections are already there, so we just need to calculate missing ones
ev['Muon', 'absMiniIso'] = ev.Muon.miniPFRelIso_all * ev.Muon.pt
ev['Muon', 'ptErrRel'] = ev.Muon.ptErr / ev.Muon.pt
# this is what we are using:
# - jetRelIso if the matched jet is within deltaR<0.4, pfRelIso03_all otherwise
# - btagDeepFlavB discriminator of the matched jet if jet is within deltaR<0.4, 0 otherwise
# - pt_cone = 0.9*pt of matched jet if jet is within deltaR<0.4, pt/(pt+iso) otherwise
mask_close = (ak.fill_none(ev.Muon.delta_r(ev.Muon.matched_jet),
99) < 0.4) * 1
mask_far = ~(ak.fill_none(ev.Muon.delta_r(ev.Muon.matched_jet), 99)
< 0.4) * 1
deepJet = ak.fill_none(ev.Muon.matched_jet.btagDeepFlavB,
0) * mask_close + 0 * mask_far
jetRelIsoV2 = ev.Muon.jetRelIso * mask_close + ev.Muon.pfRelIso03_all * mask_far # default to 0 if no match
#conePt = 0.9 * ak.fill_none(ev.Muon.matched_jet.pt,0) * mask_close + ev.Muon.pt*(1 + ev.Muon.miniPFRelIso_all)*mask_far
if self.year == 2017 or self.year == 2018:
I_1 = 0.11
I_2 = 0.74
I_3 = 6.8
elif self.year == 2016:
I_1 = 0.16
I_2 = 0.76
I_3 = 7.2
PF_unflatten = ak.from_regular(
ev.Muon.miniPFRelIso_all[:, :, np.newaxis])
max_miniIso = ak.max(
ak.concatenate(
[PF_unflatten - I_1,
ak.zeros_like(PF_unflatten)], axis=2),
axis=2) #equivalent to max(0, ev.Muon.miniPFRelIso_all - I_1)
muon_pt_unflatten = ak.from_regular(ev.Muon.pt[:, :, np.newaxis])
jet_pt_unflatten = ak.from_regular(
ev.Muon.matched_jet.pt[:, :, np.newaxis])
max_pt = ak.max(
ak.concatenate([muon_pt_unflatten, jet_pt_unflatten * I_2],
axis=2),
axis=2) #max(ev.Muon.pt, ev.Muon.matched_jet.pt * I_2)
conePt = (ev.Muon.pt *
(1 + max_miniIso)) * (ev.Muon.jetPtRelv2 > I_3) + (
max_pt * ~(ev.Muon.jetPtRelv2 > I_3))
ev['Muon', 'deepJet'] = ak.copy(deepJet)
ev['Muon', 'jetRelIsoV2'] = jetRelIsoV2
ev['Muon', 'conePt'] = conePt
ev['Muon', 'id'] = ak.ones_like(conePt) * id_level
self.cand = ev.Muon
elif self.obj == "Electron":
# calculate new variables. asignment is awkward, but what can you do.
ev['Electron',
'absMiniIso'] = ev.Electron.miniPFRelIso_all * ev.Electron.pt
ev['Electron', 'etaSC'] = ev.Electron.eta + ev.Electron.deltaEtaSC
if self.year == 2017 or self.year == 2018:
I_1 = 0.07
I_2 = 0.78
I_3 = 8.0
elif self.year == 2016:
I_1 = 0.12
I_2 = 0.80
I_3 = 7.2
# the following line is only needed if we do our own matching.
# right now, we keep using the NanoAOD match, but check the deltaR distance
# jet_index, mask_match, mask_nomatch = self.matchJets(ev.Electron, ev.Jet)
# this is what we are using:
# - jetRelIso if the matched jet is within deltaR<0.4, pfRelIso03_all otherwise
# - btagDeepFlavB discriminator of the matched jet if jet is within deltaR<0.4, 0 otherwise
# - pt_cone = 0.9*pt of matched jet if jet is within deltaR<0.4, pt/(pt+iso) otherwise
mask_close = (ak.fill_none(
ev.Electron.delta_r(ev.Electron.matched_jet), 99) < 0.4) * 1
mask_far = ~(ak.fill_none(
ev.Electron.delta_r(ev.Electron.matched_jet), 99) < 0.4) * 1
deepJet = ak.fill_none(ev.Electron.matched_jet.btagDeepFlavB,
0) * mask_close
jetRelIsoV2 = ev.Electron.jetRelIso * mask_close + ev.Electron.pfRelIso03_all * mask_far # default to 0 if no match
#conePt = 0.9 * ak.fill_none(ev.Electron.matched_jet.pt,0) * mask_close + ev.Electron.pt*(1 + ev.Electron.miniPFRelIso_all)*mask_far
PF_unflatten = ak.from_regular(
ev.Electron.miniPFRelIso_all[:, :, np.newaxis])
max_miniIso = ak.max(
ak.concatenate(
[PF_unflatten - I_1,
ak.zeros_like(PF_unflatten)], axis=2),
axis=2) #equivalent to max(0, ev.Muon.miniPFRelIso_all - I_1)
electron_pt_unflatten = ak.from_regular(ev.Electron.pt[:, :,
np.newaxis])
jet_pt_unflatten = ak.from_regular(
ev.Electron.matched_jet.pt[:, :, np.newaxis])
max_pt = ak.max(
ak.concatenate([electron_pt_unflatten, jet_pt_unflatten * I_2],
axis=2),
axis=2) #max(ev.Muon.pt, ev.Muon.matched_jet.pt * I_2)
conePt = (ev.Electron.pt *
(1 + max_miniIso)) * (ev.Electron.jetPtRelv2 > I_3) + (
max_pt * ~(ev.Electron.jetPtRelv2 > I_3))
ev['Electron', 'deepJet'] = ak.copy(deepJet)
ev['Electron', 'jetRelIsoV2'] = jetRelIsoV2
ev['Electron', 'conePt'] = conePt
ev['Electron', 'id'] = ak.ones_like(conePt) * id_level
ev['Electron', 'jetRelIso'] = ev.Electron.jetRelIso
ev['Electron', 'jetPtRelv2'] = ev.Electron.jetPtRelv2
self.cand = ev.Electron
self.getSelection()
if self.obj == "Electron" and self.wp == "tight":
self.selection = self.selection & self.getElectronMVAID(
) & self.getIsolation(0.07, 0.78, 8.0) & self.isTriggerSafeNoIso()
if self.v > 0: print(" - custom ID and multi-isolation")
if self.obj == "Electron" and self.wp == "tightFCNC":
self.selection = self.selection & self.getElectronMVAID(
) & self.getFCNCIsolation(ev.Electron.jetRelIso,
ev.Electron.jetPtRelv2, I_2,
I_3) & (ev.Electron.miniPFRelIso_all <
I_1) & self.isTriggerSafeNoIso()
if self.v > 0: print(" - custom ID and multi-isolation")
if self.obj == "Muon" and self.wp == "tight":
self.selection = self.selection & self.getIsolation(
0.11, 0.74, 6.8)
if self.v > 0: print(" - custom multi-isolation")
#self.selection = self.selection & ak.fill_none(ev.Muon.matched_jet.btagDeepFlavB<0.2770, True)
#self.selection = self.selection & (ev.Muon.matched_jet.btagDeepFlavB<0.2770)
#if self.v>0: print (" - deepJet")
if self.obj == "Muon" and self.wp == "tightFCNC":
self.selection = self.selection & self.getFCNCIsolation(
ev.Muon.jetRelIso, ev.Muon.jetPtRelv2, I_2,
I_3) & (ev.Muon.miniPFRelIso_all < I_1)
if self.v > 0: print(" - custom multi-isolation")
if self.obj == "Electron" and (self.wp == "tightTTH"
or self.wp == 'fakeableTTH'
or self.wp == "tightSSTTH"
or self.wp == 'fakeableSSTTH'):
self.selection = self.selection & self.getSigmaIEtaIEta
if self.v > 0: print(" - SigmaIEtaIEta")
#self.selection = self.selection & ak.fill_none(ev.Electron.matched_jet.btagDeepFlavB<0.2770, True)
#self.selection = self.selection & (ev.Electron.matched_jet.btagDeepFlavB<0.2770)
#self.selection = self.selection & (ev.Jet[ev.Electron.jetIdx].btagDeepFlavB<0.2770)
#if self.v>0: print (" - deepJet")
if self.obj == "Electron" and self.wp == "looseFCNC":
self.selection = self.selection & (ev.Electron.miniPFRelIso_all <
0.4)
if self.obj == 'Muon' and (self.wp == 'fakeableTTH'
or self.wp == 'fakeableSSTTH'):
#self.selection = self.selection & (self.cand.deepJet < self.getThreshold(self.cand.conePt, min_pt=20, max_pt=45, low=0.2770, high=0.0494))
self.selection = self.selection & (ak.fill_none(
ev.Muon.matched_jet.btagDeepFlavB, 0) < self.getThreshold(
self.cand.conePt, min_pt=20, max_pt=45))
if self.v > 0: print(" - interpolated deepJet")
if self.obj == "Muon" and self.wp == "looseFCNC":
self.selection = self.selection & (ev.Muon.miniPFRelIso_all < 0.4)
def test_min_max():
array = ak.Array(
[
[
np.datetime64("2020-03-27T10:41:11"),
np.datetime64("2020-01-27T10:41:11"),
np.datetime64("2020-05"),
np.datetime64("2020-01-27T10:41:11"),
np.datetime64("2020-04-27T10:41:11"),
],
[
np.datetime64("2020-04-27"),
np.datetime64("2020-02-27T10:41:11"),
np.datetime64("2020-01-27T10:41:11"),
np.datetime64("2020-06-27T10:41:11"),
],
[
np.datetime64("2020-02-27T10:41:11"),
np.datetime64("2020-03-27T10:41:11"),
np.datetime64("2020-01-27T10:41:11"),
],
]
)
assert ak.to_list(array) == [
[
np.datetime64("2020-03-27T10:41:11"),
np.datetime64("2020-01-27T10:41:11"),
np.datetime64("2020-05"),
np.datetime64("2020-01-27T10:41:11"),
np.datetime64("2020-04-27T10:41:11"),
],
[
np.datetime64("2020-04-27"),
np.datetime64("2020-02-27T10:41:11"),
np.datetime64("2020-01-27T10:41:11"),
np.datetime64("2020-06-27T10:41:11"),
],
[
np.datetime64("2020-02-27T10:41:11"),
np.datetime64("2020-03-27T10:41:11"),
np.datetime64("2020-01-27T10:41:11"),
],
]
assert ak.min(array) == np.datetime64("2020-01-27T10:41:11")
assert ak.max(array) == np.datetime64("2020-06-27T10:41:11")
assert ak.to_list(ak.min(array, axis=0)) == [
np.datetime64("2020-02-27T10:41:11"),
np.datetime64("2020-01-27T10:41:11"),
np.datetime64("2020-01-27T10:41:11"),
np.datetime64("2020-01-27T10:41:11"),
np.datetime64("2020-04-27T10:41:11"),
]
assert ak.to_list(ak.max(array, axis=0)) == [
np.datetime64("2020-04-27T00:00:00"),
np.datetime64("2020-03-27T10:41:11"),
np.datetime64("2020-05-01T20:56:24"),
np.datetime64("2020-06-27T10:41:11"),
np.datetime64("2020-04-27T10:41:11"),
]
assert ak.to_list(ak.min(array, axis=1)) == [
np.datetime64("2020-01-27T10:41:11"),
np.datetime64("2020-01-27T10:41:11"),
np.datetime64("2020-01-27T10:41:11"),
]
assert ak.to_list(ak.max(array, axis=1)) == [
np.datetime64("2020-05-01T20:56:24"),
np.datetime64("2020-06-27T10:41:11"),
np.datetime64("2020-03-27T10:41:11"),
]
def uproot_tree_to_numpy(fname,
MeanNormTuple,
inbranches_listlist,
nMaxslist,
nevents,
treename="ttree",
stop=None,
branches=None):
# array = uproot_root2array(fname, treename, stop=stop, branches=branches)
# Read in total number of events
totallengthperjet = 0
for i in range(len(nMaxslist)):
if nMaxslist[i] >= 0:
totallengthperjet += len(inbranches_listlist[i]) * nMaxslist[i]
else:
totallengthperjet += len(inbranches_listlist[i]) #flat branch
# branches = [ak.fill_none(ak.pad_none(tree[barr, target=feature_length), 0.) for feature_length, arr in zip( nMaxslist, inbranches_listlist)]
tree = u3.open(fname)[treename]
branches = [
ak.fill_none(
ak.pad_none(tree[branch_name].array(),
target=feature_length,
axis=-1,
clip=True if feature_length > 1 else False), 0.)
for feature_length, branch_list in zip(nMaxslist, inbranches_listlist)
for branch_name in branch_list
]
branchnames = [n for names in inbranches_listlist for n in names]
feature_lenghts = [
f for branches, f in zip(inbranches_listlist, nMaxslist)
for _ in branches
]
means = [
m[0] for branches, m in zip(inbranches_listlist, MeanNormTuple)
for _ in branches
]
norms = [
m[1] for branches, m in zip(inbranches_listlist, MeanNormTuple)
for _ in branches
]
print("Debugigng means and norms")
print(means)
print(norms)
print(branchnames)
branches_numpy = []
for br, brname, fl, mean, norm in zip(branches, branchnames,
feature_lenghts, means, norms):
print("DBG {}".format(brname))
print(br)
print("Length: {}".format(len(br)))
if brname == "TagVarCSV_trackJetDistVal":
print("BONUS DEBUG!")
print("Min: {}, Max: {}".format(ak.min(ak.count(br, axis=-1)),
ak.max(ak.count(br, axis=-1))))
if fl > 1:
# branches_numpy.append( (ak.to_numpy( br ) - mean) / norm)
branches_numpy.append((ak.to_numpy(br) - 0.) / 1.)
elif fl == 1:
# branches_numpy.append( (np.expand_dims( ak.to_numpy( br ), axis=-1) - mean)/norm )
branches_numpy.append(
(np.expand_dims(ak.to_numpy(br), axis=-1) - 0.) / 1.)
print("FINISHED THIS LOOP, YOU ARE PERFECT! :) ")
numpyarray = np.concatenate(branches_numpy, axis=-1)
print("\n" * 5)
print("Some metrics about this numpy array")
print(np.mean(numpyarray, axis=0))
print(np.std(numpyarray, axis=0))
print("Normalize array")
numpyarray = (numpyarray - np.mean(numpyarray, axis=0)) / np.std(
numpyarray, axis=0)
print("Some metrics about this numpy array")
print(np.mean(numpyarray, axis=0))
print(np.std(numpyarray, axis=0))
return numpyarray
def process(self, events):
events = events[
ak.num(events.Jet) >
0] #corrects for rare case where there isn't a single jet in event
output = self.accumulator.identity()
# we can use a very loose preselection to filter the events. nothing is done with this presel, though
presel = ak.num(events.Jet) >= 0
ev = events[presel]
dataset = ev.metadata['dataset']
output['totalEvents']['all'] += len(events)
output['skimmedEvents']['all'] += len(ev)
##Jets
Jets = events.Jet
## MET -> can switch to puppi MET
met_pt = ev.MET.pt
met_phi = ev.MET.phi
### For FCNC, we want electron -> tightTTH
ele_t = Collections(ev, "Electron", "tightFCNC", year=self.year).get()
ele_t_p = ele_t[((ele_t.genPartFlav == 1) | (ele_t.genPartFlav == 15))]
ele_t_np = ele_t[((ele_t.genPartFlav != 1) &
(ele_t.genPartFlav != 15))]
ele_l = Collections(ev, "Electron", "fakeableFCNC",
year=self.year).get()
ele_l_p = ele_l[((ele_l.genPartFlav == 1) | (ele_l.genPartFlav == 15))]
ele_l_np = ele_l[((ele_l.genPartFlav != 1) &
(ele_l.genPartFlav != 15))]
mu_t = Collections(ev, "Muon", "tightFCNC", year=self.year).get()
mu_t_p = mu_t[((mu_t.genPartFlav == 1) | (mu_t.genPartFlav == 15))]
mu_t_np = mu_t[((mu_t.genPartFlav != 1) & (mu_t.genPartFlav != 15))]
mu_l = Collections(ev, "Muon", "fakeableFCNC", year=self.year).get()
mu_l_p = mu_l[((mu_l.genPartFlav == 1) | (mu_l.genPartFlav == 15))]
mu_l_np = mu_l[((mu_l.genPartFlav != 1) & (mu_l.genPartFlav != 15))]
#clean jets :
# we want at least two jets that are outside of the lepton jets by deltaR > 0.4
jets = getJets(ev, maxEta=2.4, minPt=40, pt_var='pt')
jet_sel = (ak.num(jets[~(match(jets, ele_l, deltaRCut=0.4)
| match(jets, mu_l, deltaRCut=0.4))]) >= 2)
"""Now We are making the different selections for the different regions. As a reminder, our SR is one tight gen-level prompt and one tight gen-level nonprompt, and our CR is
one tight gen-level prompt and one loose NOT tight gen-level nonprompt"""
mumu_SR = ak.concatenate([mu_t_p, mu_t_np], axis=1)
mumu_SR_SS = (ak.sum(mumu_SR.charge, axis=1) != 0)
mumu_SR_sel = (ak.num(mu_t_p) == 1) & (ak.num(mu_t_np) == 1) & (
ak.num(mu_l) == 2) & jet_sel & mumu_SR_SS & (ak.num(
mumu_SR[mumu_SR.pt > 20]) > 1) & (ak.num(ele_l) == 0)
mumu_CR = ak.concatenate([mu_t_p, mu_l_np], axis=1)
mumu_CR_SS = (ak.sum(mumu_CR.charge, axis=1) != 0)
mumu_CR_sel = (ak.num(mu_t_p) == 1) & (ak.num(mu_l_np) == 1) & (
ak.num(mu_l) == 2) & jet_sel & mumu_CR_SS & (ak.num(
mumu_CR[mumu_CR.pt > 20]) > 1) & (ak.num(ele_l) == 0)
ee_SR = ak.concatenate([ele_t_p, ele_t_np], axis=1)
ee_SR_SS = (ak.sum(ee_SR.charge, axis=1) != 0)
ee_SR_sel = (ak.num(ele_t_p) == 1) & (ak.num(ele_t_np) == 1) & (
ak.num(ele_l) == 2) & jet_sel & ee_SR_SS & (ak.num(
ee_SR[ee_SR.pt > 20]) > 1) & (ak.num(mu_l) == 0)
ee_CR = ak.concatenate([ele_t_p, ele_l_np], axis=1)
ee_CR_SS = (ak.sum(ee_CR.charge, axis=1) != 0)
ee_CR_sel = (ak.num(ele_t_p) == 1) & (ak.num(ele_l_np) == 1) & (
ak.num(ele_l) == 2) & jet_sel & ee_CR_SS & (ak.num(
ee_CR[ee_CR.pt > 20]) > 1) & (ak.num(mu_l) == 0)
mue_SR = ak.concatenate([mu_t_p, ele_t_np], axis=1)
mue_SR_SS = (ak.sum(mue_SR.charge, axis=1) != 0)
mue_SR_sel = (ak.num(mu_t_p) == 1) & (ak.num(ele_t_np) == 1) & (
ak.num(ele_l) == 1) & jet_sel & mue_SR_SS & (ak.num(
mue_SR[mue_SR.pt > 20]) > 1) & (ak.num(mu_l) == 1)
mue_CR = ak.concatenate([mu_t_p, ele_l_np], axis=1)
mue_CR_SS = (ak.sum(mue_CR.charge, axis=1) != 0)
mue_CR_sel = (ak.num(mu_t_p) == 1) & (ak.num(ele_l_np) == 1) & (
ak.num(ele_l) == 1) & jet_sel & mue_CR_SS & (ak.num(
mue_CR[mue_CR.pt > 20]) > 1) & (ak.num(mu_l) == 1)
emu_SR = ak.concatenate([ele_t_p, mu_t_np], axis=1)
emu_SR_SS = (ak.sum(emu_SR.charge, axis=1) != 0)
emu_SR_sel = (ak.num(ele_t_p) == 1) & (ak.num(mu_t_np) == 1) & (
ak.num(mu_l) == 1) & jet_sel & emu_SR_SS & (ak.num(
emu_SR[emu_SR.pt > 20]) > 1) & (ak.num(ele_l) == 1)
emu_CR = ak.concatenate([ele_t_p, mu_l_np], axis=1)
emu_CR_SS = (ak.sum(emu_CR.charge, axis=1) != 0)
emu_CR_sel = (ak.num(ele_t_p) == 1) & (ak.num(mu_l_np) == 1) & (
ak.num(mu_l) == 1) & jet_sel & emu_CR_SS & (ak.num(
emu_CR[emu_CR.pt > 20]) > 1) & (ak.num(ele_l) == 1)
dilep_selections = {
"mumu_SR": mumu_SR_sel,
"mumu_CR": mumu_CR_sel,
"ee_SR": ee_SR_sel,
"ee_CR": ee_CR_sel,
"mue_SR": mue_SR_sel,
"mue_CR": mue_CR_sel,
"emu_SR": emu_SR_sel,
"emu_CR": emu_CR_sel
}
#combine all selections for generic CR and SR
CR_sel = mumu_CR_sel | ee_CR_sel | mue_CR_sel | emu_CR_sel
SR_sel = mumu_SR_sel | ee_SR_sel | mue_SR_sel | emu_SR_sel
electron_2018 = fake_rate("../data/fake_rate/FR_electron_2018.p")
electron_2017 = fake_rate("../data/fake_rate/FR_electron_2017.p")
electron_2016 = fake_rate("../data/fake_rate/FR_electron_2016.p")
muon_2018 = fake_rate("../data/fake_rate/FR_muon_2018.p")
muon_2017 = fake_rate("../data/fake_rate/FR_muon_2017.p")
muon_2016 = fake_rate("../data/fake_rate/FR_muon_2016.p")
if self.year == 2018:
weight_muon = muon_2018.FR_weight(mu_l_np)
weight_electron = electron_2018.FR_weight(ele_l_np)
elif self.year == 2017:
weight_muon = muon_2017.FR_weight(mu_l_np)
weight_electron = electron_2017.FR_weight(ele_l_np)
elif self.year == 2016:
weight_muon = muon_2016.FR_weight(mu_l_np)
weight_electron = electron_2016.FR_weight(ele_l_np)
#separate by different combinations of two-lepton events
output['EE_CR'].fill(dataset=dataset,
weight=np.sum(ee_CR_sel[ee_CR_sel]))
output['EE_CR_weighted'].fill(
dataset=dataset,
weight=np.sum(ak.to_numpy(weight_electron[ee_CR_sel])))
output['EE_SR'].fill(dataset=dataset,
weight=np.sum(ee_SR_sel[ee_SR_sel]))
output['MM_CR'].fill(dataset=dataset,
weight=np.sum(mumu_CR_sel[mumu_CR_sel]))
output['MM_CR_weighted'].fill(
dataset=dataset,
weight=np.sum(ak.to_numpy(weight_muon[mumu_CR_sel])))
output['MM_SR'].fill(dataset=dataset,
weight=np.sum(mumu_SR_sel[mumu_SR_sel]))
output['EM_CR'].fill(dataset=dataset,
weight=np.sum(emu_CR_sel[emu_CR_sel]))
output['EM_CR_weighted'].fill(
dataset=dataset,
weight=np.sum(ak.to_numpy(weight_muon[emu_CR_sel])))
output['EM_SR'].fill(dataset=dataset,
weight=np.sum(emu_SR_sel[emu_SR_sel]))
output['ME_CR'].fill(dataset=dataset,
weight=np.sum(mue_CR_sel[mue_CR_sel]))
output['ME_CR_weighted'].fill(
dataset=dataset,
weight=np.sum(ak.to_numpy(weight_electron[mue_CR_sel])))
output['ME_SR'].fill(dataset=dataset,
weight=np.sum(mue_SR_sel[mue_SR_sel]))
#fill combined histograms now (basic definitions are in default_accumulators.py)
self.SS_fill_weighted(output["MET_CR"],
mumu_CR_sel,
ee_CR_sel,
mue_CR_sel,
emu_CR_sel,
dataset=dataset,
pt=ev.MET.pt)
self.SS_fill_weighted(output["MET_CR_weighted"],
mumu_CR_sel,
ee_CR_sel,
mue_CR_sel,
emu_CR_sel,
mu_weights=weight_muon,
e_weights=weight_electron,
dataset=dataset,
pt=ev.MET.pt)
self.SS_fill_weighted(output["MET_SR"],
mumu_SR_sel,
ee_SR_sel,
mue_SR_sel,
emu_SR_sel,
dataset=dataset,
pt=ev.MET.pt)
self.fill_pt_individual(output, dataset, ev.MET.pt, "MET",
dilep_selections, weight_muon, weight_electron)
#leading lepton pt
LeadLep_pt = ak.max(ak.concatenate([ev.Muon.pt, ev.Electron.pt],
axis=1),
axis=1)
#sum of all regions
self.SS_fill_weighted(output["pt_LeadLep_CR"],
mumu_CR_sel,
ee_CR_sel,
mue_CR_sel,
emu_CR_sel,
dataset=dataset,
pt=LeadLep_pt)
self.SS_fill_weighted(output["pt_LeadLep_CR_weighted"],
mumu_CR_sel,
ee_CR_sel,
mue_CR_sel,
emu_CR_sel,
mu_weights=weight_muon,
e_weights=weight_electron,
dataset=dataset,
pt=LeadLep_pt)
self.SS_fill_weighted(output["pt_LeadLep_SR"],
mumu_SR_sel,
ee_SR_sel,
mue_SR_sel,
emu_SR_sel,
dataset=dataset,
pt=LeadLep_pt)
self.fill_pt_individual(output, dataset, LeadLep_pt, "pt_LeadLep",
dilep_selections, weight_muon, weight_electron)
#njets
njets = ak.num(jets, axis=1)
self.SS_fill_weighted(output["njets_CR"],
mumu_CR_sel,
ee_CR_sel,
mue_CR_sel,
emu_CR_sel,
dataset=dataset,
multiplicity=njets)
self.SS_fill_weighted(output["njets_CR_weighted"],
mumu_CR_sel,
ee_CR_sel,
mue_CR_sel,
emu_CR_sel,
mu_weights=weight_muon,
e_weights=weight_electron,
dataset=dataset,
multiplicity=njets)
self.SS_fill_weighted(output["njets_SR"],
mumu_SR_sel,
ee_SR_sel,
mue_SR_sel,
emu_SR_sel,
dataset=dataset,
multiplicity=njets)
self.fill_multiplicity_individual(output, dataset, njets, "njets",
dilep_selections, weight_muon,
weight_electron)
#btags
btag = ak.num(getBTagsDeepFlavB(jets, year=self.year))
self.SS_fill_weighted(output["N_b_CR"],
mumu_CR_sel,
ee_CR_sel,
mue_CR_sel,
emu_CR_sel,
dataset=dataset,
multiplicity=btag)
self.SS_fill_weighted(output["N_b_CR_weighted"],
mumu_CR_sel,
ee_CR_sel,
mue_CR_sel,
emu_CR_sel,
mu_weights=weight_muon,
e_weights=weight_electron,
dataset=dataset,
multiplicity=btag)
self.SS_fill_weighted(output["N_b_SR"],
mumu_SR_sel,
ee_SR_sel,
mue_SR_sel,
emu_SR_sel,
dataset=dataset,
multiplicity=btag)
self.fill_multiplicity_individual(output, dataset, btag, "N_b",
dilep_selections, weight_muon,
weight_electron)
#HT
ht = ak.sum(jets.pt, axis=1)
self.SS_fill_weighted(output["HT_CR"],
mumu_CR_sel,
ee_CR_sel,
mue_CR_sel,
emu_CR_sel,
dataset=dataset,
ht=ht)
self.SS_fill_weighted(output["HT_CR_weighted"],
mumu_CR_sel,
ee_CR_sel,
mue_CR_sel,
emu_CR_sel,
mu_weights=weight_muon,
e_weights=weight_electron,
dataset=dataset,
ht=ht)
self.SS_fill_weighted(output["HT_SR"],
mumu_SR_sel,
ee_SR_sel,
mue_SR_sel,
emu_SR_sel,
dataset=dataset,
ht=ht)
self.fill_ht_individual(output, dataset, ht, "HT", dilep_selections,
weight_muon, weight_electron)
return output
def test_scalar_amax(scalar_type_ak_array):
amax = ak.max(scalar_type_ak_array, initial=-9000)
np_array = ak.to_numpy(scalar_type_ak_array)
amax == np.amax(np_array, initial=-9000)
def make_radius_compatibility_distributions():
global tree
all_obj_arrays = tree.arrays(filter_name="pT3*",
entry_start=0,
entry_stop=5,
library="ak")
matchedMask = all_obj_arrays.pT3_isFake == 0
layers = np.array(
list(map(process_layers, ak.flatten(all_obj_arrays.pT3_layer_binary))))
# layerTypes = np.array(list(map(process_layerType, layers)))
layerTypes = np.array(list(map(process_numbers, layers)))
unique_layerTypes = np.unique(layerTypes, axis=0)
unique_layerTypes = np.append(unique_layerTypes, "")
print(unique_layerTypes)
for layerType in unique_layerTypes:
print("layerType = {}".format(layerType))
pixelRadius = ak.to_numpy(ak.flatten(all_obj_arrays.pT3_pixelRadius))
pixelRadiusResMin = ak.to_numpy(
ak.flatten(all_obj_arrays.pT3_pixelRadiusMin))
pixelRadiusResMax = ak.to_numpy(
ak.flatten(all_obj_arrays.pT3_pixelRadiusMax))
tripletRadius = ak.to_numpy(
ak.flatten(all_obj_arrays.pT3_tripletRadius))
tripletRadiusResMin = ak.to_numpy(
ak.flatten(all_obj_arrays.pT3_tripletRadiusMin))
tripletRadiusResMax = ak.to_numpy(
ak.flatten(all_obj_arrays.pT3_tripletRadiusMax))
simRadius = ak.flatten(all_obj_arrays.pT3_matched_pt /
(2.99792458e-3 * 3.8))
simRadius = ak.flatten(simRadius)
pixelRadiusMin = ak.to_numpy(
ak.min([pixelRadiusResMin, pixelRadius2SMin], axis=0))
pixelRadiusMax = ak.to_numpy(
ak.max([pixelRadiusResMax, pixelRadius2SMax], axis=0))
tripletRadiusMin = ak.to_numpy(
ak.min([tripletRadiusResMin, tripletRadius2SMin], axis=0))
tripletRadiusMax = ak.to_numpy(
ak.max([tripletRadiusResMax, tripletRadius2SMax], axis=0))
qArrayInnerOuter = compute_interval_overlap(1.0 / pixelRadiusMax,
1.0 / pixelRadiusMin,
1.0 / tripletRadiusMax,
1.0 / tripletRadiusMin)
for name, qArray in {"innerOuter": qArrayInnerOuter}.items():
print("qName = ", name)
if layerType == "":
qArraySimTrackMatched = qArray[ak.to_numpy(
ak.flatten(matchedMask))]
else:
qArray = qArray[layerTypes == layerType]
qArraySimTrackMatched = qArray[ak.to_numpy(
ak.flatten(matchedMask)[layerTypes == layerType])]
print(
"{} total integral = {}, {} integral below zero = {}, sim-matched {} total integral = {}, sim-matched {} integral above zero = {}"
.format(name, len(qArray), name, sum(qArray < 0), name,
len(qArraySimTrackMatched), name,
sum(qArraySimTrackMatched > 0)))
make_plots(
qArray, qArraySimTrackMatched,
"overlap between 1/{} and 1/{}".format("Inner",
name[5:]), layerType)
def test_highlevel():
array = ak.Array(
[[[2, 3, 5], [], [7, 11], [13]], [], [[17, 19], [23]]], check_valid=True
)
assert ak.count(array) == 9
assert ak.to_list(ak.count(array, axis=-1)) == [[3, 0, 2, 1], [], [2, 1]]
assert ak.to_list(ak.count(array, axis=2)) == [[3, 0, 2, 1], [], [2, 1]]
assert ak.to_list(ak.count(array, axis=-1, keepdims=True)) == [
[[3], [0], [2], [1]],
[],
[[2], [1]],
]
assert ak.to_list(ak.count(array, axis=-2)) == [[3, 2, 1], [], [2, 1]]
assert ak.to_list(ak.count(array, axis=1)) == [[3, 2, 1], [], [2, 1]]
assert ak.to_list(ak.count(array, axis=-2, keepdims=True)) == [
[[3, 2, 1]],
[[]],
[[2, 1]],
]
assert ak.count_nonzero(array) == 9
assert ak.to_list(ak.count_nonzero(array, axis=-1)) == [[3, 0, 2, 1], [], [2, 1]]
assert ak.to_list(ak.count_nonzero(array, axis=-2)) == [[3, 2, 1], [], [2, 1]]
assert ak.sum(array) == 2 + 3 + 5 + 7 + 11 + 13 + 17 + 19 + 23
assert ak.to_list(ak.sum(array, axis=-1)) == [
[2 + 3 + 5, 0, 7 + 11, 13],
[],
[17 + 19, 23],
]
assert ak.to_list(ak.sum(array, axis=-2)) == [
[2 + 7 + 13, 3 + 11, 5],
[],
[17 + 23, 19],
]
assert ak.prod(array) == 2 * 3 * 5 * 7 * 11 * 13 * 17 * 19 * 23
assert ak.to_list(ak.prod(array, axis=-1)) == [
[2 * 3 * 5, 1, 7 * 11, 13],
[],
[17 * 19, 23],
]
assert ak.to_list(ak.prod(array, axis=-2)) == [
[2 * 7 * 13, 3 * 11, 5],
[],
[17 * 23, 19],
]
assert ak.min(array) == 2
assert ak.to_list(ak.min(array, axis=-1)) == [[2, None, 7, 13], [], [17, 23]]
assert ak.to_list(ak.min(array, axis=-2)) == [[2, 3, 5], [], [17, 19]]
assert ak.max(array) == 23
assert ak.to_list(ak.max(array, axis=-1)) == [[5, None, 11, 13], [], [19, 23]]
assert ak.to_list(ak.max(array, axis=-2)) == [[13, 11, 5], [], [23, 19]]
array = ak.Array(
[
[[True, False, True], [], [False, False], [True]],
[],
[[False, True], [True]],
],
check_valid=True,
)
assert ak.any(array) == True
assert ak.to_list(ak.any(array, axis=-1)) == [
[True, False, False, True],
[],
[True, True],
]
assert ak.to_list(ak.any(array, axis=-2)) == [[True, False, True], [], [True, True]]
assert ak.all(array) == False
assert ak.to_list(ak.all(array, axis=-1)) == [
[False, True, False, True],
[],
[False, True],
]
assert ak.to_list(ak.all(array, axis=-2)) == [
[False, False, True],
[],
[False, True],
]
def make_leadjet_pt_cut(jets):
leadpt_cut = (ak.max(jets["pt"], axis=1) >= jet_pars["lead_ptmin"])
return leadpt_cut
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
