def __init__(self, **kwargs):
'''
kwargs should be:
ele (loose and tight)
mu
jets: all, central, forward, b-tag
met
'''
self.__dict__.update(kwargs)
# not yet sure whether this should go here, or later
self.filters = getFilters(self.events, year=self.year, dataset=self.dataset)
def process(self, events):
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']
# load the config - probably not needed anymore
cfg = loadConfig()
#output['totalEvents']['all'] += len(events)
#output['skimmedEvents']['all'] += len(ev)
if self.year == 2018:
triggers = ev.HLT.Ele23_Ele12_CaloIdL_TrackIdL_IsoVL
elif self.year == 2017:
triggers = ev.HLT.Ele23_Ele12_CaloIdL_TrackIdL_IsoVL
elif self.year == 2016:
triggers = ev.HLT.Ele23_Ele12_CaloIdL_TrackIdL_IsoVL_DZ
if self.year == 2018:
lumimask = LumiMask(
'processors/Cert_314472-325175_13TeV_Legacy2018_Collisions18_JSON.txt'
)
## Electrons
electron = Collections(ev, "Electron", "tight").get()
electron = electron[(electron.pt > 25) & (np.abs(electron.eta) < 2.4)]
loose_electron = Collections(ev, "Electron", "veto").get()
loose_electron = loose_electron[(loose_electron.pt > 25)
& (np.abs(loose_electron.eta) < 2.4)]
SSelectron = (ak.sum(electron.charge, axis=1) != 0) & (ak.num(electron)
== 2)
OSelectron = (ak.sum(electron.charge, axis=1) == 0) & (ak.num(electron)
== 2)
dielectron = choose(electron, 2)
dielectron_mass = (dielectron['0'] + dielectron['1']).mass
dielectron_pt = (dielectron['0'] + dielectron['1']).pt
leading_electron_idx = ak.singletons(ak.argmax(electron.pt, axis=1))
leading_electron = electron[(leading_electron_idx)]
leading_electron = leading_electron[(leading_electron.pt > 30)]
trailing_electron_idx = ak.singletons(ak.argmin(electron.pt, axis=1))
trailing_electron = electron[trailing_electron_idx]
##Muons
loose_muon = Collections(ev, "Muon", "veto").get()
loose_muon = loose_muon[(loose_muon.pt > 20)
& (np.abs(loose_muon.eta) < 2.4)]
#jets
jet = getJets(ev, minPt=40, maxEta=2.4, pt_var='pt', UL=False)
jet = jet[ak.argsort(
jet.pt, ascending=False
)] # need to sort wrt smeared and recorrected jet pt
jet = jet[~match(jet, loose_muon,
deltaRCut=0.4)] # remove jets that overlap with muons
jet = jet[~match(
jet, electron,
deltaRCut=0.4)] # remove jets that overlap with electrons
## MET -> can switch to puppi MET
met_pt = ev.MET.pt
met_phi = ev.MET.phi
#selections
filters = getFilters(ev, year=self.year, dataset=dataset)
mask = lumimask(ev.run, ev.luminosityBlock)
ss = (SSelectron)
os = (OSelectron)
mass = (ak.min(np.abs(dielectron_mass - 91.2), axis=1) < 15)
lead_electron = (ak.min(leading_electron.pt, axis=1) > 30)
jet1 = (ak.num(jet) >= 1)
jet2 = (ak.num(jet) >= 2)
num_loose = ((ak.num(loose_electron) == 2) & (ak.num(loose_muon) == 0))
selection = PackedSelection()
selection.add('filter', (filters))
selection.add('mask', (mask))
selection.add('ss', ss)
selection.add('os', os)
selection.add('mass', mass)
selection.add('leading', lead_electron)
selection.add('triggers', triggers)
selection.add('one jet', jet1)
selection.add('two jets', jet2)
selection.add('num_loose', num_loose)
bl_reqs = ['filter'] + ['mass'] + ['mask'] + ['triggers'] + [
'leading'
] + ['num_loose']
#bl_reqs = ['filter'] + ['mass'] + ['triggers'] + ['leading'] + ['num_loose']
bl_reqs_d = {sel: True for sel in bl_reqs}
baseline = selection.require(**bl_reqs_d)
s_reqs = bl_reqs + ['ss']
s_reqs_d = {sel: True for sel in s_reqs}
ss_sel = selection.require(**s_reqs_d)
o_reqs = bl_reqs + ['os']
o_reqs_d = {sel: True for sel in o_reqs}
os_sel = selection.require(**o_reqs_d)
j1s_reqs = s_reqs + ['one jet']
j1s_reqs_d = {sel: True for sel in j1s_reqs}
j1ss_sel = selection.require(**j1s_reqs_d)
j1o_reqs = o_reqs + ['one jet']
j1o_reqs_d = {sel: True for sel in j1o_reqs}
j1os_sel = selection.require(**j1o_reqs_d)
j2s_reqs = s_reqs + ['two jets']
j2s_reqs_d = {sel: True for sel in j2s_reqs}
j2ss_sel = selection.require(**j2s_reqs_d)
j2o_reqs = o_reqs + ['two jets']
j2o_reqs_d = {sel: True for sel in j2o_reqs}
j2os_sel = selection.require(**j2o_reqs_d)
output["N_jet"].fill(
dataset=dataset,
multiplicity=ak.num(jet)[os_sel],
)
return output
def process(self, events):
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']
# load the config - probably not needed anymore
cfg = loadConfig()
output['totalEvents']['all'] += len(events)
output['skimmedEvents']['all'] += len(ev)
## Electrons
electron = Collections(ev, "Electron", "tightFCNC", 0, self.year).get()
electron = electron[(electron.pt > 15) & (np.abs(electron.eta) < 2.4)]
electron = electron[(electron.genPartIdx >= 0)]
electron = electron[(np.abs(electron.matched_gen.pdgId) == 11
)] #from here on all leptons are gen-matched
electron = electron[((electron.genPartFlav == 1) |
(electron.genPartFlav
== 15))] #and now they are all prompt
is_flipped = (((electron.matched_gen.pdgId * (-1) == electron.pdgId) |
(find_first_parent(electron.matched_gen) *
(-1) == electron.pdgId)) &
(np.abs(electron.pdgId) == 11))
flipped_electron = electron[is_flipped]
n_flips = ak.num(flipped_electron)
leading_electron_idx = ak.singletons(ak.argmax(electron.pt, axis=1))
leading_electron = electron[leading_electron_idx]
leading_flipped_electron_idx = ak.singletons(
ak.argmax(flipped_electron.pt, axis=1))
leading_flipped_electron = electron[leading_flipped_electron_idx]
def getMVAscore(electron):
if self.year == 2016:
MVA = electron.mvaSpring16GP
return MVA
elif self.year == 2017:
MVA = electron.mvaFall17V2noIso
return MVA
elif self.year == 2018:
MVA = np.minimum(
np.maximum(electron.mvaFall17V2noIso, -1.0 + 1.e-6),
1.0 - 1.e-6)
return -0.5 * np.log(2 / (MVA + 1) - 1)
# setting up the various weights
#weight = Weights( len(ev) )
#if not dataset=='MuonEG':
# generator weight
# weight.add("weight", ev.genWeight)
#selections
filters = getFilters(ev, year=self.year, dataset=dataset)
electr = ((ak.num(electron) >= 1))
flip = (n_flips >= 1)
selection = PackedSelection()
selection.add('filter', (filters))
selection.add('electr', electr)
selection.add('flip', flip)
bl_reqs = ['filter', 'electr']
bl_reqs_d = {sel: True for sel in bl_reqs}
baseline = selection.require(**bl_reqs_d)
f_reqs = bl_reqs + ['flip']
f_reqs_d = {sel: True for sel in f_reqs}
flip_sel = selection.require(**f_reqs_d)
#adjust weights to prevent length mismatch
#ak_weight_gen = ak.ones_like(electron[baseline].pt) * weight.weight()[baseline]
#ak_weight_flip = ak.ones_like(flipped_electron[flip_sel].pt) * weight.weight()[flip_sel]
#output['N_ele'].fill(dataset=dataset, multiplicity=ak.num(electron)[baseline], weight=weight.weight()[baseline])
#output['electron_flips'].fill(dataset=dataset, multiplicity=n_flips[baseline], weight=weight.weight()[baseline])
output["electron"].fill(
dataset=dataset,
pt=ak.to_numpy(ak.flatten(electron[baseline].pt)),
eta=abs(ak.to_numpy(ak.flatten(electron[baseline].eta))),
)
output["electron2"].fill(
dataset=dataset,
pt=ak.to_numpy(ak.flatten(electron[baseline].pt)),
eta=ak.to_numpy(ak.flatten(electron[baseline].eta)),
)
output["flipped_electron"].fill(
dataset=dataset,
pt=ak.to_numpy(ak.flatten(flipped_electron[flip_sel].pt)),
eta=abs(ak.to_numpy(ak.flatten(flipped_electron[flip_sel].eta))),
)
output["flipped_electron2"].fill(
dataset=dataset,
pt=ak.to_numpy(ak.flatten(flipped_electron[flip_sel].pt)),
eta=ak.to_numpy(ak.flatten(flipped_electron[flip_sel].eta)),
)
output["mva_id"].fill(
dataset=dataset,
mva_id=ak.to_numpy(ak.flatten(getMVAscore(electron)[baseline])),
eta=np.abs(ak.to_numpy(ak.flatten(electron.etaSC[baseline]))),
)
output["mva_id2"].fill(
dataset=dataset,
mva_id=ak.to_numpy(ak.flatten(getMVAscore(electron)[baseline])),
pt=ak.to_numpy(ak.flatten(electron.pt[baseline])),
)
output["isolation"].fill(
dataset=dataset,
isolation1=ak.to_numpy(ak.flatten(electron.jetRelIso[baseline])),
isolation2=ak.to_numpy(ak.flatten(electron.jetPtRelv2[baseline])),
)
return output
def process(self, events):
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
if self.year == 2016:
lumimask = LumiMask(
'../data/lumi/Cert_271036-284044_13TeV_Legacy2016_Collisions16_JSON.txt'
)
if self.year == 2017:
lumimask = LumiMask(
'../data/lumi/Cert_294927-306462_13TeV_UL2017_Collisions17_GoldenJSON.txt'
)
if self.year == 2018:
lumimask = LumiMask(
'../data/lumi/Cert_314472-325175_13TeV_Legacy2018_Collisions18_JSON.txt'
)
ev = events[presel]
dataset = ev.metadata['dataset']
# load the config - probably not needed anymore
cfg = loadConfig()
output['totalEvents']['all'] += len(events)
output['skimmedEvents']['all'] += len(ev)
if self.year == 2018:
triggers = ev.HLT.Ele23_Ele12_CaloIdL_TrackIdL_IsoVL
elif self.year == 2017:
triggers = ev.HLT.Ele23_Ele12_CaloIdL_TrackIdL_IsoVL
elif self.year == 2016:
triggers = ev.HLT.Ele23_Ele12_CaloIdL_TrackIdL_IsoVL_DZ
## Electrons
electron = Collections(ev, "Electron", "tightFCNC", 0, self.year).get()
electron = electron[(electron.pt > 25) & (np.abs(electron.eta) < 2.4)]
loose_electron = Collections(ev, "Electron", "looseFCNC", 0,
self.year).get()
loose_electron = loose_electron[(loose_electron.pt > 25)
& (np.abs(loose_electron.eta) < 2.4)]
SSelectron = (ak.sum(electron.charge, axis=1) != 0) & (ak.num(electron)
== 2)
OSelectron = (ak.sum(electron.charge, axis=1) == 0) & (ak.num(electron)
== 2)
dielectron = choose(electron, 2)
dielectron_mass = (dielectron['0'] + dielectron['1']).mass
dielectron_pt = (dielectron['0'] + dielectron['1']).pt
leading_electron_idx = ak.singletons(ak.argmax(electron.pt, axis=1))
leading_electron = electron[(leading_electron_idx)]
leading_electron = leading_electron[(leading_electron.pt > 30)]
trailing_electron_idx = ak.singletons(ak.argmin(electron.pt, axis=1))
trailing_electron = electron[trailing_electron_idx]
##Muons
loose_muon = Collections(ev, "Muon", "looseFCNC", 0, self.year).get()
loose_muon = loose_muon[(loose_muon.pt > 20)
& (np.abs(loose_muon.eta) < 2.4)]
#jets
jet = getJets(ev, minPt=40, maxEta=2.4, pt_var='pt')
jet = jet[~match(jet, loose_muon,
deltaRCut=0.4)] # remove jets that overlap with muons
jet = jet[~match(
jet, electron,
deltaRCut=0.4)] # remove jets that overlap with electrons
## MET -> can switch to puppi MET
met_pt = ev.MET.pt
met_phi = ev.MET.phi
#weights
weight = Weights(len(ev))
weight2 = Weights(len(ev))
weight2.add("charge flip",
self.charge_flip_ratio.flip_weight(electron))
#selections
filters = getFilters(ev, year=self.year, dataset=dataset, UL=False)
mask = lumimask(ev.run, ev.luminosityBlock)
ss = (SSelectron)
os = (OSelectron)
mass = (ak.min(np.abs(dielectron_mass - 91.2), axis=1) < 15)
lead_electron = (ak.min(leading_electron.pt, axis=1) > 30)
jet1 = (ak.num(jet) >= 1)
jet2 = (ak.num(jet) >= 2)
num_loose = ((ak.num(loose_electron) == 2) & (ak.num(loose_muon) == 0))
selection = PackedSelection()
selection.add('filter', (filters))
selection.add('mask', (mask))
selection.add('ss', ss)
selection.add('os', os)
selection.add('mass', mass)
selection.add('leading', lead_electron)
selection.add('triggers', triggers)
selection.add('one jet', jet1)
selection.add('two jets', jet2)
selection.add('num_loose', num_loose)
bl_reqs = ['filter'] + ['triggers'] + ['mask']
bl_reqs_d = {sel: True for sel in bl_reqs}
baseline = selection.require(**bl_reqs_d)
s_reqs = bl_reqs + ['ss'] + ['mass'] + ['num_loose'] + ['leading']
s_reqs_d = {sel: True for sel in s_reqs}
ss_sel = selection.require(**s_reqs_d)
o_reqs = bl_reqs + ['os'] + ['mass'] + ['num_loose'] + ['leading']
o_reqs_d = {sel: True for sel in o_reqs}
os_sel = selection.require(**o_reqs_d)
j1s_reqs = s_reqs + ['one jet']
j1s_reqs_d = {sel: True for sel in j1s_reqs}
j1ss_sel = selection.require(**j1s_reqs_d)
j1o_reqs = o_reqs + ['one jet']
j1o_reqs_d = {sel: True for sel in j1o_reqs}
j1os_sel = selection.require(**j1o_reqs_d)
j2s_reqs = s_reqs + ['two jets']
j2s_reqs_d = {sel: True for sel in j2s_reqs}
j2ss_sel = selection.require(**j2s_reqs_d)
j2o_reqs = o_reqs + ['two jets']
j2o_reqs_d = {sel: True for sel in j2o_reqs}
j2os_sel = selection.require(**j2o_reqs_d)
#outputs
output["electron_data1"].fill(
dataset=dataset,
pt=ak.to_numpy(ak.flatten(leading_electron[os_sel].pt)),
eta=ak.to_numpy(ak.flatten(leading_electron[os_sel].eta)),
phi=ak.to_numpy(ak.flatten(leading_electron[os_sel].phi)),
weight=weight2.weight()[os_sel])
output["electron_data2"].fill(
dataset=dataset,
pt=ak.to_numpy(ak.flatten(trailing_electron[os_sel].pt)),
eta=ak.to_numpy(ak.flatten(trailing_electron[os_sel].eta)),
phi=ak.to_numpy(ak.flatten(trailing_electron[os_sel].phi)),
weight=weight2.weight()[os_sel])
output["electron_data3"].fill(
dataset=dataset,
pt=ak.to_numpy(ak.flatten(leading_electron[j1os_sel].pt)),
eta=ak.to_numpy(ak.flatten(leading_electron[j1os_sel].eta)),
phi=ak.to_numpy(ak.flatten(leading_electron[j1os_sel].phi)),
weight=weight2.weight()[j1os_sel])
output["electron_data4"].fill(
dataset=dataset,
pt=ak.to_numpy(ak.flatten(trailing_electron[j1os_sel].pt)),
eta=ak.to_numpy(ak.flatten(trailing_electron[j1os_sel].eta)),
phi=ak.to_numpy(ak.flatten(trailing_electron[j1os_sel].phi)),
weight=weight2.weight()[j1os_sel])
output["electron_data5"].fill(
dataset=dataset,
pt=ak.to_numpy(ak.flatten(leading_electron[j2os_sel].pt)),
eta=ak.to_numpy(ak.flatten(leading_electron[j2os_sel].eta)),
phi=ak.to_numpy(ak.flatten(leading_electron[j2os_sel].phi)),
weight=weight2.weight()[j2os_sel])
output["electron_data6"].fill(
dataset=dataset,
pt=ak.to_numpy(ak.flatten(trailing_electron[j2os_sel].pt)),
eta=ak.to_numpy(ak.flatten(trailing_electron[j2os_sel].eta)),
phi=ak.to_numpy(ak.flatten(trailing_electron[j2os_sel].phi)),
weight=weight2.weight()[j2os_sel])
output["electron_data7"].fill(
dataset=dataset,
pt=ak.to_numpy(ak.flatten(leading_electron[ss_sel].pt)),
eta=ak.to_numpy(ak.flatten(leading_electron[ss_sel].eta)),
phi=ak.to_numpy(ak.flatten(leading_electron[ss_sel].phi)),
weight=weight.weight()[ss_sel])
output["electron_data8"].fill(
dataset=dataset,
pt=ak.to_numpy(ak.flatten(trailing_electron[ss_sel].pt)),
eta=ak.to_numpy(ak.flatten(trailing_electron[ss_sel].eta)),
phi=ak.to_numpy(ak.flatten(trailing_electron[ss_sel].phi)),
weight=weight.weight()[ss_sel])
output["electron_data9"].fill(
dataset=dataset,
pt=ak.to_numpy(ak.flatten(leading_electron[j1ss_sel].pt)),
eta=ak.to_numpy(ak.flatten(leading_electron[j1ss_sel].eta)),
phi=ak.to_numpy(ak.flatten(leading_electron[j1ss_sel].phi)),
weight=weight.weight()[j1ss_sel])
output["electron_data10"].fill(
dataset=dataset,
pt=ak.to_numpy(ak.flatten(trailing_electron[j1ss_sel].pt)),
eta=ak.to_numpy(ak.flatten(trailing_electron[j1ss_sel].eta)),
phi=ak.to_numpy(ak.flatten(trailing_electron[j1ss_sel].phi)),
weight=weight.weight()[j1ss_sel])
output["electron_data11"].fill(
dataset=dataset,
pt=ak.to_numpy(ak.flatten(leading_electron[j2ss_sel].pt)),
eta=ak.to_numpy(ak.flatten(leading_electron[j2ss_sel].eta)),
phi=ak.to_numpy(ak.flatten(leading_electron[j2ss_sel].phi)),
weight=weight.weight()[j2ss_sel])
output["electron_data12"].fill(
dataset=dataset,
pt=ak.to_numpy(ak.flatten(trailing_electron[j2ss_sel].pt)),
eta=ak.to_numpy(ak.flatten(trailing_electron[j2ss_sel].eta)),
phi=ak.to_numpy(ak.flatten(trailing_electron[j2ss_sel].phi)),
weight=weight.weight()[j2ss_sel])
output["dilep_mass1"].fill(
dataset=dataset,
mass=ak.to_numpy(ak.flatten(dielectron_mass[os_sel])),
pt=ak.to_numpy(ak.flatten(dielectron_pt[os_sel])),
weight=weight2.weight()[os_sel])
output["dilep_mass2"].fill(
dataset=dataset,
mass=ak.to_numpy(ak.flatten(dielectron_mass[j1os_sel])),
pt=ak.to_numpy(ak.flatten(dielectron_pt[j1os_sel])),
weight=weight2.weight()[j1os_sel])
output["dilep_mass3"].fill(
dataset=dataset,
mass=ak.to_numpy(ak.flatten(dielectron_mass[j2os_sel])),
pt=ak.to_numpy(ak.flatten(dielectron_pt[j2os_sel])),
weight=weight2.weight()[j2os_sel])
output["dilep_mass4"].fill(
dataset=dataset,
mass=ak.to_numpy(ak.flatten(dielectron_mass[ss_sel])),
pt=ak.to_numpy(ak.flatten(dielectron_pt[ss_sel])),
weight=weight.weight()[ss_sel])
output["dilep_mass5"].fill(
dataset=dataset,
mass=ak.to_numpy(ak.flatten(dielectron_mass[j1ss_sel])),
pt=ak.to_numpy(ak.flatten(dielectron_pt[j1ss_sel])),
weight=weight.weight()[j1ss_sel])
output["dilep_mass6"].fill(
dataset=dataset,
mass=ak.to_numpy(ak.flatten(dielectron_mass[j2ss_sel])),
pt=ak.to_numpy(ak.flatten(dielectron_pt[j2ss_sel])),
weight=weight.weight()[j2ss_sel])
output["MET"].fill(dataset=dataset,
pt=met_pt[os_sel],
weight=weight2.weight()[os_sel])
output["MET2"].fill(dataset=dataset,
pt=met_pt[j1os_sel],
weight=weight2.weight()[j1os_sel])
output["MET3"].fill(dataset=dataset,
pt=met_pt[j2os_sel],
weight=weight2.weight()[j2os_sel])
output["MET4"].fill(dataset=dataset,
pt=met_pt[ss_sel],
weight=weight.weight()[ss_sel])
output["MET5"].fill(dataset=dataset,
pt=met_pt[j1ss_sel],
weight=weight.weight()[j1ss_sel])
output["MET6"].fill(dataset=dataset,
pt=met_pt[j2ss_sel],
weight=weight.weight()[j2ss_sel])
output["N_jet"].fill(dataset=dataset,
multiplicity=ak.num(jet)[os_sel],
weight=weight2.weight()[os_sel])
output["N_jet2"].fill(dataset=dataset,
multiplicity=ak.num(jet)[j1os_sel],
weight=weight2.weight()[j1os_sel])
output["N_jet3"].fill(dataset=dataset,
multiplicity=ak.num(jet)[j2os_sel],
weight=weight2.weight()[j2os_sel])
output["N_jet4"].fill(dataset=dataset,
multiplicity=ak.num(jet)[ss_sel],
weight=weight.weight()[ss_sel])
output["N_jet5"].fill(dataset=dataset,
multiplicity=ak.num(jet)[j1ss_sel],
weight=weight.weight()[j1ss_sel])
output["N_jet6"].fill(dataset=dataset,
multiplicity=ak.num(jet)[j2ss_sel],
weight=weight.weight()[j2ss_sel])
output["PV_npvsGood"].fill(dataset=dataset,
multiplicity=ev.PV[os_sel].npvsGood,
weight=weight2.weight()[os_sel])
output["PV_npvsGood2"].fill(dataset=dataset,
multiplicity=ev.PV[j1os_sel].npvsGood,
weight=weight2.weight()[j1os_sel])
output["PV_npvsGood3"].fill(dataset=dataset,
multiplicity=ev.PV[j2os_sel].npvsGood,
weight=weight2.weight()[j2os_sel])
output["PV_npvsGood4"].fill(dataset=dataset,
multiplicity=ev.PV[ss_sel].npvsGood,
weight=weight.weight()[ss_sel])
output["PV_npvsGood5"].fill(dataset=dataset,
multiplicity=ev.PV[j1ss_sel].npvsGood,
weight=weight.weight()[j1ss_sel])
output["PV_npvsGood6"].fill(dataset=dataset,
multiplicity=ev.PV[j2ss_sel].npvsGood,
weight=weight.weight()[j2ss_sel])
return output