def SS_selection(lep1, lep2):
selection = PackedSelection()
is_dilep = ((ak.num(lep1) + ak.num(lep2))==2)
pos_charge = ((ak.sum(lep1.pdgId, axis=1) + ak.sum(lep2.pdgId, axis=1))<0)
neg_charge = ((ak.sum(lep1.pdgId, axis=1) + ak.sum(lep2.pdgId, axis=1))>0)
dilep2 = choose(lep2, 2)
dilep1 = choose(lep1, 2)
dilep = cross(lep2, lep1)
is_SS = ( ak.any((dilep2['0'].charge * dilep2['1'].charge)>0, axis=1) | \
ak.any((dilep1['0'].charge * dilep1['1'].charge)>0, axis=1) | \
ak.any((dilep['0'].charge * dilep['1'].charge)>0, axis=1) )
selection.add('SS', is_SS)
ss_reqs = ['SS']
ss_reqs_d = {sel: True for sel in ss_reqs}
ss_selection = selection.require(**ss_reqs_d)
return ss_selection
def dilep_baseline(self, omit=[], cutflow=None, tight=False, SS=True):
'''
give it a cutflow object if you want it to be filed.
cuts in the omit list will not be applied
'''
self.selection = PackedSelection()
is_dilep = ((ak.num(self.ele) + ak.num(self.mu))==2)
pos_charge = ((ak.sum(self.ele.pdgId, axis=1) + ak.sum(self.mu.pdgId, axis=1))<0)
neg_charge = ((ak.sum(self.ele.pdgId, axis=1) + ak.sum(self.mu.pdgId, axis=1))>0)
lep0pt = ((ak.num(self.ele[(self.ele.pt>25)]) + ak.num(self.mu[(self.mu.pt>25)]))>0)
lep1pt = ((ak.num(self.ele[(self.ele.pt>20)]) + ak.num(self.mu[(self.mu.pt>20)]))>1)
lepveto = ((ak.num(self.ele_veto) + ak.num(self.mu_veto))==2)
dimu = choose(self.mu, 2)
diele = choose(self.ele, 2)
dilep = cross(self.mu, self.ele)
if SS:
is_SS = ( ak.any((dimu['0'].charge * dimu['1'].charge)>0, axis=1) | \
ak.any((diele['0'].charge * diele['1'].charge)>0, axis=1) | \
ak.any((dilep['0'].charge * dilep['1'].charge)>0, axis=1) )
else:
is_OS = ( ak.any((dimu['0'].charge * dimu['1'].charge)<0, axis=1) | \
ak.any((diele['0'].charge * diele['1'].charge)<0, axis=1) | \
ak.any((dilep['0'].charge * dilep['1'].charge)<0, axis=1) )
lepton = ak.concatenate([self.ele, self.mu], axis=1)
lepton_pdgId_pt_ordered = ak.fill_none(
ak.pad_none(
lepton[ak.argsort(lepton.pt, ascending=False)].pdgId, 2, clip=True),
0)
triggers = getTriggers(self.events,
ak.flatten(lepton_pdgId_pt_ordered[:,0:1]),
ak.flatten(lepton_pdgId_pt_ordered[:,1:2]), year=self.year, dataset=self.dataset)
ht = ak.sum(self.jet_all.pt, axis=1)
st = self.met.pt + ht + ak.sum(self.mu.pt, axis=1) + ak.sum(self.ele.pt, axis=1)
self.selection.add('lepveto', lepveto)
self.selection.add('dilep', is_dilep)
#self.selection.add('filter', self.filters)
self.selection.add('trigger', triggers)
self.selection.add('p_T(lep0)>25', lep0pt)
self.selection.add('p_T(lep1)>20', lep1pt)
if SS:
self.selection.add('SS', is_SS )
else:
self.selection.add('OS', is_OS )
self.selection.add('N_jet>3', (ak.num(self.jet_all)>3) )
self.selection.add('N_jet>4', (ak.num(self.jet_all)>4) )
self.selection.add('N_central>2', (ak.num(self.jet_central)>2) )
self.selection.add('N_central>3', (ak.num(self.jet_central)>3) )
self.selection.add('N_btag>0', (ak.num(self.jet_btag)>0) )
self.selection.add('N_fwd>0', (ak.num(self.jet_fwd)>0) )
self.selection.add('MET>30', (self.met.pt>30) )
self.selection.add('MET>50', (self.met.pt>50) )
self.selection.add('ST>600', (st>600) )
ss_reqs = [
# 'filter',
'lepveto',
'dilep',
'p_T(lep0)>25',
'p_T(lep1)>20',
'trigger',
'SS' if SS else 'OS',
'N_jet>3',
'N_central>2',
'N_btag>0',
'MET>30',
'N_fwd>0',
]
if tight:
ss_reqs += [
'N_jet>4',
'N_central>3',
'ST>600',
'MET>50',
#'delta_eta',
]
ss_reqs_d = { sel: True for sel in ss_reqs if not sel in omit }
ss_selection = self.selection.require(**ss_reqs_d)
if cutflow:
#
cutflow_reqs_d = {}
for req in ss_reqs:
cutflow_reqs_d.update({req: True})
cutflow.addRow( req, self.selection.require(**cutflow_reqs_d) )
return ss_selection
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
