def process(self, events):
output = self.accumulator.identity()
# 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()
output['totalEvents']['all'] += len(events)
output['skimmedEvents']['all'] += len(ev)
## Muons
muon = Collections(ev, "Muon", "tightSSTTH").get()
vetomuon = Collections(ev, "Muon", "vetoTTH").get()
dimuon = choose(muon, 2)
SSmuon = ak.any((dimuon['0'].charge * dimuon['1'].charge)>0, axis=1)
OSmuon = 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", "tightSSTTH").get()
vetoelectron = Collections(ev, "Electron", "vetoTTH").get()
dielectron = choose(electron, 2)
SSelectron = ak.any((dielectron['0'].charge * dielectron['1'].charge)>0, axis=1)
OSelectron = 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
lepton = ak.concatenate([muon, electron], axis=1)
dilepton = cross(muon, electron)
SSlepton = ak.any((dilepton['0'].charge * dilepton['1'].charge)>0, axis=1)
OSlepton = ak.any((dilepton['0'].charge * dilepton['1'].charge)<0, 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]
## 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)
## forward jets
high_p_fwd = fwd[ak.singletons(ak.argmax(fwd.p, axis=1))] # highest momentum spectator
high_pt_fwd = fwd[ak.singletons(ak.argmax(fwd.pt_nom, axis=1))] # highest transverse momentum spectator
high_eta_fwd = fwd[ak.singletons(ak.argmax(abs(fwd.eta), axis=1))] # most forward spectator
## Get the two leading b-jets in terms of btag score
high_score_btag = central[ak.argsort(central.btagDeepFlavB)][:,:2]
jf = cross(high_p_fwd, jet)
mjf = (jf['0']+jf['1']).mass
deltaEta = abs(high_p_fwd.eta - jf[ak.singletons(ak.argmax(mjf, axis=1))]['1'].eta)
deltaEtaMax = ak.max(deltaEta, axis=1)
mjf_max = ak.max(mjf, axis=1)
jj = choose(jet, 2)
mjj_max = ak.max((jj['0']+jj['1']).mass, axis=1)
## 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)
ht_central = ak.sum(central.pt, axis=1)
# define the weight
weight = Weights( len(ev) )
if not re.search(re.compile('MuonEG|DoubleMuon|DoubleEG|EGamma'), dataset):
# lumi weight
weight.add("weight", ev.weight*cfg['lumi'][self.year])
# 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)
sel = Selection(
dataset = dataset,
events = ev,
year = self.year,
ele = electron,
ele_veto = vetoelectron,
mu = muon,
mu_veto = vetomuon,
jet_all = jet,
jet_central = central,
jet_btag = btag,
jet_fwd = fwd,
met = ev.MET,
)
BL = sel.dilep_baseline(cutflow=cutflow, SS=False)
# first, make a few super inclusive plots
output['PV_npvs'].fill(dataset=dataset, multiplicity=ev.PV[BL].npvs, weight=weight.weight()[BL])
output['PV_npvsGood'].fill(dataset=dataset, multiplicity=ev.PV[BL].npvsGood, weight=weight.weight()[BL])
output['N_jet'].fill(dataset=dataset, multiplicity=ak.num(jet)[BL], weight=weight.weight()[BL])
BL_minusNb = sel.dilep_baseline(SS=False, omit=['N_btag>0'])
output['N_b'].fill(dataset=dataset, multiplicity=ak.num(btag)[BL_minusNb], weight=weight.weight()[BL_minusNb])
output['N_central'].fill(dataset=dataset, multiplicity=ak.num(central)[BL], weight=weight.weight()[BL])
output['N_ele'].fill(dataset=dataset, multiplicity=ak.num(electron)[BL], weight=weight.weight()[BL])
output['N_mu'].fill(dataset=dataset, multiplicity=ak.num(electron)[BL], weight=weight.weight()[BL])
BL_minusFwd = sel.dilep_baseline(SS=False, omit=['N_fwd>0'])
output['N_fwd'].fill(dataset=dataset, multiplicity=ak.num(fwd)[BL_minusFwd], weight=weight.weight()[BL_minusFwd])
BL_minusMET = sel.dilep_baseline(SS=False, omit=['MET>50'])
output['MET'].fill(
dataset = dataset,
pt = ev.MET[BL_minusMET].pt,
phi = ev.MET[BL_minusMET].phi,
weight = weight.weight()[BL_minusMET]
)
#output['electron'].fill(
# dataset = dataset,
# pt = ak.to_numpy(ak.flatten(electron[BL].pt)),
# eta = ak.to_numpy(ak.flatten(electron[BL].eta)),
# phi = ak.to_numpy(ak.flatten(electron[BL].phi)),
# weight = weight.weight()[BL]
#)
#
#output['muon'].fill(
# dataset = dataset,
# pt = ak.to_numpy(ak.flatten(muon[BL].pt)),
# eta = ak.to_numpy(ak.flatten(muon[BL].eta)),
# phi = ak.to_numpy(ak.flatten(muon[BL].phi)),
# weight = weight.weight()[BL]
#)
output['lead_lep'].fill(
dataset = dataset,
pt = ak.to_numpy(ak.flatten(leading_lepton[BL].pt)),
eta = ak.to_numpy(ak.flatten(leading_lepton[BL].eta)),
phi = ak.to_numpy(ak.flatten(leading_lepton[BL].phi)),
weight = weight.weight()[BL]
)
output['trail_lep'].fill(
dataset = dataset,
pt = ak.to_numpy(ak.flatten(trailing_lepton[BL].pt)),
eta = ak.to_numpy(ak.flatten(trailing_lepton[BL].eta)),
phi = ak.to_numpy(ak.flatten(trailing_lepton[BL].phi)),
weight = weight.weight()[BL]
)
output['fwd_jet'].fill(
dataset = dataset,
pt = ak.flatten(high_p_fwd[BL].pt_nom),
eta = ak.flatten(high_p_fwd[BL].eta),
phi = ak.flatten(high_p_fwd[BL].phi),
weight = weight.weight()[BL]
)
output['b1'].fill(
dataset = dataset,
pt = ak.flatten(high_score_btag[:, 0:1][BL].pt_nom),
eta = ak.flatten(high_score_btag[:, 0:1][BL].eta),
phi = ak.flatten(high_score_btag[:, 0:1][BL].phi),
weight = weight.weight()[BL]
)
output['b2'].fill(
dataset = dataset,
pt = ak.flatten(high_score_btag[:, 1:2][BL].pt_nom),
eta = ak.flatten(high_score_btag[:, 1:2][BL].eta),
phi = ak.flatten(high_score_btag[:, 1:2][BL].phi),
weight = weight.weight()[BL]
)
output['j1'].fill(
dataset = dataset,
pt = ak.flatten(jet.pt_nom[:, 0:1][BL]),
eta = ak.flatten(jet.eta[:, 0:1][BL]),
phi = ak.flatten(jet.phi[:, 0:1][BL]),
weight = weight.weight()[BL]
)
output['j2'].fill(
dataset = dataset,
pt = ak.flatten(jet[:, 1:2][BL].pt_nom),
eta = ak.flatten(jet[:, 1:2][BL].eta),
phi = ak.flatten(jet[:, 1:2][BL].phi),
weight = weight.weight()[BL]
)
output['j3'].fill(
dataset = dataset,
pt = ak.flatten(jet[:, 2:3][BL].pt_nom),
eta = ak.flatten(jet[:, 2:3][BL].eta),
phi = ak.flatten(jet[:, 2:3][BL].phi),
weight = weight.weight()[BL]
)
if re.search(re.compile('MuonEG|DoubleMuon|DoubleEG|EGamma'), dataset):
#rle = ak.to_numpy(ak.zip([ev.run, ev.luminosityBlock, ev.event]))
run_ = ak.to_numpy(ev.run)
lumi_ = ak.to_numpy(ev.luminosityBlock)
event_ = ak.to_numpy(ev.event)
output['%s_run'%dataset] += processor.column_accumulator(run_[BL])
output['%s_lumi'%dataset] += processor.column_accumulator(lumi_[BL])
output['%s_event'%dataset] += processor.column_accumulator(event_[BL])
# Now, take care of systematic unceratinties
if not re.search(re.compile('MuonEG|DoubleMuon|DoubleEG|EGamma'), dataset):
alljets = getJets(ev, minPt=0, maxEta=4.7)
alljets = alljets[(alljets.jetId>1)]
for var in self.variations:
# get the collections that change with the variations
jet = getPtEtaPhi(alljets, pt_var=var)
jet = jet[(jet.pt>25)]
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)
## forward jets
high_p_fwd = fwd[ak.singletons(ak.argmax(fwd.p, axis=1))] # highest momentum spectator
high_pt_fwd = fwd[ak.singletons(ak.argmax(fwd.pt, axis=1))] # highest transverse momentum spectator
high_eta_fwd = fwd[ak.singletons(ak.argmax(abs(fwd.eta), axis=1))] # most forward spectator
## Get the two leading b-jets in terms of btag score
high_score_btag = central[ak.argsort(central.btagDeepFlavB)][:,:2]
met = ev.MET
met['pt'] = getattr(met, var)
sel = Selection(
dataset = dataset,
events = ev,
year = self.year,
ele = electron,
ele_veto = vetoelectron,
mu = muon,
mu_veto = vetomuon,
jet_all = jet,
jet_central = central,
jet_btag = btag,
jet_fwd = fwd,
met = met,
)
BL = sel.dilep_baseline(SS=False)
# get the modified selection -> more difficult
#selection.add('N_jet>2_'+var, (ak.num(jet.pt)>=3)) # stupid bug here...
#selection.add('N_btag=2_'+var, (ak.num(btag)==2) )
#selection.add('N_central>1_'+var, (ak.num(central)>=2) )
#selection.add('N_fwd>0_'+var, (ak.num(fwd)>=1) )
#selection.add('MET>30_'+var, (getattr(ev.MET, var)>30) )
### Don't change the selection for now...
#bl_reqs = os_reqs + ['N_jet>2_'+var, 'MET>30_'+var, 'N_btag=2_'+var, 'N_central>1_'+var, 'N_fwd>0_'+var]
#bl_reqs_d = { sel: True for sel in bl_reqs }
#BL = selection.require(**bl_reqs_d)
# the OS selection remains unchanged
output['N_jet_'+var].fill(dataset=dataset, multiplicity=ak.num(jet)[BL], weight=weight.weight()[BL])
BL_minusFwd = sel.dilep_baseline(SS=False, omit=['N_fwd>0'])
output['N_fwd_'+var].fill(dataset=dataset, multiplicity=ak.num(fwd)[BL_minusFwd], weight=weight.weight()[BL_minusFwd])
BL_minusNb = sel.dilep_baseline(SS=False, omit=['N_btag>0'])
output['N_b_'+var].fill(dataset=dataset, multiplicity=ak.num(btag)[BL_minusNb], weight=weight.weight()[BL_minusNb])
output['N_central_'+var].fill(dataset=dataset, multiplicity=ak.num(central)[BL], weight=weight.weight()[BL])
# We don't need to redo all plots with variations. E.g., just add uncertainties to the jet plots.
output['j1_'+var].fill(
dataset = dataset,
pt = ak.flatten(jet.pt[:, 0:1][BL]),
eta = ak.flatten(jet.eta[:, 0:1][BL]),
phi = ak.flatten(jet.phi[:, 0:1][BL]),
weight = weight.weight()[BL]
)
output['b1_'+var].fill(
dataset = dataset,
pt = ak.flatten(high_score_btag[:, 0:1].pt[:, 0:1][BL]),
eta = ak.flatten(high_score_btag[:, 0:1].eta[:, 0:1][BL]),
phi = ak.flatten(high_score_btag[:, 0:1].phi[:, 0:1][BL]),
weight = weight.weight()[BL]
)
output['fwd_jet_'+var].fill(
dataset = dataset,
pt = ak.flatten(high_p_fwd[BL].pt),
#p = ak.flatten(high_p_fwd[BL].p),
eta = ak.flatten(high_p_fwd[BL].eta),
phi = ak.flatten(high_p_fwd[BL].phi),
weight = weight.weight()[BL]
)
BL_minusMET = sel.dilep_baseline(SS=False, omit=['MET>50'])
output['MET_'+var].fill(
dataset = dataset,
pt = getattr(ev.MET, var)[BL_minusMET],
phi = ev.MET[BL_minusMET].phi,
weight = weight.weight()[BL_minusMET]
)
return output
def process(self, events):
output = self.accumulator.identity()
# 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()
output['totalEvents']['all'] += len(events)
output['skimmedEvents']['all'] += len(ev)
## Muons
muon = Collections(ev, "Muon", "tight").get()
vetomuon = Collections(ev, "Muon", "veto").get()
dimuon = choose(muon, 2)
SSmuon = ak.any((dimuon['0'].charge * dimuon['1'].charge) > 0, axis=1)
OSmuon = 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", "tight").get()
vetoelectron = Collections(ev, "Electron", "veto").get()
dielectron = choose(electron, 2)
SSelectron = ak.any(
(dielectron['0'].charge * dielectron['1'].charge) > 0, axis=1)
OSelectron = 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
lepton = ak.concatenate([muon, electron], axis=1)
dilepton = cross(muon, electron)
SSlepton = ak.any((dilepton['0'].charge * dilepton['1'].charge) > 0,
axis=1)
OSlepton = ak.any((dilepton['0'].charge * dilepton['1'].charge) < 0,
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]
## Jets
jet = getJets(ev, minPt=25, maxEta=4.7)
jet = jet[(jet.pt > 25) & (jet.jetId > 1)]
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
## event selectors
filters = getFilters(ev, year=self.year, dataset=dataset)
triggers = getTriggers(ev, year=self.year, dataset=dataset)
dilep = ((ak.num(electron) == 1) & (ak.num(muon) == 1))
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(vetoelectron) + ak.num(vetomuon)) == 2)
# define the weight
weight = Weights(len(ev))
if not dataset == 'MuonEG':
# lumi weight
weight.add("weight", ev.weight * cfg['lumi'][self.year])
## 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))
selection = PackedSelection()
selection.add('lepveto', lepveto)
selection.add('dilep', dilep)
selection.add('trigger', (triggers))
selection.add('filter', (filters))
selection.add('p_T(lep0)>25', lep0pt)
selection.add('p_T(lep1)>20', lep1pt)
selection.add('OS', OSlepton)
selection.add('N_jet>2', (ak.num(jet) >= 3))
selection.add('MET>30', (ev.MET.pt > 30))
os_reqs = [
'lepveto', 'dilep', 'trigger', 'filter', 'p_T(lep0)>25',
'p_T(lep1)>20', 'OS'
]
bl_reqs = os_reqs + ['N_jet>2', 'MET>30']
os_reqs_d = {sel: True for sel in os_reqs}
os_selection = selection.require(**os_reqs_d)
bl_reqs_d = {sel: True for sel in bl_reqs}
BL = selection.require(**bl_reqs_d)
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))
# first, make a few super inclusive plots
output['PV_npvs'].fill(dataset=dataset,
multiplicity=ev.PV[os_selection].npvs,
weight=weight.weight()[os_selection])
output['PV_npvsGood'].fill(dataset=dataset,
multiplicity=ev.PV[os_selection].npvsGood,
weight=weight.weight()[os_selection])
output['N_jet'].fill(dataset=dataset,
multiplicity=ak.num(jet)[os_selection],
weight=weight.weight()[os_selection])
output['MET'].fill(dataset=dataset,
pt=ev.MET[os_selection].pt,
phi=ev.MET[os_selection].phi,
weight=weight.weight()[os_selection])
output['j1'].fill(dataset=dataset,
pt=ak.flatten(jet.pt[:, 0:1][BL]),
eta=ak.flatten(jet.eta[:, 0:1][BL]),
phi=ak.flatten(jet.phi[:, 0:1][BL]),
weight=weight.weight()[BL])
# Now, take care of systematic unceratinties
if not dataset == 'MuonEG':
alljets = getJets(ev, minPt=0, maxEta=4.7)
alljets = alljets[(alljets.jetId > 1)]
for var in self.variations:
# get the collections that change with the variations
jet_var = getPtEtaPhi(alljets, pt_var=var)
jet_var = jet_var[(jet_var.pt > 25)]
jet_var = jet_var[~match(
jet_var, muon,
deltaRCut=0.4)] # remove jets that overlap with muons
jet_var = jet_var[~match(
jet_var, electron,
deltaRCut=0.4)] # remove jets that overlap with electrons
# get the modified selection -> more difficult
selection.add(
'N_jet>2_' + var, (ak.num(jet_var.pt) > 3)
) # something needs to be improved with getPtEtaPhi function
selection.add('MET>30_' + var, (getattr(ev.MET, var) > 30))
bl_reqs = os_reqs + ['N_jet>2_' + var, 'MET>30_' + var]
bl_reqs_d = {sel: True for sel in bl_reqs}
BL = selection.require(**bl_reqs_d)
# the OS selection remains unchanged
output['N_jet_' + var].fill(
dataset=dataset,
multiplicity=ak.num(jet_var)[os_selection],
weight=weight.weight()[os_selection])
# We don't need to redo all plots with variations. E.g., just add uncertainties to the jet plots.
output['j1_' + var].fill(dataset=dataset,
pt=ak.flatten(jet_var.pt[:, 0:1][BL]),
eta=ak.flatten(jet_var.eta[:,
0:1][BL]),
phi=ak.flatten(jet_var.phi[:,
0:1][BL]),
weight=weight.weight()[BL])
return output
def process(self, events):
output = self.accumulator.identity()
# 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()
output['totalEvents']['all'] += len(events)
output['skimmedEvents']['all'] += len(ev)
## Muons
muon = Collections(ev, "Muon", "tightTTH").get()
vetomuon = Collections(ev, "Muon", "vetoTTH").get()
dimuon = choose(muon, 2)
SSmuon = ak.any((dimuon['0'].charge * dimuon['1'].charge) > 0, axis=1)
OSmuon = 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", "tightTTH").get()
vetoelectron = Collections(ev, "Electron", "vetoTTH").get()
dielectron = choose(electron, 2)
SSelectron = ak.any(
(dielectron['0'].charge * dielectron['1'].charge) > 0, axis=1)
OSelectron = 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
lepton = ak.concatenate([muon, electron], axis=1)
dilepton = cross(muon, electron)
SSlepton = ak.any((dilepton['0'].charge * dilepton['1'].charge) > 0,
axis=1)
OSlepton = ak.any((dilepton['0'].charge * dilepton['1'].charge) < 0,
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]
## 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)
## forward jets
high_p_fwd = fwd[ak.singletons(ak.argmax(
fwd.p, axis=1))] # highest momentum spectator
high_pt_fwd = fwd[ak.singletons(ak.argmax(
fwd.pt_nom, axis=1))] # highest transverse momentum spectator
high_eta_fwd = fwd[ak.singletons(ak.argmax(abs(
fwd.eta), axis=1))] # most forward spectator
## Get the two leading b-jets in terms of btag score
high_score_btag = central[ak.argsort(central.btagDeepFlavB)][:, :2]
jf = cross(high_p_fwd, jet)
mjf = (jf['0'] + jf['1']).mass
deltaEta = abs(high_p_fwd.eta -
jf[ak.singletons(ak.argmax(mjf, axis=1))]['1'].eta)
deltaEtaMax = ak.max(deltaEta, axis=1)
mjf_max = ak.max(mjf, axis=1)
jj = choose(jet, 2)
mjj_max = ak.max((jj['0'] + jj['1']).mass, axis=1)
## 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)
ht_central = ak.sum(central.pt, axis=1)
## event selectors
filters = getFilters(ev, year=self.year, dataset=dataset)
triggers = getTriggers(ev, year=self.year, dataset=dataset)
dilep = ((ak.num(electron) == 1) & (ak.num(muon) == 1))
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(vetoelectron) + ak.num(vetomuon)) == 2)
# define the weight
weight = Weights(len(ev))
if not dataset == 'MuonEG':
# lumi weight
weight.add("weight", ev.weight * cfg['lumi'][self.year])
# 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))
selection = PackedSelection()
selection.add('lepveto', lepveto)
selection.add('dilep', dilep)
selection.add('trigger', (triggers))
selection.add('filter', (filters))
selection.add('p_T(lep0)>25', lep0pt)
selection.add('p_T(lep1)>20', lep1pt)
selection.add('OS', OSlepton)
selection.add('N_btag=2', (ak.num(btag) == 2))
selection.add('N_jet>2', (ak.num(jet) >= 3))
selection.add('N_central>1', (ak.num(central) >= 2))
selection.add('N_fwd>0', (ak.num(fwd) >= 1))
selection.add('MET>30', (ev.MET.pt > 30))
os_reqs = [
'lepveto', 'dilep', 'trigger', 'filter', 'p_T(lep0)>25',
'p_T(lep1)>20', 'OS'
]
bl_reqs = os_reqs + [
'N_btag=2', 'N_jet>2', 'N_central>1', 'N_fwd>0', 'MET>30'
]
os_reqs_d = {sel: True for sel in os_reqs}
os_selection = selection.require(**os_reqs_d)
bl_reqs_d = {sel: True for sel in bl_reqs}
BL = selection.require(**bl_reqs_d)
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))
# first, make a few super inclusive plots
output['PV_npvs'].fill(dataset=dataset,
multiplicity=ev.PV[os_selection].npvs,
weight=weight.weight()[os_selection])
output['PV_npvsGood'].fill(dataset=dataset,
multiplicity=ev.PV[os_selection].npvsGood,
weight=weight.weight()[os_selection])
output['N_jet'].fill(dataset=dataset,
multiplicity=ak.num(jet)[os_selection],
weight=weight.weight()[os_selection])
output['N_b'].fill(dataset=dataset,
multiplicity=ak.num(btag)[os_selection],
weight=weight.weight()[os_selection])
output['N_central'].fill(dataset=dataset,
multiplicity=ak.num(central)[os_selection],
weight=weight.weight()[os_selection])
output['N_ele'].fill(dataset=dataset,
multiplicity=ak.num(electron)[os_selection],
weight=weight.weight()[os_selection])
output['N_mu'].fill(dataset=dataset,
multiplicity=ak.num(electron)[os_selection],
weight=weight.weight()[os_selection])
output['N_fwd'].fill(dataset=dataset,
multiplicity=ak.num(fwd)[os_selection],
weight=weight.weight()[os_selection])
output['MET'].fill(dataset=dataset,
pt=ev.MET[os_selection].pt,
phi=ev.MET[os_selection].phi,
weight=weight.weight()[os_selection])
output['electron'].fill(dataset=dataset,
pt=ak.to_numpy(ak.flatten(electron[BL].pt)),
eta=ak.to_numpy(ak.flatten(electron[BL].eta)),
phi=ak.to_numpy(ak.flatten(electron[BL].phi)),
weight=weight.weight()[BL])
output['muon'].fill(dataset=dataset,
pt=ak.to_numpy(ak.flatten(muon[BL].pt)),
eta=ak.to_numpy(ak.flatten(muon[BL].eta)),
phi=ak.to_numpy(ak.flatten(muon[BL].phi)),
weight=weight.weight()[BL])
output['lead_lep'].fill(
dataset=dataset,
pt=ak.to_numpy(ak.flatten(leading_lepton[BL].pt)),
eta=ak.to_numpy(ak.flatten(leading_lepton[BL].eta)),
phi=ak.to_numpy(ak.flatten(leading_lepton[BL].phi)),
weight=weight.weight()[BL])
output['trail_lep'].fill(
dataset=dataset,
pt=ak.to_numpy(ak.flatten(trailing_lepton[BL].pt)),
eta=ak.to_numpy(ak.flatten(trailing_lepton[BL].eta)),
phi=ak.to_numpy(ak.flatten(trailing_lepton[BL].phi)),
weight=weight.weight()[BL])
output['fwd_jet'].fill(dataset=dataset,
pt=ak.flatten(high_p_fwd[BL].pt_nom),
eta=ak.flatten(high_p_fwd[BL].eta),
phi=ak.flatten(high_p_fwd[BL].phi),
weight=weight.weight()[BL])
output['b1'].fill(dataset=dataset,
pt=ak.flatten(high_score_btag[:, 0:1][BL].pt_nom),
eta=ak.flatten(high_score_btag[:, 0:1][BL].eta),
phi=ak.flatten(high_score_btag[:, 0:1][BL].phi),
weight=weight.weight()[BL])
output['b2'].fill(dataset=dataset,
pt=ak.flatten(high_score_btag[:, 1:2][BL].pt_nom),
eta=ak.flatten(high_score_btag[:, 1:2][BL].eta),
phi=ak.flatten(high_score_btag[:, 1:2][BL].phi),
weight=weight.weight()[BL])
output['j1'].fill(dataset=dataset,
pt=ak.flatten(jet.pt_nom[:, 0:1][BL]),
eta=ak.flatten(jet.eta[:, 0:1][BL]),
phi=ak.flatten(jet.phi[:, 0:1][BL]),
weight=weight.weight()[BL])
output['j2'].fill(dataset=dataset,
pt=ak.flatten(jet[:, 1:2][BL].pt_nom),
eta=ak.flatten(jet[:, 1:2][BL].eta),
phi=ak.flatten(jet[:, 1:2][BL].phi),
weight=weight.weight()[BL])
output['j3'].fill(dataset=dataset,
pt=ak.flatten(jet[:, 2:3][BL].pt_nom),
eta=ak.flatten(jet[:, 2:3][BL].eta),
phi=ak.flatten(jet[:, 2:3][BL].phi),
weight=weight.weight()[BL])
# Now, take care of systematic unceratinties
if not dataset == 'MuonEG':
alljets = getJets(ev, minPt=0, maxEta=4.7)
alljets = alljets[(alljets.jetId > 1)]
for var in self.variations:
# get the collections that change with the variations
jet = getPtEtaPhi(alljets, pt_var=var)
jet = jet[(jet.pt > 25)]
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)
## forward jets
high_p_fwd = fwd[ak.singletons(ak.argmax(
fwd.p, axis=1))] # highest momentum spectator
high_pt_fwd = fwd[ak.singletons(ak.argmax(
fwd.pt, axis=1))] # highest transverse momentum spectator
high_eta_fwd = fwd[ak.singletons(
ak.argmax(abs(fwd.eta), axis=1))] # most forward spectator
## Get the two leading b-jets in terms of btag score
high_score_btag = central[ak.argsort(
central.btagDeepFlavB)][:, :2]
# get the modified selection -> more difficult
selection.add('N_jet>2_' + var,
(ak.num(jet.pt) >= 3)) # stupid bug here...
selection.add('N_btag=2_' + var, (ak.num(btag) == 2))
selection.add('N_central>1_' + var, (ak.num(central) >= 2))
selection.add('N_fwd>0_' + var, (ak.num(fwd) >= 1))
selection.add('MET>30_' + var, (getattr(ev.MET, var) > 30))
## Don't change the selection for now...
bl_reqs = os_reqs + [
'N_jet>2_' + var, 'MET>30_' + var, 'N_btag=2_' + var,
'N_central>1_' + var, 'N_fwd>0_' + var
]
bl_reqs_d = {sel: True for sel in bl_reqs}
BL = selection.require(**bl_reqs_d)
# the OS selection remains unchanged
output['N_jet_' + var].fill(
dataset=dataset,
multiplicity=ak.num(jet)[os_selection],
weight=weight.weight()[os_selection])
output['N_fwd_' + var].fill(
dataset=dataset,
multiplicity=ak.num(fwd)[os_selection],
weight=weight.weight()[os_selection])
output['N_b_' + var].fill(
dataset=dataset,
multiplicity=ak.num(btag)[os_selection],
weight=weight.weight()[os_selection])
output['N_central_' + var].fill(
dataset=dataset,
multiplicity=ak.num(central)[os_selection],
weight=weight.weight()[os_selection])
# We don't need to redo all plots with variations. E.g., just add uncertainties to the jet plots.
output['j1_' + var].fill(dataset=dataset,
pt=ak.flatten(jet.pt[:, 0:1][BL]),
eta=ak.flatten(jet.eta[:, 0:1][BL]),
phi=ak.flatten(jet.phi[:, 0:1][BL]),
weight=weight.weight()[BL])
output['b1_' + var].fill(
dataset=dataset,
pt=ak.flatten(high_score_btag[:, 0:1].pt[:, 0:1][BL]),
eta=ak.flatten(high_score_btag[:, 0:1].eta[:, 0:1][BL]),
phi=ak.flatten(high_score_btag[:, 0:1].phi[:, 0:1][BL]),
weight=weight.weight()[BL])
output['fwd_jet_' + var].fill(
dataset=dataset,
pt=ak.flatten(high_p_fwd[BL].pt),
eta=ak.flatten(high_p_fwd[BL].eta),
phi=ak.flatten(high_p_fwd[BL].phi),
weight=weight.weight()[BL])
output['MET_' + var].fill(dataset=dataset,
pt=getattr(ev.MET,
var)[os_selection],
phi=ev.MET[os_selection].phi,
weight=weight.weight()[os_selection])
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
def test_weights():
from coffea.analysis_tools import Weights
counts, test_eta, test_pt = dummy_jagged_eta_pt()
scale_central = np.random.normal(loc=1.0, scale=0.01, size=counts.size)
scale_up = scale_central * 1.10
scale_down = scale_central * 0.95
scale_up_shift = 0.10 * scale_central
scale_down_shift = 0.05 * scale_central
weight = Weights(counts.size)
weight.add("test", scale_central, weightUp=scale_up, weightDown=scale_down)
weight.add(
"testShift",
scale_central,
weightUp=scale_up_shift,
weightDown=scale_down_shift,
shift=True,
)
var_names = weight.variations
expected_names = ["testShiftUp", "testShiftDown", "testUp", "testDown"]
for name in expected_names:
assert name in var_names
test_central = weight.weight()
exp_weight = scale_central * scale_central
assert np.all(np.abs(test_central - (exp_weight)) < 1e-6)
test_up = weight.weight("testUp")
exp_up = scale_central * scale_central * 1.10
assert np.all(np.abs(test_up - (exp_up)) < 1e-6)
test_down = weight.weight("testDown")
exp_down = scale_central * scale_central * 0.95
assert np.all(np.abs(test_down - (exp_down)) < 1e-6)
test_shift_up = weight.weight("testUp")
assert np.all(np.abs(test_shift_up - (exp_up)) < 1e-6)
test_shift_down = weight.weight("testDown")
assert np.all(np.abs(test_shift_down - (exp_down)) < 1e-6)
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 process(self, events):
output = self.accumulator.identity()
# 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()
output['totalEvents']['all'] += len(events)
output['skimmedEvents']['all'] += len(ev)
if not re.search(re.compile('MuonEG|DoubleMuon|DoubleEG|EGamma'), dataset):
## Generated leptons
gen_lep = ev.GenL
leading_gen_lep = gen_lep[ak.singletons(ak.argmax(gen_lep.pt, axis=1))]
trailing_gen_lep = gen_lep[ak.singletons(ak.argmin(gen_lep.pt, axis=1))]
## Muons
muon = Collections(ev, "Muon", "tightSSTTH").get()
vetomuon = Collections(ev, "Muon", "vetoTTH").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", "tightSSTTH").get()
vetoelectron = Collections(ev, "Electron", "vetoTTH").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)
lepton_pdgId_pt_ordered = ak.fill_none(ak.pad_none(lepton[ak.argsort(lepton.pt, ascending=False)].pdgId, 2, clip=True), 0)
if not re.search(re.compile('MuonEG|DoubleMuon|DoubleEG|EGamma'), dataset):
n_nonprompt = getNonPromptFromFlavour(electron) + getNonPromptFromFlavour(muon)
n_chargeflip = getChargeFlips(electron, ev.GenPart) + getChargeFlips(muon, ev.GenPart)
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)
## Tau and other stuff
tau = getTaus(ev)
track = getIsoTracks(ev)
## 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)
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)
## forward jets
j_fwd = fwd[ak.singletons(ak.argmax(fwd.p, axis=1))] # highest momentum spectator
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 = abs(j_fwd2.eta - j_fwd.eta)
## 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)
# define the weight
weight = Weights( len(ev) )
if not re.search(re.compile('MuonEG|DoubleMuon|DoubleEG|EGamma'), dataset):
# lumi weight
weight.add("weight", ev.weight*cfg['lumi'][self.year])
#weight.add("weight", ev.genWeight*cfg['lumi'][self.year]*mult)
# 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)
sel = Selection(
dataset = dataset,
events = ev,
year = self.year,
ele = electron,
ele_veto = vetoelectron,
mu = muon,
mu_veto = vetomuon,
jet_all = jet,
jet_central = central,
jet_btag = btag,
jet_fwd = fwd,
met = ev.MET,
)
BL = sel.dilep_baseline(cutflow=cutflow, SS=True)
weight_BL = weight.weight()[BL]
if True:
# define the inputs to the NN
# this is super stupid. there must be a better way.
NN_inputs = np.stack([
ak.to_numpy(ak.num(jet[BL])),
ak.to_numpy(ak.num(tau[BL])),
ak.to_numpy(ak.num(track[BL])),
ak.to_numpy(st[BL]),
ak.to_numpy(ev.MET[BL].pt),
ak.to_numpy(ak.max(mjf[BL], axis=1)),
ak.to_numpy(pad_and_flatten(delta_eta[BL])),
ak.to_numpy(pad_and_flatten(leading_lepton[BL].pt)),
ak.to_numpy(pad_and_flatten(leading_lepton[BL].eta)),
ak.to_numpy(pad_and_flatten(trailing_lepton[BL].pt)),
ak.to_numpy(pad_and_flatten(trailing_lepton[BL].eta)),
ak.to_numpy(pad_and_flatten(dilepton_mass[BL])),
ak.to_numpy(pad_and_flatten(dilepton_pt[BL])),
ak.to_numpy(pad_and_flatten(j_fwd[BL].pt)),
ak.to_numpy(pad_and_flatten(j_fwd[BL].p)),
ak.to_numpy(pad_and_flatten(j_fwd[BL].eta)),
ak.to_numpy(pad_and_flatten(jet[:, 0:1][BL].pt)),
ak.to_numpy(pad_and_flatten(jet[:, 1:2][BL].pt)),
ak.to_numpy(pad_and_flatten(jet[:, 0:1][BL].eta)),
ak.to_numpy(pad_and_flatten(jet[:, 1:2][BL].eta)),
ak.to_numpy(pad_and_flatten(high_score_btag[:, 0:1][BL].pt)),
ak.to_numpy(pad_and_flatten(high_score_btag[:, 1:2][BL].pt)),
ak.to_numpy(pad_and_flatten(high_score_btag[:, 0:1][BL].eta)),
ak.to_numpy(pad_and_flatten(high_score_btag[:, 1:2][BL].eta)),
ak.to_numpy(min_bl_dR[BL]),
ak.to_numpy(min_mt_lep_met[BL]),
])
NN_inputs = np.moveaxis(NN_inputs, 0, 1)
model, scaler = load_onnx_model('v8')
try:
NN_inputs_scaled = scaler.transform(NN_inputs)
NN_pred = predict_onnx(model, NN_inputs_scaled)
best_score = np.argmax(NN_pred, axis=1)
except ValueError:
#print ("Empty NN_inputs")
NN_pred = np.array([])
best_score = np.array([])
NN_inputs_scaled = NN_inputs
#k.clear_session()
output['node'].fill(dataset=dataset, multiplicity=best_score, weight=weight_BL)
output['node0_score_incl'].fill(dataset=dataset, score=NN_pred[:,0] if np.shape(NN_pred)[0]>0 else np.array([]), weight=weight_BL)
output['node0_score'].fill(dataset=dataset, score=NN_pred[best_score==0][:,0] if np.shape(NN_pred)[0]>0 else np.array([]), weight=weight_BL[best_score==0])
output['node1_score'].fill(dataset=dataset, score=NN_pred[best_score==1][:,1] if np.shape(NN_pred)[0]>0 else np.array([]), weight=weight_BL[best_score==1])
output['node2_score'].fill(dataset=dataset, score=NN_pred[best_score==2][:,2] if np.shape(NN_pred)[0]>0 else np.array([]), weight=weight_BL[best_score==2])
output['node3_score'].fill(dataset=dataset, score=NN_pred[best_score==3][:,3] if np.shape(NN_pred)[0]>0 else np.array([]), weight=weight_BL[best_score==3])
output['node4_score'].fill(dataset=dataset, score=NN_pred[best_score==4][:,4] if np.shape(NN_pred)[0]>0 else np.array([]), weight=weight_BL[best_score==4])
SR_sel_pp = ((best_score==0) & ak.flatten((leading_lepton[BL].pdgId<0)))
SR_sel_mm = ((best_score==0) & ak.flatten((leading_lepton[BL].pdgId>0)))
leading_lepton_BL = leading_lepton[BL]
output['lead_lep_SR_pp'].fill(
dataset = dataset,
pt = ak.to_numpy(ak.flatten(leading_lepton_BL[SR_sel_pp].pt)),
weight = weight_BL[SR_sel_pp]
)
output['lead_lep_SR_mm'].fill(
dataset = dataset,
pt = ak.to_numpy(ak.flatten(leading_lepton_BL[SR_sel_mm].pt)),
weight = weight_BL[SR_sel_mm]
)
del model
del scaler
del NN_inputs, NN_inputs_scaled, NN_pred
# first, make a few super inclusive plots
output['PV_npvs'].fill(dataset=dataset, multiplicity=ev.PV[BL].npvs, weight=weight_BL)
output['PV_npvsGood'].fill(dataset=dataset, multiplicity=ev.PV[BL].npvsGood, weight=weight_BL)
output['N_jet'].fill(dataset=dataset, multiplicity=ak.num(jet)[BL], weight=weight_BL)
output['N_b'].fill(dataset=dataset, multiplicity=ak.num(btag)[BL], weight=weight_BL)
output['N_central'].fill(dataset=dataset, multiplicity=ak.num(central)[BL], weight=weight_BL)
output['N_ele'].fill(dataset=dataset, multiplicity=ak.num(electron)[BL], weight=weight_BL)
output['N_mu'].fill(dataset=dataset, multiplicity=ak.num(electron)[BL], weight=weight_BL)
output['N_fwd'].fill(dataset=dataset, multiplicity=ak.num(fwd)[BL], weight=weight_BL)
output['ST'].fill(dataset=dataset, pt=st[BL], weight=weight_BL)
output['HT'].fill(dataset=dataset, pt=ht[BL], weight=weight_BL)
if not re.search(re.compile('MuonEG|DoubleMuon|DoubleEG|EGamma'), dataset):
output['nLepFromTop'].fill(dataset=dataset, multiplicity=ev[BL].nLepFromTop, weight=weight_BL)
output['nLepFromTau'].fill(dataset=dataset, multiplicity=ev.nLepFromTau[BL], weight=weight_BL)
output['nLepFromZ'].fill(dataset=dataset, multiplicity=ev.nLepFromZ[BL], weight=weight_BL)
output['nLepFromW'].fill(dataset=dataset, multiplicity=ev.nLepFromW[BL], weight=weight_BL)
output['nGenTau'].fill(dataset=dataset, multiplicity=ev.nGenTau[BL], weight=weight_BL)
output['nGenL'].fill(dataset=dataset, multiplicity=ak.num(ev.GenL[BL], axis=1), weight=weight_BL)
output['chargeFlip_vs_nonprompt'].fill(dataset=dataset, n1=n_chargeflip[BL], n2=n_nonprompt[BL], n_ele=ak.num(electron)[BL], weight=weight_BL)
output['MET'].fill(
dataset = dataset,
pt = ev.MET[BL].pt,
phi = ev.MET[BL].phi,
weight = weight_BL
)
if not re.search(re.compile('MuonEG|DoubleMuon|DoubleEG|EGamma'), dataset):
output['lead_gen_lep'].fill(
dataset = dataset,
pt = ak.to_numpy(ak.flatten(leading_gen_lep[BL].pt)),
eta = ak.to_numpy(ak.flatten(leading_gen_lep[BL].eta)),
phi = ak.to_numpy(ak.flatten(leading_gen_lep[BL].phi)),
weight = weight_BL
)
output['trail_gen_lep'].fill(
dataset = dataset,
pt = ak.to_numpy(ak.flatten(trailing_gen_lep[BL].pt)),
eta = ak.to_numpy(ak.flatten(trailing_gen_lep[BL].eta)),
phi = ak.to_numpy(ak.flatten(trailing_gen_lep[BL].phi)),
weight = weight_BL
)
output['lead_lep'].fill(
dataset = dataset,
pt = ak.to_numpy(ak.flatten(leading_lepton[BL].pt)),
eta = ak.to_numpy(ak.flatten(leading_lepton[BL].eta)),
phi = ak.to_numpy(ak.flatten(leading_lepton[BL].phi)),
weight = weight_BL
)
output['trail_lep'].fill(
dataset = dataset,
pt = ak.to_numpy(ak.flatten(trailing_lepton[BL].pt)),
eta = ak.to_numpy(ak.flatten(trailing_lepton[BL].eta)),
phi = ak.to_numpy(ak.flatten(trailing_lepton[BL].phi)),
weight = weight_BL
)
output['j1'].fill(
dataset = dataset,
pt = ak.flatten(jet.pt_nom[:, 0:1][BL]),
eta = ak.flatten(jet.eta[:, 0:1][BL]),
phi = ak.flatten(jet.phi[:, 0:1][BL]),
weight = weight_BL
)
output['j2'].fill(
dataset = dataset,
pt = ak.flatten(jet[:, 1:2][BL].pt_nom),
eta = ak.flatten(jet[:, 1:2][BL].eta),
phi = ak.flatten(jet[:, 1:2][BL].phi),
weight = weight_BL
)
output['j3'].fill(
dataset = dataset,
pt = ak.flatten(jet[:, 2:3][BL].pt_nom),
eta = ak.flatten(jet[:, 2:3][BL].eta),
phi = ak.flatten(jet[:, 2:3][BL].phi),
weight = weight_BL
)
output['fwd_jet'].fill(
dataset = dataset,
pt = ak.flatten(j_fwd[BL].pt),
eta = ak.flatten(j_fwd[BL].eta),
phi = ak.flatten(j_fwd[BL].phi),
weight = weight_BL
)
output['high_p_fwd_p'].fill(dataset=dataset, p = ak.flatten(j_fwd[BL].p), weight = weight_BL)
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) >= 2
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", "tight").get()
electron = electron[(electron.pt > 20) & (abs(electron.eta) < 2.4)]
electron = electron[((electron.genPartIdx >= 0) &
(np.abs(electron.matched_gen.pdgId) == 11)
)] #from here on all leptons are gen-matched
##Muons
muon = Collections(ev, "Muon", "tight").get()
muon = muon[(muon.pt > 20) & (abs(muon.eta) < 2.4)]
muon = muon[((muon.genPartIdx >= 0) &
(np.abs(muon.matched_gen.pdgId) == 13))]
##Leptons
lepton = ak.concatenate([muon, electron], axis=1)
SSlepton = (ak.sum(lepton.charge, axis=1) != 0) & (ak.num(lepton) == 2)
OSlepton = (ak.sum(lepton.charge, axis=1) == 0) & (ak.num(lepton) == 2)
leading_lepton_idx = ak.singletons(ak.argmax(lepton.pt, axis=1))
leading_lepton = lepton[leading_lepton_idx]
#jets
jet = getJets(ev, minPt=40, maxEta=2.4, pt_var='pt')
jet = jet[ak.argsort(
jet.pt, 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)]
## MET -> can switch to puppi MET
met_pt = ev.MET.pt
met_phi = ev.MET.phi
# setting up the various weights
weight = Weights(len(ev))
weight2 = Weights(len(ev))
if not dataset == 'MuonEG':
# generator weight
weight.add("weight", ev.genWeight)
weight2.add("weight", ev.genWeight)
weight2.add("charge flip",
self.charge_flip_ratio.flip_weight(electron))
#selections
filters = getFilters(ev, year=self.year, dataset=dataset)
ss = (SSlepton)
os = (OSlepton)
jet_all = (ak.num(jet) >= 2)
selection = PackedSelection()
selection.add('filter', (filters))
selection.add('ss', ss)
selection.add('os', os)
selection.add('jet', jet_all)
bl_reqs = ['filter', 'jet']
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)
#outputs
output['N_jet'].fill(dataset=dataset,
multiplicity=ak.num(jet)[baseline],
weight=weight.weight()[baseline])
output['N_ele'].fill(dataset=dataset,
multiplicity=ak.num(lepton)[ss_sel],
weight=weight.weight()[ss_sel])
output['N_ele2'].fill(dataset=dataset,
multiplicity=ak.num(lepton)[os_sel],
weight=weight2.weight()[os_sel])
output["electron"].fill(
dataset=dataset,
pt=ak.to_numpy(ak.flatten(leading_lepton[ss_sel].pt)),
eta=abs(ak.to_numpy(ak.flatten(leading_lepton[ss_sel].eta))),
phi=ak.to_numpy(ak.flatten(leading_lepton[ss_sel].phi)),
weight=weight.weight()[ss_sel])
output["electron2"].fill(
dataset=dataset,
pt=ak.to_numpy(ak.flatten(leading_lepton[os_sel].pt)),
eta=abs(ak.to_numpy(ak.flatten(leading_lepton[os_sel].eta))),
phi=ak.to_numpy(ak.flatten(leading_lepton[os_sel].phi)),
weight=weight2.weight()[os_sel])
return output
def process(self, events):
output = self.accumulator.identity()
# 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()
output['totalEvents']['all'] += len(events)
output['skimmedEvents']['all'] += len(ev)
## Generated leptons
'''gen_lep = ev.GenL
leading_gen_lep = gen_lep[ak.singletons(ak.argmax(gen_lep.pt, axis=1))]
trailing_gen_lep = gen_lep[ak.singletons(ak.argmin(gen_lep.pt, axis=1))]'''
## Muons
muon = Collections(ev, "Muon", "tightTTH").get()
vetomuon = Collections(ev, "Muon", "vetoTTH").get()
leading_muon_idx = ak.singletons(ak.argmax(muon.pt, axis=1))
leading_muon = muon[leading_muon_idx]
## Electrons
electron = Collections(ev, "Electron", "tightTTH").get()
vetoelectron = Collections(ev, "Electron", "vetoTTH").get()
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)
dimuon = choose(muon, 2)
OS_dimuon = dimuon[(dimuon['0'].charge * dimuon['1'].charge < 0)]
dielectron = choose(electron, 2)
OS_dielectron = dielectron[(
dielectron['0'].charge * dielectron['1'].charge < 0)]
OS_dimuon_bestZmumu = OS_dimuon[ak.singletons(
ak.argmin(abs(OS_dimuon.mass - 91.2), axis=1))]
OS_dielectron_bestZee = OS_dielectron[ak.singletons(
ak.argmin(abs(OS_dielectron.mass - 91.2), axis=1))]
OS_dilepton_mass = ak.fill_none(
ak.pad_none(ak.concatenate(
[OS_dimuon_bestZmumu.mass, OS_dielectron_bestZee.mass],
axis=1),
1,
clip=True), -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]
## 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)
## forward jets
j_fwd = fwd[ak.singletons(ak.argmax(
fwd.p, axis=1))] # highest momentum spectator
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 = abs(j_fwd2.eta - j_fwd.eta)
## 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)
# define the weight
weight = Weights(len(ev))
if not re.search(re.compile('MuonEG|DoubleMuon|DoubleEG|EGamma'),
dataset):
# lumi weight
weight.add("weight", ev.weight * cfg['lumi'][self.year])
# 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)
sel = Selection(
dataset=dataset,
events=ev,
year=self.year,
ele=electron,
ele_veto=vetoelectron,
mu=muon,
mu_veto=vetomuon,
jet_all=jet,
jet_central=central,
jet_btag=btag,
jet_fwd=fwd,
met=ev.MET,
)
BL = sel.trilep_baseline(cutflow=cutflow)
# first, make a few super inclusive plots
output['ST'].fill(dataset=dataset,
ht=st[BL],
weight=weight.weight()[BL])
output['PV_npvs'].fill(dataset=dataset,
multiplicity=ev.PV[BL].npvs,
weight=weight.weight()[BL])
output['PV_npvsGood'].fill(dataset=dataset,
multiplicity=ev.PV[BL].npvsGood,
weight=weight.weight()[BL])
output['N_jet'].fill(dataset=dataset,
multiplicity=ak.num(jet)[BL],
weight=weight.weight()[BL])
output['N_b'].fill(dataset=dataset,
multiplicity=ak.num(btag)[BL],
weight=weight.weight()[BL])
output['N_central'].fill(dataset=dataset,
multiplicity=ak.num(central)[BL],
weight=weight.weight()[BL])
output['N_ele'].fill(dataset=dataset,
multiplicity=ak.num(vetoelectron)[BL],
weight=weight.weight()[BL])
output['N_mu'].fill(dataset=dataset,
multiplicity=ak.num(vetomuon)[BL],
weight=weight.weight()[BL])
output['N_fwd'].fill(dataset=dataset,
multiplicity=ak.num(fwd)[BL],
weight=weight.weight()[BL])
'''output['nLepFromTop'].fill(dataset=dataset, multiplicity=ev[BL].nLepFromTop, weight=weight.weight()[BL])
output['nLepFromTau'].fill(dataset=dataset, multiplicity=ev.nLepFromTau[BL], weight=weight.weight()[BL])
output['nLepFromZ'].fill(dataset=dataset, multiplicity=ev.nLepFromZ[BL], weight=weight.weight()[BL])
output['nLepFromW'].fill(dataset=dataset, multiplicity=ev.nLepFromW[BL], weight=weight.weight()[BL])
output['nGenTau'].fill(dataset=dataset, multiplicity=ev.nGenTau[BL], weight=weight.weight()[BL])
output['nGenL'].fill(dataset=dataset, multiplicity=ak.num(ev.GenL[BL], axis=1), weight=weight.weight()[BL])'''
# make a plot of the dilepton mass, but without applying the cut on the dilepton mass itself (N-1 plot)
output['dilep_mass'].fill(
dataset=dataset,
mass=ak.flatten(
OS_dilepton_mass[sel.trilep_baseline(omit=['offZ'])]),
weight=weight.weight()[sel.trilep_baseline(omit=['offZ'])])
output['MET'].fill(dataset=dataset,
pt=ev.MET[BL].pt,
phi=ev.MET[BL].phi,
weight=weight.weight()[BL])
'''output['lead_gen_lep'].fill(
dataset = dataset,
pt = ak.to_numpy(ak.flatten(leading_gen_lep[BL].pt)),
eta = ak.to_numpy(ak.flatten(leading_gen_lep[BL].eta)),
phi = ak.to_numpy(ak.flatten(leading_gen_lep[BL].phi)),
weight = weight.weight()[BL]
)
output['trail_gen_lep'].fill(
dataset = dataset,
pt = ak.to_numpy(ak.flatten(trailing_gen_lep[BL].pt)),
eta = ak.to_numpy(ak.flatten(trailing_gen_lep[BL].eta)),
phi = ak.to_numpy(ak.flatten(trailing_gen_lep[BL].phi)),
weight = weight.weight()[BL]
)'''
output['lead_lep'].fill(
dataset=dataset,
pt=ak.to_numpy(ak.flatten(leading_lepton[BL].pt)),
eta=ak.to_numpy(ak.flatten(leading_lepton[BL].eta)),
phi=ak.to_numpy(ak.flatten(leading_lepton[BL].phi)),
weight=weight.weight()[BL])
output['trail_lep'].fill(
dataset=dataset,
pt=ak.to_numpy(ak.flatten(trailing_lepton[BL].pt)),
eta=ak.to_numpy(ak.flatten(trailing_lepton[BL].eta)),
phi=ak.to_numpy(ak.flatten(trailing_lepton[BL].phi)),
weight=weight.weight()[BL])
output['j1'].fill(dataset=dataset,
pt=ak.flatten(jet.pt_nom[:, 0:1][BL]),
eta=ak.flatten(jet.eta[:, 0:1][BL]),
phi=ak.flatten(jet.phi[:, 0:1][BL]),
weight=weight.weight()[BL])
output['j2'].fill(dataset=dataset,
pt=ak.flatten(jet[:, 1:2][BL].pt_nom),
eta=ak.flatten(jet[:, 1:2][BL].eta),
phi=ak.flatten(jet[:, 1:2][BL].phi),
weight=weight.weight()[BL])
#output['j3'].fill(
# dataset = dataset,
# pt = ak.flatten(jet[:, 2:3][BL].pt_nom),
# eta = ak.flatten(jet[:, 2:3][BL].eta),
# phi = ak.flatten(jet[:, 2:3][BL].phi),
# weight = weight.weight()[BL]
#)
output['fwd_jet'].fill(dataset=dataset,
pt=ak.flatten(j_fwd[BL].pt),
eta=ak.flatten(j_fwd[BL].eta),
phi=ak.flatten(j_fwd[BL].phi),
weight=weight.weight()[BL])
output['high_p_fwd_p'].fill(dataset=dataset,
p=ak.flatten(j_fwd[BL].p),
weight=weight.weight()[BL])
vetolepton = ak.concatenate([vetomuon, vetoelectron], axis=1)
trilep = choose3(vetolepton, 3)
trilep_m = trilep.mass
output['m3l'].fill(dataset=dataset,
mass=ak.flatten(trilep_m[BL]),
weight=weight.weight()[BL])
return output
def get_event_weights(events, year: str, corrections, isTTbar=False, isSignal=False):
weights = Weights(len(events), storeIndividual=True) # store individual variations
## only apply to MC
if not events.metadata["dataset"].startswith("data_Single"):
## Prefire Corrections
if (year != "2018") and (corrections["Prefire"] == True) and ("L1PreFiringWeight" in events.fields):
weights.add("Prefire",
ak.copy(events["L1PreFiringWeight"]["Nom"]),
ak.copy(events["L1PreFiringWeight"]["Up"]),
ak.copy(events["L1PreFiringWeight"]["Dn"])
)
## Generator Weights
weights.add("genweight", ak.copy(events["genWeight"]))
## Pileup Reweighting
if "Pileup" in corrections.keys():
# treat interference samples differently
if (events.metadata["dataset"].startswith("AtoTT") or events.metadata["dataset"].startswith("HtoTT")) and ("Int" in events.metadata["dataset"]):
central_pu_wt = ak.where(events["genWeight"] > 0, corrections["Pileup"]["%s_pos" % events.metadata["dataset"]]["central"](events["Pileup"]["nTrueInt"]),\
corrections["Pileup"]["%s_neg" % events.metadata["dataset"]]["central"](events["Pileup"]["nTrueInt"]))
up_pu_wt = ak.where(events["genWeight"] > 0, corrections["Pileup"]["%s_pos" % events.metadata["dataset"]]["up"](events["Pileup"]["nTrueInt"]),\
corrections["Pileup"]["%s_neg" % events.metadata["dataset"]]["up"](events["Pileup"]["nTrueInt"]))
down_pu_wt = ak.where(events["genWeight"] > 0, corrections["Pileup"]["%s_pos" % events.metadata["dataset"]]["down"](events["Pileup"]["nTrueInt"]),\
corrections["Pileup"]["%s_neg" % events.metadata["dataset"]]["down"](events["Pileup"]["nTrueInt"]))
weights.add("Pileup",
ak.copy(central_pu_wt),
ak.copy(up_pu_wt),
ak.copy(down_pu_wt)
)
else:
weights.add("Pileup",
ak.copy(corrections["Pileup"][events.metadata["dataset"]]["central"](events["Pileup"]["nTrueInt"])),
ak.copy(corrections["Pileup"][events.metadata["dataset"]]["up"](events["Pileup"]["nTrueInt"])),
ak.copy(corrections["Pileup"][events.metadata["dataset"]]["down"](events["Pileup"]["nTrueInt"]))
)
## PS and LHE weights for ttbar events
if isTTbar:
## PS Weight variations
# PSWeight definitions can be found here: https://github.com/cms-sw/cmssw/blob/CMSSW_10_6_X/PhysicsTools/NanoAOD/plugins/GenWeightsTableProducer.cc#L543-L546
psweights = events["PSWeight"]
weights.add("ISR",
np.ones(len(events)),
ak.copy(psweights[:, 0]), # (ISR=2, FSR=1)
ak.copy(psweights[:, 2]), # (ISR=0.5, FSR=1)
)
weights.add("FSR",
np.ones(len(events)),
ak.copy(psweights[:, 1]), # (ISR=1, FSR=2)
ak.copy(psweights[:, 3]), # (ISR=1, FSR=0.5)
)
## LHEScale Weight Variations
# LHEScaleWeight definitions can be found here: https://cms-nanoaod-integration.web.cern.ch/integration/master/mc94X_doc.html#LHE
lheweights = events["LHEScaleWeight"]
weights.add("FACTOR",
np.ones(len(events)),
ak.copy(lheweights[:, 5]), # (muR=1, muF=2)
ak.copy(lheweights[:, 3]), # (muR=1, muF=0.5)
)
weights.add("RENORM",
np.ones(len(events)),
ak.copy(lheweights[:, 7]), # (muR=2, muF=1)
ak.copy(lheweights[:, 1]), # (muR=0.5, muF=1)
)
weights.add("RENORM_FACTOR_SAME",
np.ones(len(events)),
ak.copy(lheweights[:, 8]), # (muR=2, muF=2), RENORM_UP_FACTOR_UP
ak.copy(lheweights[:, 0]), # (muR=0.5, muF=0.5), RENORM_DW_FACTOR_DW
)
weights.add("RENORM_FACTOR_DIFF",
np.ones(len(events)),
ak.copy(lheweights[:, 6]), # (muR=2, muF=0.5), RENORM_UP_FACTOR_DW
ak.copy(lheweights[:, 2]), # (muR=0.5, muF=2), RENORM_DW_FACTOR_UP
)
## PS and LHE weights for signal events
if isSignal:
## PS Weight variations
# PSWeight definitions can be found here: https://github.com/cms-sw/cmssw/blob/CMSSW_10_6_X/PhysicsTools/NanoAOD/plugins/GenWeightsTableProducer.cc#L543-L546
#psweights = events["PSWeight"]
#weights.add("ISR",
# np.ones(len(events)),
# ak.copy(psweights[:, 0]), # (ISR=2, FSR=1)
# ak.copy(psweights[:, 2]), # (ISR=0.5, FSR=1)
#)
#weights.add("FSR",
# np.ones(len(events)),
# ak.copy(psweights[:, 1]), # (ISR=1, FSR=2)
# ak.copy(psweights[:, 3]), # (ISR=1, FSR=0.5)
#)
## LHEScale Weight Variations
# LHEScaleWeight definitions can be found here: https://cms-nanoaod-integration.web.cern.ch/integration/master/mc94X_doc.html#LHE
lheweights = events["LHEScaleWeight"]
weights.add("AH_FACTOR",
np.ones(len(events)),
ak.copy(lheweights[:, 5]), # (muR=1, muF=2)
ak.copy(lheweights[:, 3]), # (muR=1, muF=0.5)
)
weights.add("AH_RENORM",
np.ones(len(events)),
ak.copy(lheweights[:, 7]), # (muR=2, muF=1)
ak.copy(lheweights[:, 1]), # (muR=0.5, muF=1)
)
weights.add("AH_RENORM_FACTOR_SAME",
np.ones(len(events)),
ak.copy(lheweights[:, 8]), # (muR=2, muF=2), RENORM_UP_FACTOR_UP
ak.copy(lheweights[:, 0]), # (muR=0.5, muF=0.5), RENORM_DW_FACTOR_DW
)
weights.add("AH_RENORM_FACTOR_DIFF",
np.ones(len(events)),
ak.copy(lheweights[:, 6]), # (muR=2, muF=0.5), RENORM_UP_FACTOR_DW
ak.copy(lheweights[:, 2]), # (muR=0.5, muF=2), RENORM_DW_FACTOR_UP
)
return weights
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)>=2
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
leading_electron_idx = ak.singletons(ak.argmax(electron.pt, axis=1))
leading_electron = electron[leading_electron_idx]
trailing_electron_idx = ak.singletons(ak.argmin(electron.pt, axis=1))
trailing_electron = electron[trailing_electron_idx]
leading_parent = find_first_parent(leading_electron.matched_gen)
trailing_parent = find_first_parent(trailing_electron.matched_gen)
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]
flipped_electron = flipped_electron[(ak.fill_none(flipped_electron.pt, 0)>0)]
flipped_electron = flipped_electron[~(ak.is_none(flipped_electron))]
n_flips = ak.num(flipped_electron)
##Muons
muon = Collections(ev, "Muon", "tightFCNC").get()
muon = muon[(muon.pt > 15) & (np.abs(muon.eta) < 2.4)]
muon = muon[(muon.genPartIdx >= 0)]
muon = muon[(np.abs(muon.matched_gen.pdgId)==13)] #from here, all muons are gen-matched
muon = muon[( (muon.genPartFlav==1) | (muon.genPartFlav==15) )] #and now they are all prompt
##Leptons
lepton = ak.concatenate([muon, electron], axis=1)
SSlepton = (ak.sum(lepton.charge, axis=1) != 0) & (ak.num(lepton)==2)
OSlepton = (ak.sum(lepton.charge, axis=1) == 0) & (ak.num(lepton)==2)
emulepton = (ak.num(electron) == 1) & (ak.num(muon) == 1)
no_mumu = (ak.num(muon) <= 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]
#jets
jet = getJets(ev, minPt=40, maxEta=2.4, pt_var='pt')
jet = jet[ak.argsort(jet.pt, 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)]
## MET -> can switch to puppi MET
met_pt = ev.MET.pt
met_phi = ev.MET.phi
# setting up the various weights
weight = Weights( len(ev) )
weight2 = Weights( len(ev))
if not dataset=='MuonEG':
# generator weight
weight.add("weight", ev.genWeight)
weight2.add("weight", ev.genWeight)
weight2.add("charge flip", self.charge_flip_ratio.flip_weight(electron))
#selections
filters = getFilters(ev, year=self.year, dataset=dataset)
ss = (SSlepton)
os = (OSlepton)
jet_all = (ak.num(jet) >= 2)
diele = (ak.num(electron) == 2)
emu = (emulepton)
flips = (n_flips == 1)
no_flips = (n_flips == 0)
nmm = no_mumu
selection = PackedSelection()
selection.add('filter', (filters) )
selection.add('ss', ss )
selection.add('os', os )
selection.add('jet', jet_all )
selection.add('ee', diele)
selection.add('emu', emu)
selection.add('flip', flips)
selection.add('nflip', no_flips)
selection.add('no_mumu', nmm)
bl_reqs = ['filter'] + ['jet']
bl_reqs_d = { sel: True for sel in bl_reqs }
baseline = selection.require(**bl_reqs_d)
f_reqs = bl_reqs + ['flip'] + ['ss'] + ['ee']
f_reqs_d = {sel: True for sel in f_reqs}
flip_sel = selection.require(**f_reqs_d)
f2_reqs = bl_reqs + ['flip'] + ['ss'] + ['emu']
f2_reqs_d = {sel: True for sel in f2_reqs}
flip_sel2 = selection.require(**f2_reqs_d)
f3_reqs = bl_reqs + ['flip'] + ['ss'] + ['no_mumu']
f3_reqs_d = {sel: True for sel in f3_reqs}
flip_sel3 = selection.require(**f3_reqs_d)
nf_reqs = bl_reqs + ['nflip'] + ['os'] + ['ee']
nf_reqs_d = {sel: True for sel in nf_reqs}
n_flip_sel = selection.require(**nf_reqs_d)
nf2_reqs = bl_reqs + ['nflip'] + ['os'] + ['emu']
nf2_reqs_d = {sel: True for sel in nf2_reqs}
n_flip_sel2 = selection.require(**nf2_reqs_d)
nf3_reqs = bl_reqs + ['nflip'] + ['os'] + ['no_mumu']
nf3_reqs_d = {sel: True for sel in nf3_reqs}
n_flip_sel3 = selection.require(**nf3_reqs_d)
s_reqs = bl_reqs + ['ss'] + ['no_mumu']
s_reqs_d = { sel: True for sel in s_reqs }
ss_sel = selection.require(**s_reqs_d)
o_reqs = bl_reqs + ['os'] + ['no_mumu']
o_reqs_d = {sel: True for sel in o_reqs }
os_sel = selection.require(**o_reqs_d)
ees_reqs = bl_reqs + ['ss'] + ['ee']
ees_reqs_d = { sel: True for sel in ees_reqs }
eess_sel = selection.require(**ees_reqs_d)
eeo_reqs = bl_reqs + ['os'] + ['ee']
eeo_reqs_d = {sel: True for sel in eeo_reqs }
eeos_sel = selection.require(**eeo_reqs_d)
ems_reqs = bl_reqs + ['ss'] + ['emu']
ems_reqs_d = { sel: True for sel in ems_reqs }
emss_sel = selection.require(**ems_reqs_d)
emo_reqs = bl_reqs + ['os'] + ['emu']
emo_reqs_d = {sel: True for sel in emo_reqs }
emos_sel = selection.require(**emo_reqs_d)
#outputs
output['N_jet'].fill(dataset=dataset, multiplicity=ak.num(jet)[baseline], weight=weight.weight()[baseline])
output['N_ele'].fill(dataset=dataset, multiplicity=ak.num(lepton)[ss_sel], weight=weight.weight()[ss_sel])
output['N_ele2'].fill(dataset=dataset, multiplicity=ak.num(lepton)[os_sel], weight=weight2.weight()[os_sel])
output['electron_flips'].fill(dataset=dataset, multiplicity = n_flips[flip_sel], weight=weight.weight()[flip_sel])
output['electron_flips2'].fill(dataset=dataset, multiplicity = n_flips[n_flip_sel], weight=weight2.weight()[n_flip_sel])
output['electron_flips3'].fill(dataset=dataset, multiplicity = n_flips[flip_sel2], weight=weight.weight()[flip_sel2])
output['electron_flips4'].fill(dataset=dataset, multiplicity = n_flips[n_flip_sel2], weight=weight2.weight()[n_flip_sel2])
output["electron"].fill(
dataset = dataset,
pt = ak.to_numpy(ak.flatten(leading_electron[flip_sel3].pt)),
eta = np.abs(ak.to_numpy(ak.flatten(leading_electron[flip_sel3].eta))),
weight = weight.weight()[flip_sel3]
)
output["electron2"].fill(
dataset = dataset,
pt = ak.to_numpy(ak.flatten(leading_electron[n_flip_sel3].pt)),
eta = np.abs(ak.to_numpy(ak.flatten(leading_electron[n_flip_sel3].eta))),
weight = weight2.weight()[n_flip_sel3]
)
output["flipped_electron"].fill(
dataset = dataset,
pt = ak.to_numpy(ak.flatten(leading_electron[flip_sel].pt)),
eta = np.abs(ak.to_numpy(ak.flatten(leading_electron[flip_sel].eta))),
weight = weight.weight()[flip_sel]
)
output["flipped_electron2"].fill(
dataset = dataset,
pt = ak.to_numpy(ak.flatten(leading_electron[n_flip_sel].pt)),
eta = np.abs(ak.to_numpy(ak.flatten(leading_electron[n_flip_sel].eta))),
weight = weight2.weight()[n_flip_sel]
)
output["flipped_electron3"].fill(
dataset = dataset,
pt = ak.to_numpy(ak.flatten(leading_electron[flip_sel2].pt)),
eta = np.abs(ak.to_numpy(ak.flatten(leading_electron[flip_sel2].eta))),
weight = weight.weight()[flip_sel2]
)
output["flipped_electron4"].fill(
dataset = dataset,
pt = ak.to_numpy(ak.flatten(leading_electron[n_flip_sel2].pt)),
eta = np.abs(ak.to_numpy(ak.flatten(leading_electron[n_flip_sel2].eta))),
weight = weight2.weight()[n_flip_sel2]
)
#output["lepton_parent"].fill(
# dataset = dataset,
# pdgID = np.abs(ak.to_numpy(ak.flatten(leading_parent[ss_sel]))),
# weight = weight.weight()[ss_sel]
#)
#
#output["lepton_parent2"].fill(
# dataset = dataset,
# pdgID = np.abs(ak.to_numpy(ak.flatten(trailing_parent[ss_sel]))),
# weight = weight.weight()[ss_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)
## Muons
muon = ev.Muon
## Electrons
electron = ev.Electron
## 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]
## MET -> can switch to puppi MET
met_pt = ev.MET.pt
met_phi = ev.MET.phi
# define the weight
weight = Weights(len(ev))
if not dataset == 'MuonEG':
# generator weight
weight.add("weight", ev.genWeight)
filters = getFilters(ev, year=self.year, dataset=dataset)
dilep = ((ak.num(electron) + ak.num(muon)) == 2)
selection = PackedSelection()
selection.add('dilep', dilep)
selection.add('filter', (filters))
bl_reqs = ['dilep', 'filter']
bl_reqs_d = {sel: True for sel in bl_reqs}
baseline = selection.require(**bl_reqs_d)
output['N_ele'].fill(dataset=dataset,
multiplicity=ak.num(electron)[baseline],
weight=weight.weight()[baseline])
output['N_mu'].fill(dataset=dataset,
multiplicity=ak.num(muon)[baseline],
weight=weight.weight()[baseline])
output['lead_lep'].fill(
dataset=dataset,
pt=ak.to_numpy(ak.flatten(leading_lepton[baseline].pt)),
eta=ak.to_numpy(ak.flatten(leading_lepton[baseline].eta)),
phi=ak.to_numpy(ak.flatten(leading_lepton[baseline].phi)),
weight=weight.weight()[baseline])
return output
def process(self, events):
output = self.accumulator.identity()
# 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()
output['totalEvents']['all'] += len(events)
output['skimmedEvents']['all'] += len(ev)
if not re.search(re.compile('MuonEG|DoubleMuon|DoubleEG|EGamma'), dataset):
## Generated leptons
gen_lep = ev.GenL
leading_gen_lep = gen_lep[ak.singletons(ak.argmax(gen_lep.pt, axis=1))]
trailing_gen_lep = gen_lep[ak.singletons(ak.argmin(gen_lep.pt, axis=1))]
# Get the leptons. This has changed a couple of times now, but we are using fakeable objects as baseline leptons.
# The added p4 instance has the corrected pt (conePt for fakeable) and should be used for any following selection or calculation
# Any additional correction (if we choose to do so) should be added here, e.g. Rochester corrections, ...
## Muons
mu_v = Collections(ev, "Muon", "vetoTTH", year=year).get() # these include all muons, tight and fakeable
mu_t = Collections(ev, "Muon", "tightSSTTH", year=year).get()
mu_f = Collections(ev, "Muon", "fakeableSSTTH", year=year).get()
muon = ak.concatenate([mu_t, mu_f], axis=1)
muon['p4'] = get_four_vec_fromPtEtaPhiM(muon, get_pt(muon), muon.eta, muon.phi, muon.mass, copy=False) #FIXME new
## Electrons
el_v = Collections(ev, "Electron", "vetoTTH", year=year).get()
el_t = Collections(ev, "Electron", "tightSSTTH", year=year).get()
el_f = Collections(ev, "Electron", "fakeableSSTTH", year=year).get()
electron = ak.concatenate([el_t, el_f], axis=1)
electron['p4'] = get_four_vec_fromPtEtaPhiM(electron, get_pt(electron), electron.eta, electron.phi, electron.mass, copy=False) #FIXME new
if not re.search(re.compile('MuonEG|DoubleMuon|DoubleEG|EGamma'), dataset):
el_t_p = prompt(el_t)
el_t_np = nonprompt(el_t)
el_f_p = prompt(el_f)
el_f_np = nonprompt(el_f)
mu_t_p = prompt(mu_t)
mu_t_np = nonprompt(mu_t)
mu_f_p = prompt(mu_f)
mu_f_np = nonprompt(mu_f)
is_flipped = ( (el_t_p.matched_gen.pdgId*(-1) == el_t_p.pdgId) & (abs(el_t_p.pdgId) == 11) )
el_t_p_cc = el_t_p[~is_flipped] # this is tight, prompt, and charge consistent
el_t_p_cf = el_t_p[is_flipped] # this is tight, prompt, and charge flipped
## Merge electrons and muons. These are fakeable leptons now
lepton = ak.concatenate([muon, electron], axis=1)
leading_lepton_idx = ak.singletons(ak.argmax(lepton.p4.pt, axis=1))
leading_lepton = lepton[leading_lepton_idx]
trailing_lepton_idx = ak.singletons(ak.argmin(lepton.p4.pt, axis=1))
trailing_lepton = lepton[trailing_lepton_idx]
dilepton_mass = (leading_lepton.p4 + trailing_lepton.p4).mass
dilepton_pt = (leading_lepton.p4 + trailing_lepton.p4).pt
#dilepton_dR = delta_r(leading_lepton, trailing_lepton)
dilepton_dR = leading_lepton.p4.delta_r(trailing_lepton.p4)
lepton_pdgId_pt_ordered = ak.fill_none(ak.pad_none(lepton[ak.argsort(lepton.p4.pt, ascending=False)].pdgId, 2, clip=True), 0)
if not re.search(re.compile('MuonEG|DoubleMuon|DoubleEG|EGamma'), dataset):
n_nonprompt = getNonPromptFromFlavour(electron) + getNonPromptFromFlavour(muon)
n_chargeflip = getChargeFlips(electron, ev.GenPart) + getChargeFlips(muon, ev.GenPart)
gp = ev.GenPart
gp_e = gp[((abs(gp.pdgId)==11)&(gp.status==1)&((gp.statusFlags&(1<<0))==1)&(gp.statusFlags&(1<<8)==256))]
gp_m = gp[((abs(gp.pdgId)==13)&(gp.status==1)&((gp.statusFlags&(1<<0))==1)&(gp.statusFlags&(1<<8)==256))]
n_gen_lep = ak.num(gp_e) + ak.num(gp_m)
else:
n_gen_lep = np.zeros(len(ev))
LL = (n_gen_lep > 2) # this is the classifier for LL events (should mainly be ttZ/tZ/WZ...)
mt_lep_met = mt(lepton.p4.pt, lepton.p4.phi, ev.MET.pt, ev.MET.phi)
min_mt_lep_met = ak.min(mt_lep_met, axis=1)
## Tau and other stuff
tau = getTaus(ev)
tau = tau[~match(tau, muon, deltaRCut=0.4)]
tau = tau[~match(tau, electron, deltaRCut=0.4)]
track = getIsoTracks(ev)
## 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)
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)
## forward jets
j_fwd = fwd[ak.singletons(ak.argmax(fwd.p, axis=1))] # highest momentum spectator
# try to get either the most forward light jet, or if there's more than one with eta>1.7, the highest pt one
most_fwd = light[ak.argsort(abs(light.eta))][:,0:1]
#most_fwd = light[ak.singletons(ak.argmax(abs(light.eta)))]
best_fwd = ak.concatenate([j_fwd, most_fwd], axis=1)[:,0: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 = abs(j_fwd2.eta - j_fwd.eta)
## 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(get_pt(muon), axis=1) + ak.sum(get_pt(electron), axis=1)
st = met_pt + ht + ak.sum(lepton.p4.pt, axis=1)
# define the weight
weight = Weights( len(ev) )
if not re.search(re.compile('MuonEG|DoubleMuon|DoubleEG|EGamma'), dataset):
# lumi weight
weight.add("weight", ev.weight*cfg['lumi'][self.year])
# PU weight
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)
# slightly restructured
# calculate everything from loose, require two tights on top
# since n_tight == n_loose == 2, the tight and loose leptons are the same in the end
# in this selection we'll get events with exactly two fakeable+tight and two loose leptons.
sel = Selection(
dataset = dataset,
events = ev,
year = self.year,
ele = electron,
ele_veto = el_v,
mu = muon,
mu_veto = mu_v,
jet_all = jet,
jet_central = central,
jet_btag = btag,
jet_fwd = fwd,
jet_light = light,
met = ev.MET,
)
baseline = sel.dilep_baseline(cutflow=cutflow, SS=True, omit=['N_fwd>0'])
baseline_OS = sel.dilep_baseline(cutflow=cutflow, SS=False, omit=['N_fwd>0']) # this is for charge flip estimation
if not re.search(re.compile('MuonEG|DoubleMuon|DoubleEG|EGamma'), dataset):
BL = (baseline & ((ak.num(el_t_p_cc)+ak.num(mu_t_p))==2)) # this is the MC baseline for events with two tight prompt leptons
BL_incl = (baseline & ((ak.num(el_t)+ak.num(mu_t))==2)) # this is the MC baseline for events with two tight leptons
np_est_sel_mc = (baseline & \
((((ak.num(el_t_p_cc)+ak.num(mu_t_p))==1) & ((ak.num(el_f_np)+ak.num(mu_f_np))==1)) | (((ak.num(el_t_p_cc)+ak.num(mu_t_p))==0) & ((ak.num(el_f_np)+ak.num(mu_f_np))==2)) )) # no overlap between tight and nonprompt, and veto on additional leptons. this should be enough
np_obs_sel_mc = (baseline & ((ak.num(el_t)+ak.num(mu_t))==2) & ((ak.num(el_t_np)+ak.num(mu_t_np))>=1) ) # two tight leptons, at least one nonprompt
np_est_sel_data = (baseline & ~baseline) # this has to be false
cf_est_sel_mc = (baseline_OS & ((ak.num(el_t_p)+ak.num(mu_t_p))==2))
cf_obs_sel_mc = (baseline & ((ak.num(el_t)+ak.num(mu_t))==2) & ((ak.num(el_t_p_cf))>=1) ) # two tight leptons, at least one electron charge flip
cf_est_sel_data = (baseline & ~baseline) # this has to be false
weight_np_mc = self.nonpromptWeight.get(el_f_np, mu_f_np, meas='TT')
weight_cf_mc = self.chargeflipWeight.flip_weight(el_t_p)
else:
BL = (baseline & ((ak.num(el_t)+ak.num(mu_t))==2))
BL_incl = BL
np_est_sel_mc = (baseline & ~baseline)
np_obs_sel_mc = (baseline & ~baseline)
np_est_sel_data = (baseline & (ak.num(el_t)+ak.num(mu_t)==1) & (ak.num(el_f)+ak.num(mu_f)==1) )
cf_est_sel_mc = (baseline & ~baseline)
cf_obs_sel_mc = (baseline & ~baseline)
cf_est_sel_data = (baseline_OS & ((ak.num(el_t)+ak.num(mu_t))==2) )
weight_np_mc = np.zeros(len(ev))
weight_cf_mc = np.zeros(len(ev))
#rle = ak.to_numpy(ak.zip([ev.run, ev.luminosityBlock, ev.event]))
run_ = ak.to_numpy(ev.run)
lumi_ = ak.to_numpy(ev.luminosityBlock)
event_ = ak.to_numpy(ev.event)
if False:
output['%s_run'%dataset] += processor.column_accumulator(run_[BL])
output['%s_lumi'%dataset] += processor.column_accumulator(lumi_[BL])
output['%s_event'%dataset] += processor.column_accumulator(event_[BL])
weight_BL = weight.weight()[BL] # this is just a shortened weight list for the two prompt selection
weight_np_data = self.nonpromptWeight.get(el_f, mu_f, meas='data')
weight_cf_data = self.chargeflipWeight.flip_weight(el_t)
out_sel = (BL | np_est_sel_mc | cf_est_sel_mc)
dummy = (np.ones(len(ev))==1)
def fill_multiple_np(hist, arrays, add_sel=dummy):
#reg_sel = [BL, np_est_sel_mc, np_obs_sel_mc, np_est_sel_data, cf_est_sel_mc, cf_obs_sel_mc, cf_est_sel_data],
#print ('len', len(reg_sel[0]))
#print ('sel', reg_sel[0])
reg_sel = [BL&add_sel, BL_incl&add_sel, np_est_sel_mc&add_sel, np_obs_sel_mc&add_sel, np_est_sel_data&add_sel, cf_est_sel_mc&add_sel, cf_obs_sel_mc&add_sel, cf_est_sel_data&add_sel],
fill_multiple(
hist,
datasets=[
dataset, # only prompt contribution from process
dataset+"_incl", # everything from process (inclusive MC truth)
"np_est_mc", # MC based NP estimate
"np_obs_mc", # MC based NP observation
"np_est_data",
"cf_est_mc",
"cf_obs_mc",
"cf_est_data",
],
arrays=arrays,
selections=reg_sel[0], # no idea where the additional dimension is coming from...
weights=[
weight.weight()[reg_sel[0][0]],
weight.weight()[reg_sel[0][1]],
weight.weight()[reg_sel[0][2]]*weight_np_mc[reg_sel[0][2]],
weight.weight()[reg_sel[0][3]],
weight.weight()[reg_sel[0][4]]*weight_np_data[reg_sel[0][4]],
weight.weight()[reg_sel[0][5]]*weight_cf_mc[reg_sel[0][5]],
weight.weight()[reg_sel[0][6]],
weight.weight()[reg_sel[0][7]]*weight_cf_data[reg_sel[0][7]],
],
)
if self.evaluate or self.dump:
# define the inputs to the NN
# this is super stupid. there must be a better way.
# used a np.stack which is ok performance wise. pandas data frame seems to be slow and memory inefficient
#FIXME no n_b, n_fwd back in v13/v14 of the DNN
NN_inputs_d = {
'n_jet': ak.to_numpy(ak.num(jet)),
'n_fwd': ak.to_numpy(ak.num(fwd)),
'n_b': ak.to_numpy(ak.num(btag)),
'n_tau': ak.to_numpy(ak.num(tau)),
#'n_track': ak.to_numpy(ak.num(track)),
'st': ak.to_numpy(st),
'met': ak.to_numpy(ev.MET.pt),
'mjj_max': ak.to_numpy(ak.fill_none(ak.max(mjf, axis=1),0)),
'delta_eta_jj': ak.to_numpy(pad_and_flatten(delta_eta)),
'lead_lep_pt': ak.to_numpy(pad_and_flatten(leading_lepton.p4.pt)),
'lead_lep_eta': ak.to_numpy(pad_and_flatten(leading_lepton.p4.eta)),
'sublead_lep_pt': ak.to_numpy(pad_and_flatten(trailing_lepton.p4.pt)),
'sublead_lep_eta': ak.to_numpy(pad_and_flatten(trailing_lepton.p4.eta)),
'dilepton_mass': ak.to_numpy(pad_and_flatten(dilepton_mass)),
'dilepton_pt': ak.to_numpy(pad_and_flatten(dilepton_pt)),
'fwd_jet_pt': ak.to_numpy(pad_and_flatten(best_fwd.pt)),
'fwd_jet_p': ak.to_numpy(pad_and_flatten(best_fwd.p)),
'fwd_jet_eta': ak.to_numpy(pad_and_flatten(best_fwd.eta)),
'lead_jet_pt': ak.to_numpy(pad_and_flatten(jet[:, 0:1].pt)),
'sublead_jet_pt': ak.to_numpy(pad_and_flatten(jet[:, 1:2].pt)),
'lead_jet_eta': ak.to_numpy(pad_and_flatten(jet[:, 0:1].eta)),
'sublead_jet_eta': ak.to_numpy(pad_and_flatten(jet[:, 1:2].eta)),
'lead_btag_pt': ak.to_numpy(pad_and_flatten(high_score_btag[:, 0:1].pt)),
'sublead_btag_pt': ak.to_numpy(pad_and_flatten(high_score_btag[:, 1:2].pt)),
'lead_btag_eta': ak.to_numpy(pad_and_flatten(high_score_btag[:, 0:1].eta)),
'sublead_btag_eta': ak.to_numpy(pad_and_flatten(high_score_btag[:, 1:2].eta)),
'min_bl_dR': ak.to_numpy(ak.fill_none(min_bl_dR, 0)),
'min_mt_lep_met': ak.to_numpy(ak.fill_none(min_mt_lep_met, 0)),
}
if self.dump:
for k in NN_inputs_d.keys():
output[k] += processor.column_accumulator(NN_inputs_d[k][out_sel])
if self.evaluate:
NN_inputs = np.stack( [NN_inputs_d[k] for k in NN_inputs_d.keys()] )
NN_inputs = np.nan_to_num(NN_inputs, 0, posinf=1e5, neginf=-1e5) # events with posinf/neginf/nan will not pass the BL selection anyway
NN_inputs = np.moveaxis(NN_inputs, 0, 1) # this is needed for a np.stack (old version)
model, scaler = load_onnx_model(self.training)
try:
NN_inputs_scaled = scaler.transform(NN_inputs)
NN_pred = predict_onnx(model, NN_inputs_scaled)
best_score = np.argmax(NN_pred, axis=1)
except ValueError:
print ("Problem with prediction. Showing the shapes here:")
print (np.shape(NN_inputs))
print (np.shape(weight_BL))
NN_pred = np.array([])
best_score = np.array([])
NN_inputs_scaled = NN_inputs
raise
##k.clear_session()
#FIXME below needs to be fixed again with changed NN evaluation. Should work now
fill_multiple_np(output['node'], {'multiplicity':best_score})
fill_multiple_np(output['node0_score_incl'], {'score':NN_pred[:,0]})
fill_multiple_np(output['node1_score_incl'], {'score':NN_pred[:,1]})
fill_multiple_np(output['node2_score_incl'], {'score':NN_pred[:,2]})
fill_multiple_np(output['node3_score_incl'], {'score':NN_pred[:,3]})
fill_multiple_np(output['node4_score_incl'], {'score':NN_pred[:,4]})
fill_multiple_np(output['node0_score'], {'score':NN_pred[:,0]}, add_sel=(best_score==0))
fill_multiple_np(output['node1_score'], {'score':NN_pred[:,1]}, add_sel=(best_score==1))
fill_multiple_np(output['node2_score'], {'score':NN_pred[:,2]}, add_sel=(best_score==2))
fill_multiple_np(output['node3_score'], {'score':NN_pred[:,3]}, add_sel=(best_score==3))
fill_multiple_np(output['node4_score'], {'score':NN_pred[:,4]}, add_sel=(best_score==4))
#SR_sel_pp = ((best_score==0) & ak.flatten((leading_lepton[BL].pdgId<0)))
#SR_sel_mm = ((best_score==0) & ak.flatten((leading_lepton[BL].pdgId>0)))
#leading_lepton_BL = leading_lepton[BL]
#output['lead_lep_SR_pp'].fill(
# dataset = dataset,
# pt = ak.to_numpy(ak.flatten(leading_lepton_BL[SR_sel_pp].pt)),
# weight = weight_BL[SR_sel_pp]
#)
#output['lead_lep_SR_mm'].fill(
# dataset = dataset,
# pt = ak.to_numpy(ak.flatten(leading_lepton_BL[SR_sel_mm].pt)),
# weight = weight_BL[SR_sel_mm]
#)
del model
del scaler
del NN_inputs, NN_inputs_scaled, NN_pred
labels = {'topW_v3': 0, 'TTW':1, 'TTZ': 2, 'TTH': 3, 'ttbar': 4, 'rare':5, 'diboson':6} # these should be all?
if dataset in labels:
label_mult = labels[dataset]
else:
label_mult = 7 # data or anything else
if self.dump:
output['label'] += processor.column_accumulator(np.ones(len(ev[out_sel])) * label_mult)
output['SS'] += processor.column_accumulator(ak.to_numpy(BL[out_sel]))
output['OS'] += processor.column_accumulator(ak.to_numpy(cf_est_sel_mc[out_sel]))
output['AR'] += processor.column_accumulator(ak.to_numpy(np_est_sel_mc[out_sel]))
output['LL'] += processor.column_accumulator(ak.to_numpy(LL[out_sel]))
output['weight'] += processor.column_accumulator(ak.to_numpy(weight.weight()[out_sel]))
output['weight_np'] += processor.column_accumulator(ak.to_numpy(weight_np_mc[out_sel]))
output['weight_cf'] += processor.column_accumulator(ak.to_numpy(weight_cf_mc[out_sel]))
# first, make a few super inclusive plots
output['PV_npvs'].fill(dataset=dataset, multiplicity=ev.PV[BL].npvs, weight=weight_BL)
output['PV_npvsGood'].fill(dataset=dataset, multiplicity=ev.PV[BL].npvsGood, weight=weight_BL)
fill_multiple_np(output['N_jet'], {'multiplicity': ak.num(jet)})
fill_multiple_np(output['N_b'], {'multiplicity': ak.num(btag)})
fill_multiple_np(output['N_central'], {'multiplicity': ak.num(central)})
fill_multiple_np(output['N_ele'], {'multiplicity':ak.num(electron)})
fill_multiple_np(output['N_mu'], {'multiplicity':ak.num(muon)})
fill_multiple_np(output['N_fwd'], {'multiplicity':ak.num(fwd)})
fill_multiple_np(output['ST'], {'ht': st})
fill_multiple_np(output['HT'], {'ht': ht})
if not re.search(re.compile('MuonEG|DoubleMuon|DoubleEG|EGamma'), dataset):
output['nLepFromTop'].fill(dataset=dataset, multiplicity=ev[BL].nLepFromTop, weight=weight_BL)
output['nLepFromTau'].fill(dataset=dataset, multiplicity=ev.nLepFromTau[BL], weight=weight_BL)
output['nLepFromZ'].fill(dataset=dataset, multiplicity=ev.nLepFromZ[BL], weight=weight_BL)
output['nLepFromW'].fill(dataset=dataset, multiplicity=ev.nLepFromW[BL], weight=weight_BL)
output['nGenTau'].fill(dataset=dataset, multiplicity=ev.nGenTau[BL], weight=weight_BL)
output['nGenL'].fill(dataset=dataset, multiplicity=ak.num(ev.GenL[BL], axis=1), weight=weight_BL)
output['chargeFlip_vs_nonprompt'].fill(dataset=dataset, n1=n_chargeflip[BL], n2=n_nonprompt[BL], n_ele=ak.num(electron)[BL], weight=weight_BL)
fill_multiple_np(output['MET'], {'pt':ev.MET.pt, 'phi':ev.MET.phi})
if not re.search(re.compile('MuonEG|DoubleMuon|DoubleEG|EGamma'), dataset):
output['lead_gen_lep'].fill(
dataset = dataset,
pt = ak.to_numpy(ak.flatten(leading_gen_lep[BL].pt)),
eta = ak.to_numpy(ak.flatten(leading_gen_lep[BL].eta)),
phi = ak.to_numpy(ak.flatten(leading_gen_lep[BL].phi)),
weight = weight_BL
)
output['trail_gen_lep'].fill(
dataset = dataset,
pt = ak.to_numpy(ak.flatten(trailing_gen_lep[BL].pt)),
eta = ak.to_numpy(ak.flatten(trailing_gen_lep[BL].eta)),
phi = ak.to_numpy(ak.flatten(trailing_gen_lep[BL].phi)),
weight = weight_BL
)
fill_multiple_np(
output['lead_lep'],
{
'pt': pad_and_flatten(leading_lepton.p4.pt),
'eta': pad_and_flatten(leading_lepton.eta),
'phi': pad_and_flatten(leading_lepton.phi),
},
)
fill_multiple_np(
output['trail_lep'],
{
'pt': pad_and_flatten(trailing_lepton.p4.pt),
'eta': pad_and_flatten(trailing_lepton.eta),
'phi': pad_and_flatten(trailing_lepton.phi),
},
)
output['j1'].fill(
dataset = dataset,
pt = ak.flatten(jet.pt_nom[:, 0:1][BL]),
eta = ak.flatten(jet.eta[:, 0:1][BL]),
phi = ak.flatten(jet.phi[:, 0:1][BL]),
weight = weight_BL
)
output['j2'].fill(
dataset = dataset,
pt = ak.flatten(jet[:, 1:2][BL].pt_nom),
eta = ak.flatten(jet[:, 1:2][BL].eta),
phi = ak.flatten(jet[:, 1:2][BL].phi),
weight = weight_BL
)
output['j3'].fill(
dataset = dataset,
pt = ak.flatten(jet[:, 2:3][BL].pt_nom),
eta = ak.flatten(jet[:, 2:3][BL].eta),
phi = ak.flatten(jet[:, 2:3][BL].phi),
weight = weight_BL
)
fill_multiple_np(
output['fwd_jet'],
{
'pt': pad_and_flatten(best_fwd.pt),
'eta': pad_and_flatten(best_fwd.eta),
'phi': pad_and_flatten(best_fwd.phi),
},
)
#output['fwd_jet'].fill(
# dataset = dataset,
# pt = ak.flatten(j_fwd[BL].pt),
# eta = ak.flatten(j_fwd[BL].eta),
# phi = ak.flatten(j_fwd[BL].phi),
# weight = weight_BL
#)
output['high_p_fwd_p'].fill(dataset=dataset, p = ak.flatten(best_fwd[BL].p), weight = weight_BL)
return output
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):
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']
# load the config - probably not needed anymore
cfg = loadConfig()
output['totalEvents']['all'] += len(events)
output['skimmedEvents']['all'] += len(ev)
### For FCNC, we want electron -> tightTTH
electron = Collections(ev, "Electron", "tightSSTTH").get()
fakeableelectron = Collections(ev, "Electron", "fakeableSSTTH").get()
# muon = Collections(ev, "Muon", "tightSSTTH").get()
# fakeablemuon = Collections(ev, "Muon", "fakeableSSTTH").get()
muon = Collections(ev, "Muon", "tightSSTTH").get()
fakeablemuon = Collections(ev, "Muon", "fakeableSSTTH").get()
##Jets
Jets = events.Jet
## MET -> can switch to puppi MET
met_pt = ev.MET.pt
met_phi = ev.MET.phi
# define the weight
weight = Weights(len(ev))
if not dataset == 'MuonEG':
# generator weight
weight.add("weight", ev.genWeight)
# output['lead_lep'].fill(
# dataset = dataset,
# pt = ak.to_numpy(ak.flatten(leading_lepton[baseline].pt)),
# eta = ak.to_numpy(ak.flatten(leading_lepton[baseline].eta)),
# phi = ak.to_numpy(ak.flatten(leading_lepton[baseline].phi)),
# weight = weight.weight()[baseline]
# )
jets = getJets(ev, maxEta=2.4, minPt=25, pt_var='pt')
output['single_mu_fakeable'].fill(
dataset=dataset,
pt=ak.to_numpy(
ak.flatten(fakeablemuon[
(ak.num(fakeablemuon) == 1) & (ak.num(muon) == 0) &
(ak.num(jets[~match(jets, fakeablemuon, deltaRCut=0.7)]) >=
1)].conePt)),
eta=ak.to_numpy(
ak.flatten(fakeablemuon[
(ak.num(fakeablemuon) == 1) & (ak.num(muon) == 0) &
(ak.num(jets[~match(jets, fakeablemuon, deltaRCut=0.7)]) >=
1)].eta)))
output['single_mu'].fill(
dataset=dataset,
pt=ak.to_numpy(
ak.flatten(
muon[(ak.num(fakeablemuon) == 0) & (ak.num(muon) == 1) &
(ak.num(jets[~match(jets, muon, deltaRCut=0.7)]) >=
1)].conePt)),
eta=ak.to_numpy(
ak.flatten(
muon[(ak.num(fakeablemuon) == 0) & (ak.num(muon) == 1) &
(ak.num(jets[~match(jets, muon, deltaRCut=0.7)]) >=
1)].eta)))
output['single_e_fakeable'].fill(
dataset=dataset,
pt=ak.to_numpy(
ak.flatten(fakeableelectron[(ak.num(fakeableelectron) == 1) & (
ak.num(electron) == 0) & (ak.num(
jets[~match(jets, fakeableelectron, deltaRCut=0.7)]) >=
1)].conePt)),
eta=np.abs(
ak.to_numpy(
ak.flatten(fakeableelectron[
(ak.num(fakeableelectron) == 1)
& (ak.num(electron) == 0) & (ak.num(
jets[~match(jets, fakeableelectron, deltaRCut=0.7)]
) >= 1)].etaSC))))
output['single_e'].fill(
dataset=dataset,
pt=ak.to_numpy(
ak.flatten(electron[
(ak.num(fakeableelectron) == 0) & (ak.num(electron) == 1) &
(ak.num(jets[~match(jets, electron, deltaRCut=0.7)]) >=
1)].conePt)),
eta=np.abs(
ak.to_numpy(
ak.flatten(electron[
(ak.num(fakeableelectron) == 0)
& (ak.num(electron) == 1) &
(ak.num(jets[~match(jets, electron, deltaRCut=0.7)]) >=
1)].etaSC))))
return output
def process(self, events):
output = self.accumulator.identity()
# 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()
output['totalEvents']['all'] += len(events)
output['skimmedEvents']['all'] += len(ev)
## Generated leptons
gen_lep = ev.GenL
leading_gen_lep = gen_lep[ak.singletons(ak.argmax(gen_lep.pt, axis=1))]
trailing_gen_lep = gen_lep[ak.singletons(ak.argmin(gen_lep.pt, axis=1))]
## Muons
muon = Collections(ev, "Muon", "tightSSTTH").get()
vetomuon = Collections(ev, "Muon", "vetoTTH").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", "tightSSTTH").get()
vetoelectron = Collections(ev, "Electron", "vetoTTH").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]
n_nonprompt = getNonPromptFromFlavour(electron) + getNonPromptFromFlavour(muon)
n_chargeflip = getChargeFlips(electron, ev.GenPart) + getChargeFlips(muon, ev.GenPart)
## 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)
## forward jets
j_fwd = fwd[ak.singletons(ak.argmax(fwd.p, axis=1))] # highest momentum spectator
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 = abs(j_fwd2.eta - j_fwd.eta)
## 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(electron) + ak.num(muon))==2)
pos_charge = ((ak.sum(electron.pdgId, axis=1) + ak.sum(muon.pdgId, axis=1))<0)
neg_charge = ((ak.sum(electron.pdgId, axis=1) + ak.sum(muon.pdgId, axis=1))>0)
lep0pt = ((ak.num(electron[(electron.pt>25)]) + ak.num(muon[(muon.pt>25)]))>0)
lep0pt_40 = ((ak.num(electron[(electron.pt>40)]) + ak.num(muon[(muon.pt>40)]))>0)
lep0pt_100 = ((ak.num(electron[(electron.pt>100)]) + ak.num(muon[(muon.pt>100)]))>0)
lep1pt = ((ak.num(electron[(electron.pt>20)]) + ak.num(muon[(muon.pt>20)]))>1)
lep1pt_30 = ((ak.num(electron[(electron.pt>30)]) + ak.num(muon[(muon.pt>30)]))>1)
lepveto = ((ak.num(vetoelectron) + ak.num(vetomuon))==2)
# define the weight
weight = Weights( len(ev) )
#mult = 1
#if dataset=='inclusive': mult = 0.0478/47.448
#if dataset=='plus': mult = 0.0036/7.205
if not dataset=='MuonEG':
# lumi weight
weight.add("weight", ev.weight*cfg['lumi'][self.year])
#weight.add("weight", ev.genWeight*cfg['lumi'][self.year]*mult)
# 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))
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(lep0)>40', lep0pt_40 )
selection.add('p_T(lep1)>20', lep1pt )
selection.add('p_T(lep1)>30', lep1pt_30 )
selection.add('SS', ( SSlepton | SSelectron | SSmuon) )
selection.add('pos', ( pos_charge ) )
selection.add('neg', ( neg_charge ) )
selection.add('N_jet>3', (ak.num(jet)>=4) )
selection.add('N_jet>4', (ak.num(jet)>=5) )
selection.add('N_central>2', (ak.num(central)>=3) )
selection.add('N_central>3', (ak.num(central)>=4) )
selection.add('N_btag>0', (ak.num(btag)>=1) )
selection.add('MET>50', (ev.MET.pt>50) )
selection.add('ST', (st>600) )
selection.add('N_fwd>0', (ak.num(fwd)>=1 ))
selection.add('delta_eta', (ak.any(delta_eta>2, axis=1) ) )
selection.add('fwd_p>500', (ak.any(j_fwd.p>500, axis=1) ) )
ss_reqs = ['lepveto', 'dilep', 'SS', 'filter', 'p_T(lep0)>25', 'p_T(lep1)>20', 'N_jet>3', 'N_central>2', 'N_btag>0']
bl_reqs = ss_reqs + ['N_fwd>0', 'N_jet>4', 'N_central>3', 'ST', 'MET>50', 'delta_eta']
sr_reqs = bl_reqs + ['fwd_p>500', 'p_T(lep0)>40', 'p_T(lep1)>30']
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)
sr_reqs_d = { sel: True for sel in sr_reqs }
SR = selection.require(**sr_reqs_d)
cutflow = Cutflow(output, ev, weight=weight)
cutflow_reqs_d = {}
for req in sr_reqs:
cutflow_reqs_d.update({req: True})
cutflow.addRow( req, selection.require(**cutflow_reqs_d) )
# first, make a few super inclusive plots
output['PV_npvs'].fill(dataset=dataset, multiplicity=ev.PV[ss_selection].npvs, weight=weight.weight()[ss_selection])
output['PV_npvsGood'].fill(dataset=dataset, multiplicity=ev.PV[ss_selection].npvsGood, weight=weight.weight()[ss_selection])
output['N_jet'].fill(dataset=dataset, multiplicity=ak.num(jet)[ss_selection], weight=weight.weight()[ss_selection])
output['N_b'].fill(dataset=dataset, multiplicity=ak.num(btag)[ss_selection], weight=weight.weight()[ss_selection])
output['N_central'].fill(dataset=dataset, multiplicity=ak.num(central)[ss_selection], weight=weight.weight()[ss_selection])
output['N_ele'].fill(dataset=dataset, multiplicity=ak.num(electron)[ss_selection], weight=weight.weight()[ss_selection])
output['N_mu'].fill(dataset=dataset, multiplicity=ak.num(electron)[ss_selection], weight=weight.weight()[ss_selection])
output['N_fwd'].fill(dataset=dataset, multiplicity=ak.num(fwd)[ss_selection], weight=weight.weight()[ss_selection])
output['nLepFromTop'].fill(dataset=dataset, multiplicity=ev[BL].nLepFromTop, weight=weight.weight()[BL])
output['nLepFromTau'].fill(dataset=dataset, multiplicity=ev.nLepFromTau[BL], weight=weight.weight()[BL])
output['nLepFromZ'].fill(dataset=dataset, multiplicity=ev.nLepFromZ[BL], weight=weight.weight()[BL])
output['nLepFromW'].fill(dataset=dataset, multiplicity=ev.nLepFromW[BL], weight=weight.weight()[BL])
output['nGenTau'].fill(dataset=dataset, multiplicity=ev.nGenTau[BL], weight=weight.weight()[BL])
output['nGenL'].fill(dataset=dataset, multiplicity=ak.num(ev.GenL[BL], axis=1), weight=weight.weight()[BL])
output['chargeFlip_vs_nonprompt'].fill(dataset=dataset, n1=n_chargeflip[ss_selection], n2=n_nonprompt[ss_selection], n_ele=ak.num(electron)[ss_selection], weight=weight.weight()[ss_selection])
output['MET'].fill(
dataset = dataset,
pt = ev.MET[ss_selection].pt,
phi = ev.MET[ss_selection].phi,
weight = weight.weight()[ss_selection]
)
output['lead_gen_lep'].fill(
dataset = dataset,
pt = ak.to_numpy(ak.flatten(leading_gen_lep[BL].pt)),
eta = ak.to_numpy(ak.flatten(leading_gen_lep[BL].eta)),
phi = ak.to_numpy(ak.flatten(leading_gen_lep[BL].phi)),
weight = weight.weight()[BL]
)
output['trail_gen_lep'].fill(
dataset = dataset,
pt = ak.to_numpy(ak.flatten(trailing_gen_lep[BL].pt)),
eta = ak.to_numpy(ak.flatten(trailing_gen_lep[BL].eta)),
phi = ak.to_numpy(ak.flatten(trailing_gen_lep[BL].phi)),
weight = weight.weight()[BL]
)
output['lead_lep'].fill(
dataset = dataset,
pt = ak.to_numpy(ak.flatten(leading_lepton[BL].pt)),
eta = ak.to_numpy(ak.flatten(leading_lepton[BL].eta)),
phi = ak.to_numpy(ak.flatten(leading_lepton[BL].phi)),
weight = weight.weight()[BL]
)
output['trail_lep'].fill(
dataset = dataset,
pt = ak.to_numpy(ak.flatten(trailing_lepton[BL].pt)),
eta = ak.to_numpy(ak.flatten(trailing_lepton[BL].eta)),
phi = ak.to_numpy(ak.flatten(trailing_lepton[BL].phi)),
weight = weight.weight()[BL]
)
output['j1'].fill(
dataset = dataset,
pt = ak.flatten(jet.pt_nom[:, 0:1][BL]),
eta = ak.flatten(jet.eta[:, 0:1][BL]),
phi = ak.flatten(jet.phi[:, 0:1][BL]),
weight = weight.weight()[BL]
)
output['j2'].fill(
dataset = dataset,
pt = ak.flatten(jet[:, 1:2][BL].pt_nom),
eta = ak.flatten(jet[:, 1:2][BL].eta),
phi = ak.flatten(jet[:, 1:2][BL].phi),
weight = weight.weight()[BL]
)
output['j3'].fill(
dataset = dataset,
pt = ak.flatten(jet[:, 2:3][BL].pt_nom),
eta = ak.flatten(jet[:, 2:3][BL].eta),
phi = ak.flatten(jet[:, 2:3][BL].phi),
weight = weight.weight()[BL]
)
return output
def process(self, events):
output = self.accumulator.identity()
# 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()
output['totalEvents']['all'] += len(events)
output['skimmedEvents']['all'] += len(ev)
## Muons
muon = Collections(ev, "Muon", "tightSSTTH").get()
vetomuon = Collections(ev, "Muon", "vetoTTH").get()
dimuon = choose(muon, 2)
SSmuon = ak.any((dimuon['0'].charge * dimuon['1'].charge) > 0, axis=1)
OSmuon = 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", "tightSSTTH").get()
vetoelectron = Collections(ev, "Electron", "vetoTTH").get()
dielectron = choose(electron, 2)
SSelectron = ak.any(
(dielectron['0'].charge * dielectron['1'].charge) > 0, axis=1)
OSelectron = 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
lepton = ak.concatenate([muon, electron], axis=1)
dilepton = cross(muon, electron)
SSlepton = ak.any((dilepton['0'].charge * dilepton['1'].charge) > 0,
axis=1)
OSlepton = ak.any((dilepton['0'].charge * dilepton['1'].charge) < 0,
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]
second_lepton = lepton[~(trailing_lepton_idx & leading_lepton_idx)]
## 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)
## forward jets
high_p_fwd = fwd[ak.singletons(ak.argmax(
fwd.p, axis=1))] # highest momentum spectator
high_pt_fwd = fwd[ak.singletons(ak.argmax(
fwd.pt_nom, axis=1))] # highest transverse momentum spectator
high_eta_fwd = fwd[ak.singletons(ak.argmax(abs(
fwd.eta), axis=1))] # most forward spectator
## Get the two leading b-jets in terms of btag score
high_score_btag = central[ak.argsort(central.btagDeepFlavB)][:, :2]
jf = cross(high_p_fwd, jet)
mjf = (jf['0'] + jf['1']).mass
deltaEta = abs(high_p_fwd.eta -
jf[ak.singletons(ak.argmax(mjf, axis=1))]['1'].eta)
deltaEtaMax = ak.max(deltaEta, axis=1)
mjf_max = ak.max(mjf, axis=1)
jj = choose(jet, 2)
mjj_max = ak.max((jj['0'] + jj['1']).mass, axis=1)
## 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)
lt = met_pt + ak.sum(muon.pt, axis=1) + ak.sum(electron.pt, axis=1)
ht_central = ak.sum(central.pt, axis=1)
# define the weight
weight = Weights(len(ev))
if not re.search(re.compile('MuonEG|DoubleMuon|DoubleEG|EGamma'),
dataset):
# lumi weight
weight.add("weight", ev.weight * cfg['lumi'][self.year])
# 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,
b_direction='central',
c_direction='central'))
# lepton SFs
weight.add("lepton", self.leptonSF.get(electron, muon))
sel = Selection(
dataset=dataset,
events=ev,
year=self.year,
ele=electron,
ele_veto=vetoelectron,
mu=muon,
mu_veto=vetomuon,
jet_all=jet,
jet_central=central,
jet_btag=btag,
jet_fwd=fwd,
met=ev.MET,
)
BL = sel.dilep_baseline(SS=False)
BL_minusNb = sel.dilep_baseline(SS=False, omit=['N_btag>0'])
output['N_b'].fill(dataset=dataset,
multiplicity=ak.num(btag)[BL_minusNb],
weight=weight.weight()[BL_minusNb])
if re.search(re.compile('MuonEG|DoubleMuon|DoubleEG|EGamma'), dataset):
#rle = ak.to_numpy(ak.zip([ev.run, ev.luminosityBlock, ev.event]))
run_ = ak.to_numpy(ev.run)
lumi_ = ak.to_numpy(ev.luminosityBlock)
event_ = ak.to_numpy(ev.event)
output['%s_run' % dataset] += processor.column_accumulator(
run_[BL])
output['%s_lumi' % dataset] += processor.column_accumulator(
lumi_[BL])
output['%s_event' % dataset] += processor.column_accumulator(
event_[BL])
# Now, take care of systematic unceratinties
if not re.search(re.compile('MuonEG|DoubleMuon|DoubleEG|EGamma'),
dataset):
alljets = getJets(ev, minPt=0, maxEta=4.7)
alljets = alljets[(alljets.jetId > 1)]
for var in self.variations:
# get the collections that change with the variations
btag = getBTagsDeepFlavB(
jet,
year=self.year) # should study working point for DeepJet
weight = Weights(len(ev))
weight.add("weight", ev.weight * cfg['lumi'][self.year])
weight.add("PU",
ev.puWeight,
weightUp=ev.puWeightUp,
weightDown=ev.puWeightDown,
shift=False)
if var == 'centralUp':
weight.add(
"btag",
self.btagSF.Method1a(btag,
light,
b_direction='central',
c_direction='up'))
elif var == 'centralDown':
weight.add(
"btag",
self.btagSF.Method1a(btag,
light,
b_direction='central',
c_direction='down'))
elif var == 'upCentral':
weight.add(
"btag",
self.btagSF.Method1a(btag,
light,
b_direction='up',
c_direction='central'))
elif var == 'downCentral':
weight.add(
"btag",
self.btagSF.Method1a(btag,
light,
b_direction='down',
c_direction='central'))
weight.add("lepton", self.leptonSF.get(electron, muon))
met = ev.MET
sel = Selection(
dataset=dataset,
events=ev,
year=self.year,
ele=electron,
ele_veto=vetoelectron,
mu=muon,
mu_veto=vetomuon,
jet_all=jet,
jet_central=central,
jet_btag=btag,
jet_fwd=fwd,
met=met,
)
BL = sel.dilep_baseline(SS=False)
BL_minusNb = sel.dilep_baseline(SS=False, omit=['N_btag>0'])
output['N_b_' + var].fill(
dataset=dataset,
multiplicity=ak.num(btag)[BL_minusNb],
weight=weight.weight()[BL_minusNb])
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", "tight").get()
electron = electron[(electron.miniPFRelIso_all < 0.12)
& (electron.pt > 20) & (abs(electron.eta) < 2.4)]
gen_matched_electron = electron[((electron.genPartIdx >= 0) & (abs(
electron.matched_gen.pdgId) == 11))]
n_gen = ak.num(gen_matched_electron)
is_flipped = ((gen_matched_electron.matched_gen.pdgId *
(-1) == gen_matched_electron.pdgId) &
(abs(gen_matched_electron.pdgId) == 11))
#is_flipped = (abs(ev.GenPart[gen_matched_electron.genPartIdx].pdgId) == abs(gen_matched_electron.pdgId))&(ev.GenPart[gen_matched_electron.genPartIdx].pdgId/abs(ev.GenPart[gen_matched_electron.genPartIdx].pdgId) != gen_matched_electron.pdgId/abs(gen_matched_electron.pdgId))
flipped_electron = gen_matched_electron[is_flipped]
n_flips = ak.num(flipped_electron)
sielectron = choose(electron, 1)
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]
## MET -> can switch to puppi MET
met_pt = ev.MET.pt
met_phi = ev.MET.phi
# setting up the various weights
weight = Weights(len(ev))
weight2 = Weights(len(ev))
if not dataset == 'MuonEG':
# generator weight
weight.add("weight", ev.genWeight)
weight2.add("weight", ev.genWeight)
weight2.add("charge flip",
self.charge_flip_ratio.flip_ratio(sielectron['0']))
#selections
filters = getFilters(ev, year=self.year, dataset=dataset)
electr = ((ak.num(electron) == 2))
ss = (SSelectron)
gen = (n_gen >= 1)
flip = (n_flips >= 1)
selection = PackedSelection()
selection.add('filter', (filters))
selection.add('electr', electr)
selection.add('ss', ss)
selection.add('flip', flip)
selection.add('gen', gen)
bl_reqs = ['filter', 'electr']
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)
f_reqs = bl_reqs + ['gen', 'flip']
f_reqs_d = {sel: True for sel in f_reqs}
flip_sel = selection.require(**f_reqs_d)
#outputs
output['N_ele'].fill(dataset=dataset,
multiplicity=ak.num(electron)[flip_sel],
weight=weight.weight()[flip_sel])
output['electron_flips'].fill(dataset=dataset,
multiplicity=n_flips[flip_sel],
weight=weight.weight()[flip_sel])
output['N_ele2'].fill(dataset=dataset,
multiplicity=ak.num(electron)[baseline],
weight=weight2.weight()[baseline])
output['electron_flips2'].fill(dataset=dataset,
multiplicity=n_flips[baseline],
weight=weight2.weight()[baseline])
output["electron"].fill(
dataset=dataset,
pt=ak.to_numpy(ak.flatten(flipped_electron[flip_sel].pt)),
eta=ak.to_numpy(ak.flatten(abs(flipped_electron[flip_sel].eta))),
#phi = ak.to_numpy(ak.flatten(leading_electron[baseline].phi)),
weight=weight.weight()[flip_sel])
output["electron2"].fill(
dataset=dataset,
pt=ak.to_numpy(ak.flatten(leading_electron[baseline].pt)),
eta=ak.to_numpy(ak.flatten(abs(leading_electron[baseline].eta))),
#phi = ak.to_numpy(ak.flatten(leading_electron[baseline].phi)),
weight=weight2.weight()[baseline])
return output
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']
# load the config - probably not needed anymore
# cfg = loadConfig()
output['totalEvents']['all'] += len(events)
output['skimmedEvents']['all'] += len(ev)
### For FCNC, we want electron -> tightTTH
electron = Collections(ev, "Electron", "tightFCNC").get()
fakeableelectron = Collections(ev, "Electron", "fakeableFCNC").get()
muon = Collections(ev, "Muon", "tightFCNC").get()
fakeablemuon = Collections(ev, "Muon", "fakeableFCNC").get()
##Jets
Jets = events.Jet
## MET -> can switch to puppi MET
met_pt = ev.MET.pt
met_phi = ev.MET.phi
lepton = fakeablemuon #ak.concatenate([fakeablemuon, fakeableelectron], axis=1)
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)
selection = PackedSelection()
selection.add('MET<20', (ev.MET.pt < 20))
selection.add('mt<20', min_mt_lep_met < 20)
#selection.add('MET<19', (ev.MET.pt<19) )
selection_reqs = ['MET<20', 'mt<20'] #, 'MET<19']
fcnc_reqs_d = {sel: True for sel in selection_reqs}
fcnc_selection = selection.require(**fcnc_reqs_d)
# define the weight
weight = Weights(len(ev))
if not dataset == 'MuonEG':
# generator weight
weight.add("weight", ev.genWeight)
jets = getJets(
ev, maxEta=2.4, minPt=25, pt_var='pt'
) #& (ak.num(jets[~match(jets, fakeablemuon, deltaRCut=1.0)])>=1)
single_muon_sel = (ak.num(muon) == 1) & (ak.num(fakeablemuon) == 1) | (
ak.num(muon) == 0) & (ak.num(fakeablemuon) == 1)
single_electron_sel = (ak.num(electron) == 1) & (
ak.num(fakeableelectron)
== 1) | (ak.num(electron) == 0) & (ak.num(fakeableelectron) == 1)
fcnc_muon_sel = (ak.num(
jets[~match(jets, fakeablemuon, deltaRCut=1.0)]) >=
1) & fcnc_selection & single_muon_sel
fcnc_electron_sel = (ak.num(
jets[~match(jets, fakeableelectron, deltaRCut=1.0)]) >=
1) & fcnc_selection & single_electron_sel
tight_muon_sel = (ak.num(muon) == 1) & fcnc_muon_sel
loose_muon_sel = (ak.num(fakeablemuon) == 1) & fcnc_muon_sel
tight_electron_sel = (ak.num(electron) == 1) & fcnc_electron_sel
loose_electron_sel = (ak.num(fakeableelectron)
== 1) & fcnc_electron_sel
output['single_mu_fakeable'].fill(
dataset=dataset,
pt=ak.to_numpy(ak.flatten(fakeablemuon[loose_muon_sel].conePt)),
eta=np.abs(
ak.to_numpy(ak.flatten(fakeablemuon[loose_muon_sel].eta))))
output['single_mu'].fill(
dataset=dataset,
pt=ak.to_numpy(ak.flatten(muon[tight_muon_sel].conePt)),
eta=np.abs(ak.to_numpy(ak.flatten(muon[tight_muon_sel].eta))))
output['single_e_fakeable'].fill(
dataset=dataset,
pt=ak.to_numpy(
ak.flatten(fakeableelectron[loose_electron_sel].conePt)),
eta=np.abs(
ak.to_numpy(
ak.flatten(fakeableelectron[loose_electron_sel].eta))))
output['single_e'].fill(
dataset=dataset,
pt=ak.to_numpy(ak.flatten(electron[tight_electron_sel].conePt)),
eta=np.abs(
ak.to_numpy(ak.flatten(electron[tight_electron_sel].eta))))
if self.debug:
#create pandas dataframe for debugging
passed_events = ev[tight_muon_sel]
passed_muons = muon[tight_muon_sel]
event_p = ak.to_pandas(passed_events[["event"]])
event_p["MET_PT"] = passed_events["MET"]["pt"]
event_p["mt"] = min_mt_lep_met[tight_muon_sel]
event_p["num_tight_mu"] = ak.to_numpy(ak.num(muon)[tight_muon_sel])
event_p["num_loose_mu"] = ak.num(fakeablemuon)[tight_muon_sel]
muon_p = ak.to_pandas(
ak.flatten(passed_muons)[[
"pt", "conePt", "eta", "dz", "dxy", "ptErrRel",
"miniPFRelIso_all", "jetRelIsoV2", "jetRelIso",
"jetPtRelv2"
]])
#convert to numpy array for the output
events_array = pd.concat([muon_p, event_p], axis=1)
events_to_add = [6886009]
for e in events_to_add:
tmp_event = ev[ev.event == e]
added_event = ak.to_pandas(tmp_event[["event"]])
added_event["MET_PT"] = tmp_event["MET"]["pt"]
added_event["mt"] = min_mt_lep_met[ev.event == e]
added_event["num_tight_mu"] = ak.to_numpy(
ak.num(muon)[ev.event == e])
added_event["num_loose_mu"] = ak.to_numpy(
ak.num(fakeablemuon)[ev.event == e])
add_muon = ak.to_pandas(
ak.flatten(muon[ev.event == e])[[
"pt", "conePt", "eta", "dz", "dxy", "ptErrRel",
"miniPFRelIso_all", "jetRelIsoV2", "jetRelIso",
"jetPtRelv2"
]])
add_concat = pd.concat([add_muon, added_event], axis=1)
events_array = pd.concat([events_array, add_concat], axis=0)
output['muons_df'] += processor.column_accumulator(
events_array.to_numpy())
return output
def test_weights_partial():
from coffea.analysis_tools import Weights
counts, _, _ = dummy_jagged_eta_pt()
w1 = np.random.normal(loc=1.0, scale=0.01, size=counts.size)
w2 = np.random.normal(loc=1.3, scale=0.05, size=counts.size)
weights = Weights(counts.size, storeIndividual=True)
weights.add("w1", w1)
weights.add("w2", w2)
test_exclude_none = weights.weight()
assert np.all(np.abs(test_exclude_none - w1 * w2) < 1e-6)
test_exclude1 = weights.partial_weight(exclude=["w1"])
assert np.all(np.abs(test_exclude1 - w2) < 1e-6)
test_include1 = weights.partial_weight(include=["w1"])
assert np.all(np.abs(test_include1 - w1) < 1e-6)
test_exclude2 = weights.partial_weight(exclude=["w2"])
assert np.all(np.abs(test_exclude2 - w1) < 1e-6)
test_include2 = weights.partial_weight(include=["w2"])
assert np.all(np.abs(test_include2 - w2) < 1e-6)
test_include_both = weights.partial_weight(include=["w1", "w2"])
assert np.all(np.abs(test_include_both - w1 * w2) < 1e-6)
# Check that exception is thrown if arguments are incompatible
error_raised = False
try:
weights.partial_weight(exclude=["w1"], include=["w2"])
except ValueError:
error_raised = True
assert error_raised
error_raised = False
try:
weights.partial_weight()
except ValueError:
error_raised = True
assert error_raised
# Check that exception is thrown if individual weights
# are not saved from the start
weights = Weights(counts.size, storeIndividual=False)
weights.add("w1", w1)
weights.add("w2", w2)
error_raised = False
try:
weights.partial_weight(exclude=["test"], include=["test"])
except ValueError:
error_raised = True
assert error_raised
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):
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
