def analyze(self, event):
"""process event, return True (go to next module) or False (fail, go to next event)"""
event = mappedEvent(event, mapname=self._branch_map)
for key in self.formulas.keys():
self.out.fillBranch(key, self.formulas[key](event))
return True
def analyze(self, event):
"""process event, return True (go to next module) or False (fail, go to next event)"""
event = mappedEvent(event, mapname=self._branch_map)
values = []
ev = event.event
values.append(self.GetValue(event, "Lepton_pt[0]") * math.cos(self.GetValue(event, "Lepton_phi[0]")))
values.append(self.GetValue(event, "Lepton_pt[0]") * math.sin(self.GetValue(event, "Lepton_phi[0]")))
values.append(self.GetValue(event, "Lepton_pt[0]") * math.sinh(self.GetValue(event, "Lepton_eta[0]")))
values.append(self.GetValue(event, "Lepton_pt[1]") * math.cos(self.GetValue(event, "Lepton_phi[1]")))
values.append(self.GetValue(event, "Lepton_pt[1]") * math.sin(self.GetValue(event, "Lepton_phi[1]")))
values.append(self.GetValue(event, "Lepton_pt[1]") * math.sinh(self.GetValue(event, "Lepton_eta[1]")))
if self.GetValue(event, "nCleanJet")>=1:
values.append(self.GetValue(event, "CleanJet_pt[0]") * math.cos(self.GetValue(event, "CleanJet_phi[0]")))
values.append(self.GetValue(event, "CleanJet_pt[0]") * math.sin(self.GetValue(event, "CleanJet_phi[0]")))
values.append(self.GetValue(event, "CleanJet_pt[0]") * math.sinh(self.GetValue(event, "CleanJet_eta[0]")))
else:
values.append(0.0)
values.append(0.0)
values.append(0.0)
if self.GetValue(event, "nCleanJet")>=2:
values.append(self.GetValue(event, "CleanJet_pt[1]") * math.cos(self.GetValue(event, "CleanJet_phi[1]")))
values.append(self.GetValue(event, "CleanJet_pt[1]") * math.sin(self.GetValue(event, "CleanJet_phi[1]")))
values.append(self.GetValue(event, "CleanJet_pt[1]") * math.sinh(self.GetValue(event, "CleanJet_eta[1]")))
else:
values.append(0.0)
values.append(0.0)
values.append(0.0)
values.append(self.GetValue(event, "PuppiMET_pt") * math.cos(self.GetValue(event, "PuppiMET_phi")))
values.append(self.GetValue(event, "PuppiMET_pt") * math.sin(self.GetValue(event, "PuppiMET_phi")))
values.append(self.GetValue(event, "dphilmet"))
values.append(self.GetValue(event, "dphilmet1"))
values.append(self.GetValue(event, "dphilmet2"))
values.append(self.GetValue(event, "mll"))
values.append(self.GetValue(event, "mTi"))
values.append(self.GetValue(event, "mth"))
values.append(self.GetValue(event, "mtw1"))
values.append(self.GetValue(event, "mtw2"))
values.append(self.GetValue(event, "ht"))
values_stacked = np.hstack(values).reshape(1, len(values))
values_preprocessed = self.preprocessing[ev % 2].transform(values_stacked)
response = self.classifiers[ev % 2].predict(values_preprocessed)
response = np.squeeze(response)
self.out.fillBranch("DNN_mth", response)
return True
def analyze(self, event):
"""process event, return True (go to next module) or False (fail, go to next event)"""
event = mappedEvent(event, mapname=self._branch_map)
for iMva in self.mvaDic:
jVar = 0
for iVar in self.mvaDic[iMva]['inputVars']:
self.mvaDic[iMva]['inputs'][jVar][0] = eval(
self.mvaDic[iMva]['inputVars'][iVar])
jVar += 1
#print "====== ",iMva
#print self.mvaDic[iMva]['inputVars'].keys()
#print self.mvaDic[iMva]['inputs']
val = self.mvaDic[iMva]['reader'].EvaluateMVA(
self.mvaDic[iMva]['type'])
#print val
self.out.fillBranch(iMva, val)
#self.out.fillBranch(iMva, self.mvaDic[iMva]['reader'].EvaluateMVA(self.mvaDic[iMva]['type']))
return True
def analyze(self, event):
# Read branches that may be created by previous step in the chain
# It's important to read them like this in case they
# are created by the step before in a PostProcessor chain.
event = mappedEvent(event, mapname=self._branch_map)
self.nFatJet = event.nCleanFatJet
self.rawJet_coll = Collection(event, 'Jet')
self.Jet_coll = Collection(event, 'CleanJet')
self.JetNotFat_coll = Collection(event, 'CleanJetNotFat')
# do this check at every event, as other modules might have read further branches
# if event._tree._ttreereaderversion > self._ttreereaderversion:
# self.initReaders(event._tree)
category = -1
# Take the 4-momenta of the CleanJets.
# If FatJets are present only the CleanJetNotFat are taken. A list of indexes
# referring to the CleanJet collection is keeps to save the final result
good_jets, good_jets_ids = self.get_jets_vectors()
# N.B. The VBS_jets and V_jets index are positions in the list of
# good_jets (Jet not overlapping with Fatjet with a minpt).
# We want to save a reference to the CleanJet collection.
if self.nFatJet == 1 and len(good_jets) >= 2:
###################################
# Boosted category
##################################
category = 0
# Vbs jets with different algo
for key, algo in pairing_strategies_fatjet.items():
VBS_jets = [-1, -1]
V_jets = [-1, -1]
# N.B. always get back CleanJet collection ids
VBS_jets = [good_jets_ids[ij] for ij in algo(good_jets)]
self.out.fillBranch("VBS_jets_" + key, VBS_jets)
self.out.fillBranch("V_jets_" + key, V_jets)
elif self.nFatJet == 0 and len(good_jets) >= 4:
##############################
# Resolved category
###########################
category = 1
# Cache of association algos
# (N.B. indexes by good_jets collections)
cache = {} # algo: ( associated_jets, remaining jets)
if self.mode == "ALL":
for key, algos in pairing_strategies_resolved.items():
self.perform_jet_association(key, good_jets, good_jets_ids,
cache)
else:
if self.mode in pairing_strategies_resolved:
self.perform_jet_association(self.mode, good_jets,
good_jets_ids, cache)
else:
print("ERROR! Selected pairing mode not found!!")
#return False
else:
# Don't use event in VBSjjlnu analysis
# or it's boosted but with not enough jets,
# or it is not boosted and it has less than 4 jets with minpt
#print("Event removed")
category = -1
# Fill the category
self.out.fillBranch("VBS_category", category)
"""return True (go to next module) or False (fail, go to next event)"""
return True
def analyze(self, event):
"""process event, return True (go to next module) or False (fail, go to next event)"""
#if event._tree._ttreereaderversion > self._ttreereaderversion: # do this check at every event, as other modules might have read further branches
# self.initReaders(event._tree)
# do NOT access other branches in python between the check/call to initReaders and the call to C++ worker code
event = mappedEvent(event, mapname=self._branch_map)
lepton_col = Collection(event, 'Lepton')
nLep = len(lepton_col)
#try:
nvtx = event.PV_npvsGood #event. => find nvtx
#except:
# nvtx = event.PV_npvs
run_period = event.run_period
lep_var = {}
lep_var['RecoSF'] = []
lep_var['RecoSF_Up'] = []
lep_var['RecoSF_Down'] = []
el_wp_var = {}
mu_wp_var = {}
for wp in self.ElectronWP[self.cmssw]['TightObjWP']:
for postfix in self.wp_sf_pf:
el_wp_var[wp + postfix] = []
for wp in self.MuonWP[self.cmssw]['TightObjWP']:
for postfix in self.wp_sf_pf:
mu_wp_var[wp + postfix] = []
#------ Lepton Loop
for iLep in range(nLep):
pdgId = lepton_col[iLep]['pdgId']
pt = lepton_col[iLep]['pt']
eta = lepton_col[iLep]['eta']
did_reco = False
reco_sf, reco_sf_dwn, reco_sf_up = 0., 0., 0.
# Lepton id's
if abs(lepton_col[iLep]['pdgId']) == 11:
for wp in self.ElectronWP[self.cmssw]['TightObjWP']:
if not did_reco:
reco_sf, reco_sf_dwn, reco_sf_up = self.get_reco_SF(
pdgId, pt, eta, nvtx, wp, run_period)
lep_var['RecoSF'].append(reco_sf)
lep_var['RecoSF_Up'].append(reco_sf + reco_sf_up)
lep_var['RecoSF_Down'].append(reco_sf - reco_sf_dwn)
did_reco = True
idiso_sf, idiso_sf_dwn, idiso_sf_up, idiso_sf_sys = self.get_idIso_SF(
pdgId, pt, eta, nvtx, wp, run_period)
el_wp_var[wp + '_IdIsoSF'].append(idiso_sf)
el_wp_var[wp + '_IdIsoSF_Up'].append(idiso_sf +
idiso_sf_up)
el_wp_var[wp + '_IdIsoSF_Down'].append(idiso_sf -
idiso_sf_dwn)
el_wp_var[wp + '_IdIsoSF_Syst'].append(idiso_sf +
idiso_sf_sys)
el_wp_var[wp + '_TotSF'].append(idiso_sf * reco_sf)
el_wp_var[wp +
'_TotSF_Up'].append(idiso_sf * reco_sf +
math.sqrt(idiso_sf_up**2 +
reco_sf_up**2 +
idiso_sf_sys**2))
el_wp_var[wp +
'_TotSF_Down'].append(idiso_sf * reco_sf -
math.sqrt(idiso_sf_dwn**2 +
reco_sf_dwn**2 +
idiso_sf_sys**2))
for wp in self.MuonWP[self.cmssw]['TightObjWP']:
mu_wp_var[wp + '_IdIsoSF'].append(1.0)
mu_wp_var[wp + '_IdIsoSF_Up'].append(0.0)
mu_wp_var[wp + '_IdIsoSF_Down'].append(0.0)
mu_wp_var[wp + '_IdIsoSF_Syst'].append(0.0)
mu_wp_var[wp + '_TotSF'].append(reco_sf)
mu_wp_var[wp + '_TotSF_Up'].append(reco_sf + reco_sf_up)
mu_wp_var[wp + '_TotSF_Down'].append(reco_sf - reco_sf_dwn)
elif abs(lepton_col[iLep]['pdgId']) == 13:
for wp in self.MuonWP[self.cmssw]['TightObjWP']:
if not did_reco:
reco_sf, reco_sf_dwn, reco_sf_up = self.get_reco_SF(
pdgId, pt, eta, nvtx, wp, run_period)
lep_var['RecoSF'].append(reco_sf)
lep_var['RecoSF_Up'].append(reco_sf + reco_sf_up)
lep_var['RecoSF_Down'].append(reco_sf - reco_sf_dwn)
did_reco = True
idiso_sf, idiso_sf_dwn, idiso_sf_up, idiso_sf_sys = self.get_idIso_SF(
pdgId, pt, eta, nvtx, wp, run_period)
mu_wp_var[wp + '_IdIsoSF'].append(idiso_sf)
mu_wp_var[wp + '_IdIsoSF_Up'].append(idiso_sf +
idiso_sf_up)
mu_wp_var[wp + '_IdIsoSF_Down'].append(idiso_sf -
idiso_sf_dwn)
mu_wp_var[wp + '_IdIsoSF_Syst'].append(idiso_sf +
idiso_sf_sys)
mu_wp_var[wp + '_TotSF'].append(idiso_sf * reco_sf)
mu_wp_var[wp +
'_TotSF_Up'].append(idiso_sf * reco_sf +
math.sqrt(idiso_sf_up**2 +
reco_sf_up**2 +
idiso_sf_sys**2))
mu_wp_var[wp +
'_TotSF_Down'].append(idiso_sf * reco_sf -
math.sqrt(idiso_sf_dwn**2 +
reco_sf_dwn**2 +
idiso_sf_sys**2))
for wp in self.ElectronWP[self.cmssw]['TightObjWP']:
el_wp_var[wp + '_IdIsoSF'].append(1.0)
el_wp_var[wp + '_IdIsoSF_Up'].append(0.0)
el_wp_var[wp + '_IdIsoSF_Down'].append(0.0)
el_wp_var[wp + '_IdIsoSF_Syst'].append(0.0)
el_wp_var[wp + '_TotSF'].append(reco_sf)
el_wp_var[wp + '_TotSF_Up'].append(reco_sf + reco_sf_up)
el_wp_var[wp + '_TotSF_Down'].append(reco_sf - reco_sf_dwn)
# Filling branches
#print "[jhchoi] fillbranch"
for key in lep_var:
self.out.fillBranch('Lepton_' + key, lep_var[key])
for key in el_wp_var:
self.out.fillBranch('Lepton_tightElectron_' + key, el_wp_var[key])
for key in mu_wp_var:
self.out.fillBranch('Lepton_tightMuon_' + key, mu_wp_var[key])
if event.event % 10000 == 1: ##To flush memory of ttree
#self.out._tree.AutoSave("FlushBaskets")
self.out._tree.AutoSave("FlushBaskets")
#print "[jhchoi]end of fillbranch"
return True
def analyze(self, event):
"""process event, return True (go to next module) or False (fail, go to next event)"""
event = mappedEvent(event, mapname=self._branch_map)
withindex = "[0]" # There was a case once where the entries in a sample weren't a list, for some reason
try:
wpt = self.GetValue(event,
"HM_CleanFatJetPassMBoosted_pt" + withindex)
ValidEntry = True
except IndexError:
ValidEntry = False
except TypeError:
withindex = ''
if self.GetValue(
event,
"HM_nCleanFatJetPassMBoosted") >= 1 and ValidEntry: # Boosted
wpt = self.GetValue(event,
"HM_CleanFatJetPassMBoosted_pt" + withindex)
weta = self.GetValue(event,
"HM_CleanFatJetPassMBoosted_eta" + withindex)
wphi = self.GetValue(event,
"HM_CleanFatJetPassMBoosted_phi" + withindex)
wmass = self.GetValue(
event, "HM_CleanFatJetPassMBoosted_mass" + withindex)
WWmass = self.GetValue(
event, "HM_CleanFatJetPassMBoosted_HlnFat_mass" + withindex)
wptmww = self.GetValue(
event, "HM_CleanFatJetPassMBoosted_WptOvHfatM" + withindex)
tau21 = self.GetValue(
event, "HM_CleanFatJetPassMBoosted_tau21" + withindex)
wr1pt = 0.0
wr1eta = 0.0
wr1phi = 0.0
wr2pt = 0.0
wr2eta = 0.0
wr2phi = 0.0
jetidx1 = 0
jetidx2 = 1
elif int(self.GetValue(event, "HM_idx_j1")) != -1: # Resolved
wpt = self.GetValue(event, "HM_Whad_pt")
weta = self.GetValue(event, "HM_Whad_eta")
wphi = self.GetValue(event, "HM_Whad_phi")
wmass = self.GetValue(event, "HM_Whad_mass")
WWmass = self.GetValue(event, "HM_Hlnjj_mass")
wptmww = self.GetValue(event, "HM_WptOvHak4M")
tau21 = 0.0
nojet = [
int(self.GetValue(event, "HM_idx_j1")),
int(self.GetValue(event, "HM_idx_j2"))
]
wr1pt = self.GetValue(event, "CleanJet_pt[" + str(nojet[0]) + "]")
wr1eta = self.GetValue(event,
"CleanJet_eta[" + str(nojet[0]) + "]")
wr1phi = self.GetValue(event,
"CleanJet_phi[" + str(nojet[0]) + "]")
wr2pt = self.GetValue(event, "CleanJet_pt[" + str(nojet[1]) + "]")
wr2eta = self.GetValue(event,
"CleanJet_eta[" + str(nojet[1]) + "]")
wr2phi = self.GetValue(event,
"CleanJet_phi[" + str(nojet[1]) + "]")
goodjet = [alpha for alpha in range(4) if alpha not in nojet]
jetidx1 = goodjet[0]
jetidx2 = goodjet[1]
else: # Neither boosted nor resolved: Event not selected
self.out.fillBranch("DNN_mth", 0.0)
return True
if self.GetValue(event, "nCleanJet") >= 1 + jetidx1:
jetpt1 = self.GetValue(event, "CleanJet_pt[" + str(jetidx1) + "]")
jeteta1 = self.GetValue(event,
"CleanJet_eta[" + str(jetidx1) + "]")
jetphi1 = self.GetValue(event,
"CleanJet_phi[" + str(jetidx1) + "]")
else:
jetpt1 = 0.0
jeteta1 = 0.0
jetphi1 = 0.0
if self.GetValue(event, "nCleanJet") >= 1 + jetidx2:
jetpt2 = self.GetValue(event, "CleanJet_pt[" + str(jetidx2) + "]")
jeteta2 = self.GetValue(event,
"CleanJet_eta[" + str(jetidx2) + "]")
jetphi2 = self.GetValue(event,
"CleanJet_phi[" + str(jetidx2) + "]")
else:
jetpt2 = 0.0
jeteta2 = 0.0
jetphi2 = 0.0
values = []
ev = event.event
values.append(
self.GetValue(event, "Lepton_pt[0]") *
math.cos(self.GetValue(event, "Lepton_phi[0]")))
values.append(
self.GetValue(event, "Lepton_pt[0]") *
math.sin(self.GetValue(event, "Lepton_phi[0]")))
values.append(
self.GetValue(event, "Lepton_pt[0]") *
math.sinh(self.GetValue(event, "Lepton_eta[0]")))
values.append(jetpt1 * math.cos(jetphi1))
values.append(jetpt1 * math.sin(jetphi1))
values.append(jetpt1 * math.sinh(jeteta1))
values.append(jetpt2 * math.cos(jetphi2))
values.append(jetpt2 * math.sin(jetphi2))
values.append(jetpt2 * math.sinh(jeteta2))
values.append(wpt * math.cos(wphi))
values.append(wpt * math.sin(wphi))
values.append(wpt * math.sinh(weta))
values.append(wmass)
values.append(
self.GetValue(event, "HM_Wlep_pt_Puppi") *
math.cos(self.GetValue(event, "HM_Wlep_phi_Puppi")))
values.append(
self.GetValue(event, "HM_Wlep_pt_Puppi") *
math.sin(self.GetValue(event, "HM_Wlep_phi_Puppi")))
values.append(
self.GetValue(event, "HM_Wlep_pt_Puppi") *
math.sinh(self.GetValue(event, "HM_Wlep_eta_Puppi")))
values.append(self.GetValue(event, "HM_Wlep_mass_Puppi"))
values.append(wr1pt * math.cos(wr1phi))
values.append(wr1pt * math.sin(wr1phi))
values.append(wr1pt * math.sinh(wr1eta))
values.append(wr2pt * math.cos(wr2phi))
values.append(wr2pt * math.sin(wr2phi))
values.append(wr2pt * math.sinh(wr2eta))
values.append(
self.GetValue(event, "PuppiMET_pt") *
math.cos(self.GetValue(event, "PuppiMET_phi")))
values.append(
self.GetValue(event, "PuppiMET_pt") *
math.sin(self.GetValue(event, "PuppiMET_phi")))
values.append(wptmww)
values.append(tau21)
values.append(WWmass)
values_stacked = np.hstack(values).reshape(1, len(values))
values_preprocessed = self.preprocessing[ev %
2].transform(values_stacked)
response = self.classifiers[ev % 2].predict(values_preprocessed)
response = np.squeeze(response)
self.out.fillBranch("DNN_mth", response)
return True
def analyze(self, event):
# Let's map the event with the branch mapping we are using in the chain
event = mappedEvent(event, mapname=self._output_branch_map)
# output SF: nominal, up, down
output_SF = [
1.,
1.,
1.,
]
# We need to get a list of FatJet passing kinematical cuts and lepton cleaning
# and then check the tau21 selection to assign the correct SF
leptons_coll = Collection(event, "Lepton")
fatjets_coll = Collection(event, "FatJet")
goodfatjet_tau21s = []
for ifj, fj in enumerate(fatjets_coll):
# removing attribute fetching for performance
fj_id = fj.jetId
fj_eta = fj.eta
fj_phi = fj.phi
fj_tau1 = fj.tau1
fj_tau2 = fj.tau2
# Get branches with prefixes for Jes,jmr,jer
fj_softdrop_mass = getattr(fj,
"msoftdrop" + self._input_branch_prefix)
if "jes" in self._input_branch_prefix or "jer" in self._input_branch_prefix:
fj_pt = getattr(
fj, "pt" +
self._input_branch_prefix) # for systematic variations
else:
fj_pt = fj.pt
# If the FatJet has only 1 particle remove it (rare corner case)
if fj_tau1 == 0: continue
fj_tau21 = fj_tau2 / fj_tau1
goodFatJet = True
if fj_id < self.jetid: goodFatJet = False
if fj_pt < self.minpt: goodFatJet = False
if abs(fj_eta) > self.maxeta: goodFatJet = False
if fj_softdrop_mass < self.mass_range[
0] or fj_softdrop_mass > self.mass_range[1]:
goodFatJet = False
# Do not perform tau21 cut
# Check overlap with leptons if the ID kinematics cuts are passed
if goodFatJet:
# Loop on leptons and exclude FatJet if there's a lepton with DeltaR < 1
for il, lep in enumerate(leptons_coll):
dRLep = self.getDeltaR(fj_phi, fj_eta, lep.phi, lep.eta)
if dRLep < self.over_lepR:
goodFatJet = False
# Now save the tau21 of the Fatjet passing kinematical cuts
if goodFatJet:
goodfatjet_tau21s.append(fj_tau21)
# Apply the tau21 cut on all the fatjets passing the kinematical cuts
tau21cut = list(map(lambda t: t <= self.max_tau21, goodfatjet_tau21s))
if any(tau21cut):
# we have found at least one fatjet passing kin cuts and also tau21 ID --> high purity SF region
hpsf, hpsf_unc = SF_hp[self.year]
output_SF = [
hpsf, #nomimal
hpsf + hpsf_unc, #up
hpsf - hpsf_unc #down
]
elif len(tau21cut) > 0:
# If there is not fatjet passing tau cut but there are good fatjet passing kinematical cuts --> low purity SF region
lpsf, lpsf_unc = SF_lp[self.year]
# The up/down variations are opposite than the high purity category
output_SF = [
lpsf, #nomimal
lpsf - lpsf_unc, #up
lpsf + lpsf_unc #down
]
# If there are not good fatjet the SF remains 1.
# Write out
self.out.fillBranch("BoostedWtagSF_nominal", output_SF[0])
self.out.fillBranch("BoostedWtagSF_up", output_SF[1])
self.out.fillBranch("BoostedWtagSF_down", output_SF[2])
return True
def analyze(self, event):
"""process event, return True (go to next module) or False (fail, go to next event)"""
event = mappedEvent(event, mapname=self._branch_map)
if event._tree._ttreereaderversion > self._ttreereaderversion: # do this check at every event, as other modules might have read further branches
self.initReaders(event._tree)
# do NOT access other branches in python between the check/call to initReaders and the call to C++ worker code
#--- Set vars
##### lepton selected at the Step stage, so it is 1 for now
#IsWlepEvt = 1
wlep_dict = {}
for MET in self.metCollections:
for v in Wlep_var:
wlep_dict[v+"_"+MET] = 0
lep_pt =self.lep_var['Lepton_pt'][0]
lep_eta=self.lep_var['Lepton_eta'][0]
lep_phi=self.lep_var['Lepton_phi'][0]
lep_pz =lep_pt*math.sinh(lep_eta) ##pz = pt*sinh(eta)
lep_E =lep_pt*math.cosh(lep_eta) ## p = pt*cosh(eta)
Wlep_mt = -9999.0
for MET,METtype in self.metCollections.items():
#met_pt=float(self.met_var['MET_pt'])
#met_phi=float(self.met_var['MET_phi'])
#met_pt = event.PuppiMET_pt
#met_phi = event.PuppiMET_phi
met_pt = getattr(event, METtype+'_pt')
met_phi = getattr(event, METtype+'_phi')
wlep_mass = 80.4
mu = ((wlep_mass)**2)/2 + lep_pt*met_pt*math.cos(met_phi-lep_phi)
##met_pz solution = met_pz_1 +-sqrt(met_pz_2)
met_pz_1=mu*lep_pz/(lep_pt**2)
met_pz_2=( mu*lep_pz/(lep_pt**2) )**2 - ( (lep_E*met_pt)**2 - mu**2 )/(lep_pt**2)
met_pz=0
##--complex number case
if met_pz_2 < 0:
met_pz = met_pz_1
##--real solution
else:
sol1 = met_pz_1+math.sqrt(met_pz_2)
sol2 = met_pz_1-math.sqrt(met_pz_2)
if math.fabs(sol1) < math.fabs(sol2):
met_pz = sol1
else:
met_pz = sol2
wlep_px = lep_pt*math.cos(lep_phi) + met_pt*math.cos(met_phi)
wlep_py = lep_pt*math.sin(lep_phi) + met_pt*math.sin(met_phi)
wlep_pz = lep_pz + met_pz
wlep_E = lep_E + math.sqrt(met_pz**2 + met_pt**2)
v_wlep = ROOT.TLorentzVector()
v_wlep.SetPxPyPzE(wlep_px, wlep_py, wlep_pz, wlep_E)
wlep_dict['pt'+"_"+MET] = v_wlep.Pt()
wlep_dict['eta'+"_"+MET] = v_wlep.Eta()
wlep_dict['phi'+"_"+MET] = v_wlep.Phi()
wlep_dict['mass'+"_"+MET] = v_wlep.M()
#wlep_dict['px'+"_"+MET] = v_wlep.Px()
#wlep_dict['py'+"_"+MET] = v_wlep.Py()
#wlep_dict['pz'+"_"+MET] = v_wlep.Pz()
#wlep_dict['E'+"_"+MET] = v_wlep.E()
Wlep_mt = math.sqrt( 2. * lep_pt * met_pt * ( 1. - math.cos (lep_phi - met_phi) ))
#--- Fill branches
for var in wlep_dict:
self.out.fillBranch( 'HM_Wlep_' + var, wlep_dict[var])
##fillBranch(name,value)
#self.out.fillBranch( 'IsWlepEvt', IsWlepEvt)
self.out.fillBranch( 'HM_Wlep_mt', Wlep_mt)
return True
def analyze(self, event):
"""process event, return True (go to next module) or False (fail, go to next event)"""
event = mappedEvent(event, mapname=self._branch_map)
# do this check at every event, as other modules might have read further branches
#if event._tree._ttreereaderversion > self._ttreereaderversion:
# self.initReaders(event._tree)
#nOrgJets = getattr(event, "nJet")
#OrgJets = Collection(event, "Jet")
# initialize
self.HlnFat_4v.SetPtEtaPhiM(0, 0, 0, 0)
self.Hlnjj_4v.SetPtEtaPhiM(0, 0, 0, 0)
self.Wlep_4v.SetPtEtaPhiM(0, 0, 0, 0)
self.Wfat_4v.SetPtEtaPhiM(0, 0, 0, 0)
self.Wjj_4v.SetPtEtaPhiM(0, 0, 0, 0)
##--For FatJet Collection in SR/SB/TopCR
CleanFatJetPassMBoosted = {}
for myvar in self.list_WJetVar:
CleanFatJetPassMBoosted[myvar] = []
# Boosted-like category, not requiring tau21 cut
idxWfat_noTau21Cut = -999
HlnFatMass_noTau21Cut = -999.
Wfat_Btop = False
Wjj_Btop = False
Evt_btagged = False
Hlnjj_mass = -999.
WptOvHak4M = -999
IsWfat = False
IsWjj = False
Wlep_mt = getattr(event, "HM_Wlep_mt")
Hlnjj_mt = -999
##Event variable
EventVar = {}
list_myvar = [
'IsBoosted', 'IsResolved', 'IsBTopTagged', 'IsVbfFat', 'IsVbfjj'
]
for myvar in list_myvar:
EventVar[myvar] = False
vbfFat_jj_dEta = -999
vbfFat_jj_mass = -999
vbfjj_jj_dEta = -999
vbfjj_jj_mass = -999
# largest mjj ignoring any W candidate jets, regardless of separation in eta
largest_nonW_mjj = -999
IsFat = False
IsJj = False
IsVbfFat = False
IsVbfjj = False
##--read vars
Lept_col = Collection(event, 'Lepton')
CFatJet_col = Collection(event, 'CleanFatJet')
CJet_col = Collection(event, 'CleanJet')
CleanJetNotFat_col = Collection(event, 'CleanJetNotFat')
Jet_col = Collection(event, 'Jet')
met_pt = getattr(event, "PuppiMET_pt")
#met_pt = getattr(event, "MET_pt")
Wlep_pt_Puppi = getattr(event, "HM_Wlep_pt_Puppi")
Wlep_eta_Puppi = getattr(event, "HM_Wlep_eta_Puppi")
Wlep_phi_Puppi = getattr(event, "HM_Wlep_phi_Puppi")
Wlep_mass_Puppi = getattr(event, "HM_Wlep_mass_Puppi")
Wjj_pt = getattr(event, "HM_Whad_pt")
Wjj_eta = getattr(event, "HM_Whad_eta")
Wjj_phi = getattr(event, "HM_Whad_phi")
Wjj_mass = getattr(event, "HM_Whad_mass")
Wjj_ClJet0_idx = getattr(event, "HM_idx_j1")
Wjj_ClJet1_idx = getattr(event, "HM_idx_j2")
if Lept_col._len < 1: return False
Flavlnjj = -999
if abs(Lept_col[0]['pdgId']) == 11: Flavlnjj = 1
if abs(Lept_col[0]['pdgId']) == 13: Flavlnjj = 2
self.Wlep_4v.SetPtEtaPhiM(Wlep_pt_Puppi, Wlep_eta_Puppi,
Wlep_phi_Puppi, Wlep_mass_Puppi)
##Check btagged event or not
bWP = self.bWP
for jdx in range(CleanJetNotFat_col._len):
clj_idx = CleanJetNotFat_col[jdx]['jetIdx']
jet_idx = CJet_col[clj_idx]['jetIdx']
if Jet_col[jet_idx]['btagDeepB'] > bWP:
if Jet_col[jet_idx]['pt'] > 20:
Wfat_Btop = True
# FatJet event from FatJet module, but need to apply cut further
for ix in range(CFatJet_col._len):
Wfat_mass = CFatJet_col[ix]['mass']
Wfat_pt = CFatJet_col[ix]['pt']
Wfat_eta = CFatJet_col[ix]['eta']
Wfat_phi = CFatJet_col[ix]['phi']
Wfat_tau21 = CFatJet_col[ix]['tau21']
self.Wfat_4v.SetPtEtaPhiM(Wfat_pt, Wfat_eta, Wfat_phi, Wfat_mass)
self.HlnFat_4v = self.Wfat_4v + self.Wlep_4v
thisHlnFat_mass = self.HlnFat_4v.M()
thisWptOvHfatM = min(Wlep_pt_Puppi, Wfat_pt) / thisHlnFat_mass
# FatJet Evt Cuts
# These are already selected in postproduction but to make sure
# N-subjettiness tau21 = tau2/tau1
##https://twiki.cern.ch/twiki/bin/viewauth/CMS/JetWtagging#2016_scale_factors_and_correctio , high purity cut
cutJ_base = [
Wfat_pt > 200,
abs(Wfat_eta) < 2.4, thisWptOvHfatM > 0.4
]
if all(cutJ_base):
if idxWfat_noTau21Cut == -999:
idxWfat_noTau21Cut = ix
HlnFatMass_noTau21Cut = thisHlnFat_mass
# require tau21 cut for standard boosted category
if Wfat_tau21 < self.tau21WP:
CleanFatJetPassMBoosted['pt'].append(Wfat_pt)
CleanFatJetPassMBoosted['mass'].append(Wfat_mass)
CleanFatJetPassMBoosted['eta'].append(Wfat_eta)
CleanFatJetPassMBoosted['phi'].append(Wfat_phi)
CleanFatJetPassMBoosted['tau21'].append(Wfat_tau21)
CleanFatJetPassMBoosted['WptOvHfatM'].append(
thisWptOvHfatM)
CleanFatJetPassMBoosted['HlnFat_mass'].append(
thisHlnFat_mass)
CleanFatJetPassMBoosted['CFatJetIdx'].append(ix)
IsWfat = (len(CleanFatJetPassMBoosted['pt']) > 0)
# W_Ak4 Event ----------------------------
#if (Wfat_SR == False or Wfat_Btop == True) and (Wjj_mass > -1):
if (
(not IsWfat)
and ((Wjj_ClJet0_idx != -1) and (Wjj_ClJet1_idx != -1))
): ##No FatJet passing final boosted cut and it is resolved Whad candidate
# Now it is Wjj event, initialize as all is true
self.Wjj_4v.SetPtEtaPhiM(Wjj_pt, Wjj_eta, Wjj_phi, Wjj_mass)
self.Hlnjj_4v = self.Wlep_4v + self.Wjj_4v
Hlnjj_mass = self.Hlnjj_4v.M()
#Hlnjj_mt = self.Hlnjj_4v.Mt() # This is sqrt(E*E - Pz*Pz) = sqrt(M*M + PT*PT)
Hlnjj_mt = sqrt(2. * self.Wlep_4v.Pt() * self.Wjj_4v.Pt() *
(1. - cos(self.Wlep_4v.Phi() - self.Wjj_4v.Phi())))
WptOvHak4M = min(Wlep_pt_Puppi, Wjj_pt) / Hlnjj_mass
#Wlep_mt = self.Wlep_4v.Mt() # This is sqrt(E*E - Pz*Pz) = sqrt(M*M + PT*PT)
# Need Lept & Neut -> Moved to WlepMaker
#cutjj_Base = [ met_pt>30, Wlep_mt>50, Hlnjj_mt > 60, WptOvHak4M > 0.35 ]
cutjj_Base = [
Wlep_mt > 50, Wjj_mass > 40 and Wjj_mass < 250, Hlnjj_mt > 60,
WptOvHak4M > 0.35
]
IsWjj = all(cutjj_Base)
JetIdx0 = CJet_col[Wjj_ClJet0_idx]['jetIdx']
JetIdx1 = CJet_col[Wjj_ClJet1_idx]['jetIdx']
for jdx in range(Jet_col._len):
if jdx == JetIdx0: continue
if jdx == JetIdx1: continue
if Jet_col[jdx]['pt'] < 20: continue
if abs(Jet_col[jdx]['eta']) > 2.4: continue
if Jet_col[jdx]['btagDeepB'] > bWP: Wjj_Btop = True
# Save Event ---------------------------------
# Evet Catagory
Cat_Fat = [IsWfat, met_pt > 40]
IsFat = all(Cat_Fat)
Cat_AK4 = [IsWjj, met_pt > 30]
IsJj = all(Cat_AK4)
Evt_btagged = (IsFat and Wfat_Btop) or (IsJj and Wjj_Btop)
EventVar['IsBoosted'] = IsFat
EventVar['IsResolved'] = IsJj
EventVar['IsBTopTagged'] = Evt_btagged
# VBF tag ---------------------------------------
# Requiring two additional jets with pt > 30 gev, |eta| < 4.7
# and VBF cuts
# lnJ case--------
lnJ_addJet_pt = []
lnJ_addJet_eta = []
lnJ_addJet_phi = []
lnJ_addJet_mass = []
lnJ_addJet_jid = []
nlnJ_addJet = 0
if IsFat:
for jdx in range(CleanJetNotFat_col._len):
clj_i = CleanJetNotFat_col[jdx]['jetIdx']
if (CJet_col[clj_i]['pt'] < 30) or (abs(CJet_col[clj_i]['eta'])
> 4.7):
continue
lnJ_addJet_pt.append(CJet_col[clj_i]['pt'])
lnJ_addJet_eta.append(CJet_col[clj_i]['eta'])
lnJ_addJet_phi.append(CJet_col[clj_i]['phi'])
lnJ_addJet_mass.append(
Jet_col[CJet_col[clj_i]['jetIdx']]['mass'])
lnJ_addJet_jid.append(
Jet_col[CJet_col[clj_i]['jetIdx']]['jetId'])
nlnJ_addJet += 1
if nlnJ_addJet > 1:
for i in range(nlnJ_addJet):
for j in range(nlnJ_addJet):
dEta_tmp = abs(lnJ_addJet_eta[i] - lnJ_addJet_eta[j])
mass_tmp = self.InvMassCalc(
lnJ_addJet_pt[i], lnJ_addJet_eta[i],
lnJ_addJet_phi[i], lnJ_addJet_mass[i],
lnJ_addJet_pt[j], lnJ_addJet_eta[j],
lnJ_addJet_phi[j], lnJ_addJet_mass[j])
if dEta_tmp > 3.5:
if mass_tmp > vbfFat_jj_mass:
vbfFat_jj_dEta = dEta_tmp
vbfFat_jj_mass = mass_tmp
if mass_tmp > largest_nonW_mjj:
largest_nonW_mjj = mass_tmp
if vbfFat_jj_mass > 500:
IsVbfFat = True
# lnjj case ---------
lnjj_addJet_pt = []
lnjj_addJet_eta = []
lnjj_addJet_phi = []
lnjj_addJet_mass = []
lnjj_addJet_jid = []
nlnjj_addJet = 0
if IsJj:
for ci in range(CJet_col._len):
# check if it is used
if ci == Wjj_ClJet0_idx: continue
if ci == Wjj_ClJet1_idx: continue
if (CJet_col[ci]['pt'] < 30) or (abs(CJet_col[ci]['eta']) >
4.7):
continue
lnjj_addJet_pt.append(CJet_col[ci]['pt'])
lnjj_addJet_eta.append(CJet_col[ci]['eta'])
lnjj_addJet_phi.append(CJet_col[ci]['phi'])
lnjj_addJet_mass.append(
Jet_col[CJet_col[ci]['jetIdx']]['mass'])
lnjj_addJet_jid.append(
Jet_col[CJet_col[ci]['jetIdx']]['jetId'])
nlnjj_addJet += 1
if nlnjj_addJet > 1:
for i in range(nlnjj_addJet):
for j in range(nlnjj_addJet):
dEta_tmp = abs(lnjj_addJet_eta[i] - lnjj_addJet_eta[j])
mass_tmp = self.InvMassCalc(
lnjj_addJet_pt[i], lnjj_addJet_eta[i],
lnjj_addJet_phi[i], lnjj_addJet_mass[i],
lnjj_addJet_pt[j], lnjj_addJet_eta[j],
lnjj_addJet_phi[j], lnjj_addJet_mass[j])
if dEta_tmp > 3.5:
if mass_tmp > vbfjj_jj_mass:
vbfjj_jj_dEta = dEta_tmp
vbfjj_jj_mass = mass_tmp
if mass_tmp > largest_nonW_mjj:
largest_nonW_mjj = mass_tmp
if vbfjj_jj_mass > 500:
IsVbfjj = True
EventVar['IsVbfFat'] = IsVbfFat
EventVar['IsVbfjj'] = IsVbfjj
self.out.fillBranch('HM_Flavlnjj', Flavlnjj)
##--Event Categorization--##
list_myvar = [
'IsBoosted', 'IsResolved', 'IsBTopTagged', 'IsVbfFat', 'IsVbfjj'
]
for myvar in list_myvar:
self.out.fillBranch('HM_' + myvar, EventVar[myvar])
##--Boosted FatJet--##
for myvar in self.list_WJetVar:
self.out.fillBranch("HM_CleanFatJetPassMBoosted_" + myvar,
CleanFatJetPassMBoosted[myvar])
self.out.fillBranch("HM_nCleanFatJetPassMBoosted",
len(CleanFatJetPassMBoosted['pt']))
self.out.fillBranch("HM_idxWfat_noTau21Cut", idxWfat_noTau21Cut)
self.out.fillBranch("HM_HlnFatMass_noTau21Cut", HlnFatMass_noTau21Cut)
#self.out.fillBranch( 'Wlep_mt' , Wlep_mt)
self.out.fillBranch('HM_Hlnjj_mt', Hlnjj_mt)
self.out.fillBranch('HM_vbfFat_jj_dEta', vbfFat_jj_dEta)
self.out.fillBranch('HM_vbfFat_jj_mass', vbfFat_jj_mass)
self.out.fillBranch('HM_vbfjj_jj_dEta', vbfjj_jj_dEta)
self.out.fillBranch('HM_vbfjj_jj_mass', vbfjj_jj_mass)
self.out.fillBranch('HM_largest_nonW_mjj', largest_nonW_mjj)
self.out.fillBranch('HM_Hlnjj_mass', Hlnjj_mass)
self.out.fillBranch('HM_WptOvHak4M', WptOvHak4M)
return True
def analyze(self, event):
"""process event, return True (go to next module) or False (fail, go to next event)"""
event = mappedEvent(event, mapname=self._branch_map)
try:
wpt = self.GetValue(event, "HM_CleanFatJetPassMBoosted_pt[0]")
ValidEntry = True
except IndexError:
ValidEntry = False
if self.GetValue(event,
"HM_nCleanFatJetPassMBoosted") >= 1 and ValidEntry:
weta = self.GetValue(event, "HM_CleanFatJetPassMBoosted_eta[0]")
wphi = self.GetValue(event, "HM_CleanFatJetPassMBoosted_phi[0]")
wmass = self.GetValue(event, "HM_CleanFatJetPassMBoosted_mass[0]")
WWmass = self.GetValue(
event, "HM_CleanFatJetPassMBoosted_HlnFat_mass[0]")
wptmww = self.GetValue(event,
"HM_CleanFatJetPassMBoosted_WptOvHfatM[0]")
tau21 = self.GetValue(event, "HM_CleanFatJetPassMBoosted_tau21[0]")
wr1pt = 0.0
wr1eta = 0.0
wr1phi = 0.0
wr2pt = 0.0
wr2eta = 0.0
wr2phi = 0.0
jetidx1 = 0
jetidx2 = 1
else:
wpt = self.GetValue(event, "HM_Whad_pt")
weta = self.GetValue(event, "HM_Whad_eta")
wphi = self.GetValue(event, "HM_Whad_phi")
wmass = self.GetValue(event, "HM_Whad_mass")
WWmass = self.GetValue(event, "HM_Hlnjj_mass")
wptmww = self.GetValue(event, "HM_WptOvHak4M")
tau21 = 0.0
nojet = [
int(self.GetValue(event, "HM_idx_j1")),
int(self.GetValue(event, "HM_idx_j2"))
]
if -1 in nojet: # Events has less than 2 jets and shouldn't be considered anyway
self.out.fillBranch("DNN_isVBF", 0.0)
return True
wr1pt = self.GetValue(event, "CleanJet_pt[" + str(nojet[0]) + "]")
wr1eta = self.GetValue(event,
"CleanJet_eta[" + str(nojet[0]) + "]")
wr1phi = self.GetValue(event,
"CleanJet_phi[" + str(nojet[0]) + "]")
wr2pt = self.GetValue(event, "CleanJet_pt[" + str(nojet[1]) + "]")
wr2eta = self.GetValue(event,
"CleanJet_eta[" + str(nojet[1]) + "]")
wr2phi = self.GetValue(event,
"CleanJet_phi[" + str(nojet[1]) + "]")
goodjet = [alpha for alpha in range(4) if alpha not in nojet]
jetidx1 = goodjet[0]
jetidx2 = goodjet[1]
if self.GetValue(event, "nCleanJet") >= 1 + jetidx1:
jetpt1 = self.GetValue(event, "CleanJet_pt[" + str(jetidx1) + "]")
jeteta1 = self.GetValue(event,
"CleanJet_eta[" + str(jetidx1) + "]")
jetphi1 = self.GetValue(event,
"CleanJet_phi[" + str(jetidx1) + "]")
else:
jetpt1 = 0.0
jeteta1 = 0.0
jetphi1 = 0.0
if self.GetValue(event, "nCleanJet") >= 1 + jetidx2:
jetpt2 = self.GetValue(event, "CleanJet_pt[" + str(jetidx2) + "]")
jeteta2 = self.GetValue(event,
"CleanJet_eta[" + str(jetidx2) + "]")
jetphi2 = self.GetValue(event,
"CleanJet_phi[" + str(jetidx2) + "]")
else:
jetpt2 = 0.0
jeteta2 = 0.0
jetphi2 = 0.0
#if jetidx1==0 and jetidx2==1:
# mjj = self.GetValue(event, "mjj")
# detajj = self.GetValue(event, "detajj")
if self.GetValue(event, "nCleanJet") >= 1 + jetidx2:
J1 = ROOT.TLorentzVector()
J2 = ROOT.TLorentzVector()
J1.SetPtEtaPhiM(
self.GetValue(event, "CleanJet_pt[" + str(jetidx1) + "]"),
self.GetValue(event, "CleanJet_eta[" + str(jetidx1) + "]"),
self.GetValue(event, "CleanJet_phi[" + str(jetidx1) + "]"),
self.GetValue(
event,
"Jet_mass[event.CleanJet_jetIdx[" + str(jetidx1) + "]]"))
J2.SetPtEtaPhiM(
self.GetValue(event, "CleanJet_pt[" + str(jetidx2) + "]"),
self.GetValue(event, "CleanJet_eta[" + str(jetidx2) + "]"),
self.GetValue(event, "CleanJet_phi[" + str(jetidx2) + "]"),
self.GetValue(
event,
"Jet_mass[event.CleanJet_jetIdx[" + str(jetidx2) + "]]"))
mjj = (J1 + J2).M()
detajj = abs(J1.Eta() - J2.Eta())
else:
mjj = -9999.0
detajj = -9999.0
values = []
ev = event.event
values.append(
self.GetValue(event, "Lepton_pt[0]") *
math.cos(self.GetValue(event, "Lepton_phi[0]")))
values.append(
self.GetValue(event, "Lepton_pt[0]") *
math.sin(self.GetValue(event, "Lepton_phi[0]")))
values.append(
self.GetValue(event, "Lepton_pt[0]") *
math.sinh(self.GetValue(event, "Lepton_eta[0]")))
values.append(jetpt1 * math.cos(jetphi1))
values.append(jetpt1 * math.sin(jetphi1))
values.append(jetpt1 * math.sinh(jeteta1))
values.append(jetpt2 * math.cos(jetphi2))
values.append(jetpt2 * math.sin(jetphi2))
values.append(jetpt2 * math.sinh(jeteta2))
values.append(wpt * math.cos(wphi))
values.append(wpt * math.sin(wphi))
values.append(wpt * math.sinh(weta))
values.append(wmass)
values.append(
self.GetValue(event, "HM_Wlep_pt_Puppi") *
math.cos(self.GetValue(event, "HM_Wlep_phi_Puppi")))
values.append(
self.GetValue(event, "HM_Wlep_pt_Puppi") *
math.sin(self.GetValue(event, "HM_Wlep_phi_Puppi")))
values.append(
self.GetValue(event, "HM_Wlep_pt_Puppi") *
math.sinh(self.GetValue(event, "HM_Wlep_eta_Puppi")))
values.append(self.GetValue(event, "HM_Wlep_mass_Puppi"))
values.append(wr1pt * math.cos(wr1phi))
values.append(wr1pt * math.sin(wr1phi))
values.append(wr1pt * math.sinh(wr1eta))
values.append(wr2pt * math.cos(wr2phi))
values.append(wr2pt * math.sin(wr2phi))
values.append(wr2pt * math.sinh(wr2eta))
values.append(
self.GetValue(event, "PuppiMET_pt") *
math.cos(self.GetValue(event, "PuppiMET_phi")))
values.append(
self.GetValue(event, "PuppiMET_pt") *
math.sin(self.GetValue(event, "PuppiMET_phi")))
values.append(wptmww)
values.append(tau21)
values.append(WWmass)
values_stacked = np.hstack(values).reshape(1, len(values))
values_preprocessed = self.preprocessing[ev %
2].transform(values_stacked)
response = self.classifiers[ev % 2].predict(values_preprocessed)
response = np.squeeze(response)
self.out.fillBranch("DNN_mth", response)
return True
def analyze(self, event):
"""process event, return True (go to next module) or False (fail, go to next event)"""
event = mappedEvent(event, mapname=self._branch_map)
if self.firstEvent:
self.firstEvent = False
if self.keepRunP and not hasattr(event, 'run_period'): raise ValueError('TrigMaker: event does not contain the \'run_period\' branch, while \'keepRunP\' is True.')
# Make your life easier
if self.seeded: evt = eval(self.event)
else: evt = None
if not self.keepRunP: run_p = self._run_period(eval(self.run), evt)
else: run_p = eval(self.run_p)
nvtx = event.PV_npvsGood
lep_col = Collection(event, 'Lepton')
nLep = len(lep_col)
pdgId = []
pt = []
eta = []
phi = []
for iLep in range(nLep):
pdgId.append(lep_col[iLep]['pdgId'])
pt.append(lep_col[iLep]['pt'])
eta.append(lep_col[iLep]['eta'])
phi.append(lep_col[iLep]['phi'])
EMTF = self._get_EMTFbug_veto(pdgId, pt, eta, phi, run_p)
trig_dec = self._get_trigDec(run_p, event)
# Fill DATA branches
for name in self.NewVar['I']:
if 'Trigger_sngEl' in name: self.out.fillBranch(name, trig_dec['SingleEle'])
elif 'Trigger_sngMu' in name: self.out.fillBranch(name, trig_dec['SingleMu'])
elif 'Trigger_dblEl' in name: self.out.fillBranch(name, trig_dec['DoubleEle'])
elif 'Trigger_dblMu' in name: self.out.fillBranch(name, trig_dec['DoubleMu'])
elif 'Trigger_ElMu' in name: self.out.fillBranch(name, trig_dec['EleMu'])
elif 'run_period' in name and not self.keepRunP: self.out.fillBranch(name, run_p)
elif 'EMTFbug_veto' in name : self.out.fillBranch(name, EMTF)
#self.out.fillBranch('Trigger_sngMu', trig_dec['SingleMu'])
#self.out.fillBranch('Trigger_dblEl', trig_dec['DoubleEle'])
#self.out.fillBranch('Trigger_dblMu', trig_dec['DoubleMu'])
#self.out.fillBranch('Trigger_ElMu' , trig_dec['EleMu'])
#if not self.keepRunP: self.out.fillBranch('run_period', run_p)
#self.out.fillBranch('EMTFbug_veto', EMTF)
# Stop here if not MC
if self.isData: return True
# Trigger efficiencies
eff_dict = {}
for name in self.NewVar['F']:
if 'EffWeight' in name: eff_dict[name] = 0.
Trig_em = [False]*6
if nLep > 0 :
temp_evt, temp_evt_v, Trig_em = self._get_w1l(pdgId[0], pt[0], eta[0], run_p, evt)
for name in self.NewVar['F']:
if 'TriggerEffWeight' in name:
if '_1l' in name:
if '_1l_d' in name: eff_dict[name] = temp_evt[1]
elif '_1l_u' in name: eff_dict[name] = temp_evt[2]
else: eff_dict[name] = temp_evt[0]
elif '_sngEl' in name: eff_dict[name] = temp_evt_v[0]
elif '_sngMu' in name: eff_dict[name] = temp_evt_v[1]
elif '_dblEl' in name: eff_dict[name] = temp_evt_v[2]
elif '_dblMu' in name: eff_dict[name] = temp_evt_v[3]
elif '_ElMu' in name: eff_dict[name] = temp_evt_v[4]
#eff_dict['TriggerEffWeight_1l'] = temp_evt[0]
#eff_dict['TriggerEffWeight_1l_d'] = temp_evt[1]
#eff_dict['TriggerEffWeight_1l_u'] = temp_evt[2]
#eff_dict['TriggerEffWeight_sngEl'] = temp_evt_v[0]
#eff_dict['TriggerEffWeight_sngMu'] = temp_evt_v[1]
#eff_dict['TriggerEffWeight_dblEl'] = temp_evt_v[2]
#eff_dict['TriggerEffWeight_dblMu'] = temp_evt_v[3]
#eff_dict['TriggerEffWeight_ElMu'] = temp_evt_v[4]
if nLep > 1:
temp_evt, temp_evt_v, Trig_em = self._get_w(pdgId[0], pt[0], eta[0], pdgId[1], pt[1], eta[1], nvtx, run_p, evt)
for name in self.NewVar['F']:
if 'TriggerEffWeight' in name:
if '_2l' in name:
if '_2l_d' in name: eff_dict[name] = temp_evt[1]
elif '_2l_u' in name: eff_dict[name] = temp_evt[2]
else: eff_dict[name] = temp_evt[0]
elif '_sngEl' in name: eff_dict[name] = temp_evt_v[0]
elif '_sngMu' in name: eff_dict[name] = temp_evt_v[1]
elif '_dblEl' in name: eff_dict[name] = temp_evt_v[2]
elif '_dblMu' in name: eff_dict[name] = temp_evt_v[3]
elif '_ElMu' in name: eff_dict[name] = temp_evt_v[4]
#eff_dict['TriggerEffWeight_2l'] = temp_evt[0]
#eff_dict['TriggerEffWeight_2l_d'] = temp_evt[1]
#eff_dict['TriggerEffWeight_2l_u'] = temp_evt[2]
#eff_dict['TriggerEffWeight_sngEl'] = temp_evt_v[0]
#eff_dict['TriggerEffWeight_sngMu'] = temp_evt_v[1]
#eff_dict['TriggerEffWeight_dblEl'] = temp_evt_v[2]
#eff_dict['TriggerEffWeight_dblMu'] = temp_evt_v[3]
#eff_dict['TriggerEffWeight_ElMu'] = temp_evt_v[4]
if nLep > 2:
temp_evt = self._get_3lw(pdgId[0], pt[0], eta[0], pdgId[1], pt[1], eta[1], pdgId[2], pt[2], eta[2], nvtx, run_p)
for name in self.NewVar['F']:
if 'TriggerEffWeight' in name:
if '_3l' in name:
if '_3l_d' in name: eff_dict[name] = temp_evt[1]
elif '_3l_u' in name: eff_dict[name] = temp_evt[2]
else: eff_dict[name] = temp_evt[0]
#eff_dict['TriggerEffWeight_3l'] = temp_evt[0]
#eff_dict['TriggerEffWeight_3l_d'] = temp_evt[1]
#eff_dict['TriggerEffWeight_3l_u'] = temp_evt[2]
if nLep > 3:
temp_evt = self._get_nlw(pdgId[:4], pt[:4], eta[:4], nvtx, run_p)
for name in self.NewVar['F']:
if 'TriggerEffWeight' in name:
if '_4l' in name:
if '_4l_d' in name: eff_dict[name] = temp_evt[1]
elif '_4l_u' in name: eff_dict[name] = temp_evt[2]
else: eff_dict[name] = temp_evt[0]
#eff_dict['TriggerEffWeight_4l'] = temp_evt[0]
#eff_dict['TriggerEffWeight_4l_d'] = temp_evt[1]
#eff_dict['TriggerEffWeight_4l_u'] = temp_evt[2]
# Fill branches
if 'TriggerEmulator' in self.NewVar['I']:
self.out.fillBranch('TriggerEmulator', Trig_em)
for name in eff_dict:
self.out.fillBranch(name, eff_dict[name])
return True
def analyze(self, event):
# Read branches that may be created by previous step in the chain
# It's important to read them like this in case they
# are created by the step before in a PostProcessor chain.
event = mappedEvent(event, mapname=self._branch_map)
self.vbs_category = event.VBS_category
self.rawJet_coll = Collection(event, 'Jet')
self.Jet_coll = Collection(event, 'CleanJet')
self.JetNotFat_coll = Collection(event, 'CleanJetNotFat')
lepton_raw = Object(event, "Lepton", index=0)
met_raw = Object(event, self.metType)
category = int(self.vbs_category)
# Check if VBS category
if category not in [0, 1]:
output = vbs_vars.getDefault()
# Fill the branches
for var, val in output.items():
self.out.fillBranch(var, val)
return True
lep = TLorentzVector()
lep.SetPtEtaPhiE(lepton_raw.pt, lepton_raw.eta, lepton_raw.phi,
lepton_raw.pt * cosh(lepton_raw.eta))
met = TLorentzVector()
met.SetPtEtaPhiE(met_raw.pt, 0., met_raw.phi, met_raw.pt)
# Reconstruct neutrino from lepton and met
reco_neutrino = RecoNeutrino.reconstruct_neutrino(lep,
met,
mode="central")
# Extract the jets four momenta using only JetNotFat but keeping
# a reference to the CleanJet index.
jets, jets_ids = self.get_jets_vectors()
vbsjets = []
vjets = []
other_jets = []
other_jets_ind = []
for jet, jetind in zip(jets, jets_ids):
if jetind in event[self.VBS_jets_var[category]]:
vbsjets.append(jet)
elif jetind in event[self.V_jets_var[category]]:
vjets.append(jet)
else:
other_jets.append(jet)
other_jets_ind.append(jetind)
# Check Mjj_vbs and deltaeta_vbs cuts
if ((vbsjets[0]+vbsjets[1]).M() < self.mjj_vbs_cut or \
abs(vbsjets[0].Eta() - vbsjets[1].Eta()) < self.deltaeta_vbs_cut):
return False
output = None
if category == 0:
#####################
# Boosted category
fatjet = Object(event, "CleanFatJet", index=0)
# CleanFatJet collection mass is Softdrop PUPPI mass
output = vbs_vars.getVBSkin_boosted(vbsjets,
fatjet.p4(),
lep,
met,
reco_neutrino,
other_jets,
other_jets_ind,
debug=self.debug)
elif category == 1:
#####################
# Resolved category
output = vbs_vars.getVBSkin_resolved(vbsjets,
vjets,
lep,
met,
reco_neutrino,
other_jets,
other_jets_ind,
debug=self.debug)
# Fill the branches
for var, val in output.items():
self.out.fillBranch(var, val)
"""return True (go to next module) or False (fail, go to next event)"""
return True
def analyze(self, event):
"""process event, return True (go to next module) or False (fail, go to next event)"""
event = mappedEvent(event, mapname=self._branch_map)
#muons = Collection(event, "Muon")
#electrons = Collection(event, "Electron")
# order in pt the collection merging muons and electrons
# lepMerger must be already called
leptons = Collection(event, "Lepton")
#leptons = electrons
nLep = len(leptons)
lep_pt = ROOT.std.vector(float)(0)
lep_eta = ROOT.std.vector(float)(0)
lep_phi = ROOT.std.vector(float)(0)
lep_flavour = ROOT.std.vector(float)(0)
for lep in leptons :
lep_pt. push_back(lep.pt)
lep_eta.push_back(lep.eta)
lep_phi.push_back(lep.phi)
lep_flavour.push_back(lep.pdgId)
# 11 = ele
# 13 = mu
#if lep.tightId == 0 :
# lep_flavour.push_back(lep.charge * 11)
#else:
# lep_flavour.push_back(lep.charge * 13)
# is this really doing its job?
Jet = Collection(event, "CleanJet")
#auxiliary jet collection to access the mass
OrigJet = Collection(event, "Jet")
nJet = len(Jet)
jet_pt = ROOT.std.vector(float)(0)
jet_eta = ROOT.std.vector(float)(0)
jet_phi = ROOT.std.vector(float)(0)
jet_mass = ROOT.std.vector(float)(0)
for jet in Jet :
jet_pt. push_back(jet.pt)
jet_eta.push_back(jet.eta)
jet_phi.push_back(jet.phi)
jet_mass.push_back(OrigJet[jet.jetIdx].mass)
WW = ROOT.WW()
WW.setLeptons(lep_pt, lep_eta, lep_phi, lep_flavour)
WW.setJets (jet_pt, jet_eta, jet_phi, jet_mass)
#MET_sumEt = event.MET_sumEt
#MET_phi = event.MET_phi
#MET_pt = event.MET_pt
MET_sumEt = event.PuppiMET_sumEt
MET_phi = event.PuppiMET_phi
MET_pt = event.PuppiMET_pt
WW.setMET(MET_pt, MET_phi)
WW.setSumET(MET_sumEt)
WW.setTkMET(event.TkMET_pt, event.TkMET_phi)
WW.checkIfOk()
for nameBranches in self.newbranches :
self.out.fillBranch(nameBranches , getattr(WW, nameBranches)())
return True
def analyze(self, event):
"""process event, return True (go to next module) or False (fail, go to next event)"""
event = mappedEvent(event, mapname=self._branch_map)
if self.jet_idx_name=='':
if hasattr(event, 'idx_j1'): self.jet_idx_name = 'idx_j'
elif hasattr(event, 'HM_idx_j1'): self.jet_idx_name = 'HM_idx_j'
else: raise ValueError('MHSemiLepVars: input tree has no variable named "idx_j1" or "HM_idx_j1"')
print('MHSemiLepVars: jet index string is "'+self.jet_idx_name+'"')
jets = Collection(event, 'CleanJet')
org_jets = Collection(event, 'Jet')
leps = Collection(event, 'Lepton')
idx_j1 = getattr(event, self.jet_idx_name+'1')
idx_j2 = getattr(event, self.jet_idx_name+'2')
if idx_j1 < 0 or idx_j2 < 0:
for var in self.angle_var:
for obj in self.angle_obj:
self.out.fillBranch('MHlnjj_'+var+'_'+obj, -999.)
for var in self.var:
for obj in self.obj:
self.out.fillBranch('MHlnjj_'+var+'_'+obj, -999.)
self.out.fillBranch('MHlnjj_pt_l', -999.)
self.out.fillBranch('MHlnjj_pt_j1', -999.)
self.out.fillBranch('MHlnjj_pt_j2', -999.)
self.out.fillBranch('MHlnjj_eta_l', -999.)
self.out.fillBranch('MHlnjj_eta_j1', -999.)
self.out.fillBranch('MHlnjj_eta_j2', -999.)
self.out.fillBranch('MHlnjj_idx_j3', -1)
self.out.fillBranch('MHlnjj_PTljj_D_PTmet', -999.)
self.out.fillBranch('MHlnjj_PTljj_D_Mlmetjj', -999.)
self.out.fillBranch('MHlnjj_MINPTlj_D_PTmet', -999.)
self.out.fillBranch('MHlnjj_MINPTlj_D_Mlmetjj', -999.)
self.out.fillBranch('MHlnjj_MAXPTlj_D_PTmet', -999.)
self.out.fillBranch('MHlnjj_MAXPTlj_D_Mlmetjj', -999.)
self.out.fillBranch('MHlnjj_MTljj_D_PTmet', -999.)
self.out.fillBranch('MHlnjj_MTljj_D_Mlmetjj', -999.)
return True
# MET
self.MET.SetPtEtaPhiM(getattr(event, "PuppiMET_pt"), 0.0, getattr(event, "PuppiMET_phi"), 0.0)
#self.MET.SetPtEtaPhiE(getattr(event, "PuppiMET_pt"), 0.0, getattr(event, "PuppiMET_phi"), getattr(event, "PuppiMET_sumEt"))
# Jets
#self.J1.SetPtEtaPhiM(jets[idx_j1].pt, jets[idx_j1].eta, jets[idx_j1].phi, jets[idx_j1].mass)
#self.J2.SetPtEtaPhiM(jets[idx_j2].pt, jets[idx_j2].eta, jets[idx_j2].phi, jets[idx_j2].mass)
self.J1.SetPtEtaPhiM(jets[idx_j1].pt, jets[idx_j1].eta, jets[idx_j1].phi, org_jets[jets[idx_j1].jetIdx].mass)
self.J2.SetPtEtaPhiM(jets[idx_j2].pt, jets[idx_j2].eta, jets[idx_j2].phi, org_jets[jets[idx_j2].jetIdx].mass)
# LEP
if abs(leps[0].pdgId) == 11:
self.LEP.SetPtEtaPhiM(leps[0].pt, leps[0].eta, leps[0].phi, self.el_mass)
elif abs(leps[0].pdgId) == 13:
self.LEP.SetPtEtaPhiM(leps[0].pt, leps[0].eta, leps[0].phi, self.mu_mass)
# Constructed objects
self.JJ = self.J1 + self.J2
self.LJJ = self.LEP + self.JJ
self.LMET = self.LEP + self.MET
self.LMETJJ = self.LMET + self.JJ
for var in self.angle_var:
for obj in self.angle_obj:
self.out.fillBranch('MHlnjj_'+var+'_'+obj, self.getVal(var, obj))
for var in self.var:
for obj in self.obj:
self.out.fillBranch('MHlnjj_'+var+'_'+obj, self.getVal(var, obj))
self.out.fillBranch('MHlnjj_pt_l', self.LEP.Pt())
self.out.fillBranch('MHlnjj_pt_j1', jets[idx_j1].pt)
self.out.fillBranch('MHlnjj_pt_j2', jets[idx_j2].pt)
self.out.fillBranch('MHlnjj_eta_l', self.LEP.Eta())
self.out.fillBranch('MHlnjj_eta_j1', jets[idx_j1].eta)
self.out.fillBranch('MHlnjj_eta_j2', jets[idx_j2].eta)
self.out.fillBranch('MHlnjj_PTljj_D_PTmet', self.LJJ.Pt()/self.MET.Pt())
self.out.fillBranch('MHlnjj_PTljj_D_Mlmetjj', self.LJJ.Pt()/self.LMETJJ.M())
self.out.fillBranch('MHlnjj_MINPTlj_D_PTmet', min(self.LEP.Pt(), self.J2.Pt())/self.MET.Pt())
self.out.fillBranch('MHlnjj_MINPTlj_D_Mlmetjj', min(self.LEP.Pt(), self.J2.Pt())/self.LMETJJ.M())
self.out.fillBranch('MHlnjj_MAXPTlj_D_PTmet', max(self.LEP.Pt(), self.J1.Pt())/self.MET.Pt())
self.out.fillBranch('MHlnjj_MAXPTlj_D_Mlmetjj', max(self.LEP.Pt(), self.J1.Pt())/self.LMETJJ.M())
self.out.fillBranch('MHlnjj_MTljj_D_PTmet', self.getVal('mt', 'ljj')/self.MET.Pt())
self.out.fillBranch('MHlnjj_MTljj_D_Mlmetjj', self.getVal('mt', 'ljj')/self.LMETJJ.M())
all_cj = range(len(jets))
all_cj.remove(idx_j1)
all_cj.remove(idx_j2)
if len(all_cj) > 0: self.out.fillBranch('MHlnjj_idx_j3', all_cj[0])
else: self.out.fillBranch('MHlnjj_idx_j3', -1)
return True
def analyze(self, event):
"""process event, return True (go to next module) or False (fail, go to next event)"""
event = mappedEvent(event, mapname=self._branch_map)
values = []
ev = event.event
njet30 = 0
jetidx = [-1, -1, -1, -1]
for alpha in range(int(self.GetValue(event, "nCleanJet"))):
if self.GetValue(event, "CleanJet_pt[" + str(alpha) + "]") >= 30.0:
njet30 += 1
else:
break
withindex = "[0]" # There was a case once where the entries in a sample weren't a list, for some reason
try:
wpt = self.GetValue(event,
"HM_CleanFatJetPassMBoosted_pt" + withindex)
ValidEntry = True
except IndexError:
ValidEntry = False
except TypeError:
withindex = ''
if self.GetValue(
event,
"HM_nCleanFatJetPassMBoosted") >= 1 and ValidEntry: # Boosted
wpt = self.GetValue(event,
"HM_CleanFatJetPassMBoosted_pt" + withindex)
weta = self.GetValue(event,
"HM_CleanFatJetPassMBoosted_eta" + withindex)
wphi = self.GetValue(event,
"HM_CleanFatJetPassMBoosted_phi" + withindex)
wmass = self.GetValue(
event, "HM_CleanFatJetPassMBoosted_mass" + withindex)
#WWmass = self.GetValue(event, "HM_CleanFatJetPassMBoosted_HlnFat_mass"+withindex)
wr1pt = 0.0
wr1eta = 0.0
wr1phi = 0.0
wr1mass = 0.0
wr2pt = 0.0
wr2eta = 0.0
wr2phi = 0.0
wr2mass = 0.0
for i in range(int(self.GetValue(event, "nCleanJet"))):
if i == 4: break
jetidx[i] = i
elif int(self.GetValue(event, "HM_idx_j1")) != -1: # Resolved
wpt = self.GetValue(event, "HM_Whad_pt")
weta = self.GetValue(event, "HM_Whad_eta")
wphi = self.GetValue(event, "HM_Whad_phi")
wmass = self.GetValue(event, "HM_Whad_mass")
#WWmass = self.GetValue(event, "HM_Hlnjj_mass")
nojet = [
int(self.GetValue(event, "HM_idx_j1")),
int(self.GetValue(event, "HM_idx_j2"))
]
wr1pt = self.GetValue(event, "CleanJet_pt[" + str(nojet[0]) + "]")
wr1eta = self.GetValue(event,
"CleanJet_eta[" + str(nojet[0]) + "]")
wr1phi = self.GetValue(event,
"CleanJet_phi[" + str(nojet[0]) + "]")
wr1mass = self.GetValue(
event, "Jet_mass[" + str(
int(
self.GetValue(event, "CleanJet_jetIdx[" +
str(nojet[0]) + "]"))) + "]")
wr2pt = self.GetValue(event, "CleanJet_pt[" + str(nojet[1]) + "]")
wr2eta = self.GetValue(event,
"CleanJet_eta[" + str(nojet[1]) + "]")
wr2phi = self.GetValue(event,
"CleanJet_phi[" + str(nojet[1]) + "]")
wr2mass = self.GetValue(
event, "Jet_mass[" + str(
int(
self.GetValue(event, "CleanJet_jetIdx[" +
str(nojet[1]) + "]"))) + "]")
j = 0
for i in range(int(self.GetValue(event, "nCleanJet"))):
if i in nojet: continue
jetidx[j] = i
j += 1
if j == 4: break
else: # Neither boosted nor resolved: Event not selected
self.out.fillBranch("DNN_isVBF", 0.0)
return True
if jetidx[0] != -1:
jetpt1 = self.GetValue(event,
"CleanJet_pt[" + str(jetidx[0]) + "]")
jeteta1 = self.GetValue(event,
"CleanJet_eta[" + str(jetidx[0]) + "]")
jetphi1 = self.GetValue(event,
"CleanJet_phi[" + str(jetidx[0]) + "]")
jetmass1 = self.GetValue(
event, "Jet_mass[" + str(
int(
self.GetValue(
event, "CleanJet_jetIdx[" + str(jetidx[0]) + "]")))
+ "]")
LorJ1 = ROOT.TLorentzVector()
LorJ1.SetPtEtaPhiM(jetpt1, jeteta1, jetphi1, jetmass1)
else:
jetpt1 = 0.0
jeteta1 = 0.0
jetphi1 = 0.0
jetmass1 = 0.0
if jetidx[1] != -1:
jetpt2 = self.GetValue(event,
"CleanJet_pt[" + str(jetidx[1]) + "]")
jeteta2 = self.GetValue(event,
"CleanJet_eta[" + str(jetidx[1]) + "]")
jetphi2 = self.GetValue(event,
"CleanJet_phi[" + str(jetidx[1]) + "]")
jetmass2 = self.GetValue(
event, "Jet_mass[" + str(
int(
self.GetValue(
event, "CleanJet_jetIdx[" + str(jetidx[1]) + "]")))
+ "]")
LorJ2 = ROOT.TLorentzVector()
LorJ2.SetPtEtaPhiM(jetpt2, jeteta2, jetphi2, jetmass2)
mjj_12 = (LorJ1 + LorJ2).M()
detajj_12 = abs(LorJ1.Eta() - LorJ2.Eta())
else:
jetpt2 = 0.0
jeteta2 = 0.0
jetphi2 = 0.0
jetmass2 = 0.0
mjj_12 = 0.0
detajj_12 = 0.0
if jetidx[2] != -1:
jetpt3 = self.GetValue(event,
"CleanJet_pt[" + str(jetidx[2]) + "]")
jeteta3 = self.GetValue(event,
"CleanJet_eta[" + str(jetidx[2]) + "]")
jetphi3 = self.GetValue(event,
"CleanJet_phi[" + str(jetidx[2]) + "]")
jetmass3 = self.GetValue(
event, "Jet_mass[" + str(
int(
self.GetValue(
event, "CleanJet_jetIdx[" + str(jetidx[2]) + "]")))
+ "]")
LorJ3 = ROOT.TLorentzVector()
LorJ3.SetPtEtaPhiM(jetpt3, jeteta3, jetphi3, jetmass3)
mjj_13 = (LorJ1 + LorJ3).M()
detajj_13 = abs(LorJ1.Eta() - LorJ3.Eta())
mjj_23 = (LorJ2 + LorJ3).M()
detajj_23 = abs(LorJ2.Eta() - LorJ3.Eta())
else:
jetpt3 = 0.0
jeteta3 = 0.0
jetphi3 = 0.0
jetmass3 = 0.0
mjj_13 = 0.0
detajj_13 = 0.0
mjj_23 = 0.0
detajj_23 = 0.0
if jetidx[3] != -1:
jetpt4 = self.GetValue(event,
"CleanJet_pt[" + str(jetidx[3]) + "]")
jeteta4 = self.GetValue(event,
"CleanJet_eta[" + str(jetidx[3]) + "]")
jetphi4 = self.GetValue(event,
"CleanJet_phi[" + str(jetidx[3]) + "]")
jetmass4 = self.GetValue(
event, "Jet_mass[" + str(
int(
self.GetValue(
event, "CleanJet_jetIdx[" + str(jetidx[3]) + "]")))
+ "]")
LorJ4 = ROOT.TLorentzVector()
LorJ4.SetPtEtaPhiM(jetpt4, jeteta4, jetphi4, jetmass4)
mjj_14 = (LorJ1 + LorJ4).M()
detajj_14 = abs(LorJ1.Eta() - LorJ4.Eta())
mjj_24 = (LorJ2 + LorJ4).M()
detajj_24 = abs(LorJ2.Eta() - LorJ4.Eta())
mjj_34 = (LorJ3 + LorJ4).M()
detajj_34 = abs(LorJ3.Eta() - LorJ4.Eta())
else:
jetpt4 = 0.0
jeteta4 = 0.0
jetphi4 = 0.0
jetmass4 = 0.0
mjj_14 = 0.0
detajj_14 = 0.0
mjj_24 = 0.0
detajj_24 = 0.0
mjj_34 = 0.0
detajj_34 = 0.0
values.append(
self.GetValue(event, "Lepton_pt[0]") *
math.cos(self.GetValue(event, "Lepton_phi[0]")))
values.append(
self.GetValue(event, "Lepton_pt[0]") *
math.sin(self.GetValue(event, "Lepton_phi[0]")))
values.append(
self.GetValue(event, "Lepton_pt[0]") *
math.sinh(self.GetValue(event, "Lepton_eta[0]")))
values.append(jetpt1 * math.cos(jetphi1))
values.append(jetpt1 * math.sin(jetphi1))
values.append(jetpt1 * math.sinh(jeteta1))
values.append(jetmass1)
values.append(jetpt2 * math.cos(jetphi2))
values.append(jetpt2 * math.sin(jetphi2))
values.append(jetpt2 * math.sinh(jeteta2))
values.append(jetmass2)
values.append(jetpt3 * math.cos(jetphi3))
values.append(jetpt3 * math.sin(jetphi3))
values.append(jetpt3 * math.sinh(jeteta3))
values.append(jetmass3)
values.append(jetpt4 * math.cos(jetphi4))
values.append(jetpt4 * math.sin(jetphi4))
values.append(jetpt4 * math.sinh(jeteta4))
values.append(jetmass4)
values.append(wpt * math.cos(wphi))
values.append(wpt * math.sin(wphi))
values.append(wpt * math.sinh(weta))
values.append(wmass)
values.append(
self.GetValue(event, "HM_Wlep_pt_Puppi") *
math.cos(self.GetValue(event, "HM_Wlep_phi_Puppi")))
values.append(
self.GetValue(event, "HM_Wlep_pt_Puppi") *
math.sin(self.GetValue(event, "HM_Wlep_phi_Puppi")))
values.append(
self.GetValue(event, "HM_Wlep_pt_Puppi") *
math.sinh(self.GetValue(event, "HM_Wlep_eta_Puppi")))
values.append(self.GetValue(event, "HM_Wlep_mass_Puppi"))
values.append(wr1pt * math.cos(wr1phi))
values.append(wr1pt * math.sin(wr1phi))
values.append(wr1pt * math.sinh(wr1eta))
values.append(wr1mass)
values.append(wr2pt * math.cos(wr2phi))
values.append(wr2pt * math.sin(wr2phi))
values.append(wr2pt * math.sinh(wr2eta))
values.append(wr2mass)
values.append(
self.GetValue(event, "PuppiMET_pt") *
math.cos(self.GetValue(event, "PuppiMET_phi")))
values.append(
self.GetValue(event, "PuppiMET_pt") *
math.sin(self.GetValue(event, "PuppiMET_phi")))
values.append(self.GetValue(event, "nCleanJet"))
values.append(njet30)
values.append(self.GetValue(event, "HM_largest_nonW_mjj"))
#values.append(WWmass)
values.append(mjj_12)
values.append(detajj_12)
values.append(mjj_13)
values.append(detajj_13)
values.append(mjj_14)
values.append(detajj_14)
values.append(mjj_23)
values.append(detajj_23)
values.append(mjj_24)
values.append(detajj_24)
values.append(mjj_34)
values.append(detajj_34)
values_stacked = np.hstack(values).reshape(1, len(values))
values_preprocessed = self.preprocessing[ev %
2].transform(values_stacked)
response = self.classifiers[ev % 2].predict(values_preprocessed)
response = np.squeeze(response)
self.out.fillBranch("DNN_isVBF", response[0])
return True
def analyze(self, event):
"""process event, return True (go to next module) or False (fail, go to next event)"""
event = mappedEvent(event, mapname=self._branch_map)
jet_coll = Collection(event, self.jetColl)
nJet = jet_coll._len
if 'Clean' in self.jetColl:
ori_jet_coll = Collection(event, self.jetColl.replace('Clean', ''))
order = []
for iJet in range(nJet):
pt = jet_coll[iJet]['pt']
eta = jet_coll[iJet]['eta']
if 'Clean' in self.jetColl:
jetId = ori_jet_coll[jet_coll[iJet]['jetIdx']]['jetId']
puId = ori_jet_coll[jet_coll[iJet]['jetIdx']]['puId']
else:
jetId = jet_coll[iJet]['jetId']
puId = jet_coll[iJet]['puId']
pu_loose = bool(puId & (1 << 2))
pu_medium = bool(puId & (1 << 1))
pu_tight = bool(puId & (1 << 0))
goodJet = True
if pt < self.minpt: goodJet = False
if abs(eta) > self.maxeta: goodJet = False
if jetId < self.jetid: goodJet = False
if self.pujetid == 'loose' and not pu_loose: goodJet = False
if self.pujetid == 'medium' and not pu_medium: goodJet = False
if self.pujetid == 'tight' and not pu_tight: goodJet = False
if self.pujetid == 'custom' and pt <= 50:
if not pu_loose: goodJet = False
#if abs(eta) > 2.5 and not pu_medium : goodJet = False
if goodJet: order.append(iJet)
##Select best pair for Whad
##if there's no pair , indices will have -1
#temp_v = [jet_coll[iJet][temp_b] for iJet in order]
idx_j1 = -1
idx_j2 = -1
whad_pt = -1.
whad_eta = -1.
whad_phi = -1.
whad_mass = -1.
whad_px = -1.
whad_py = -1.
whad_pz = -1.
whad_E = -1.
wmass = 80.4
dM = 9999.
for iJet in order:
for jJet in order:
if jJet <= iJet: continue
v1 = ROOT.TLorentzVector()
v2 = ROOT.TLorentzVector()
if 'Clean' in self.jetColl:
jet_pt1 = ori_jet_coll[jet_coll[iJet]['jetIdx']]['pt']
jet_eta1 = ori_jet_coll[jet_coll[iJet]['jetIdx']]['eta']
jet_phi1 = ori_jet_coll[jet_coll[iJet]['jetIdx']]['phi']
jet_mass1 = ori_jet_coll[jet_coll[iJet]['jetIdx']]['mass']
jet_pt2 = ori_jet_coll[jet_coll[jJet]['jetIdx']]['pt']
jet_eta2 = ori_jet_coll[jet_coll[jJet]['jetIdx']]['eta']
jet_phi2 = ori_jet_coll[jet_coll[jJet]['jetIdx']]['phi']
jet_mass2 = ori_jet_coll[jet_coll[jJet]['jetIdx']]['mass']
else:
jet_pt1 = jet_coll[iJet]['pt']
jet_eta1 = jet_coll[iJet]['eta']
jet_phi1 = jet_coll[iJet]['phi']
jet_mass1 = jet_coll[iJet]['mass']
jet_pt2 = jet_coll[jJet]['pt']
jet_eta2 = jet_coll[jJet]['eta']
jet_phi2 = jet_coll[jJet]['phi']
jet_mass2 = jet_coll[jJet]['mass']
v1.SetPtEtaPhiM(jet_pt1, jet_eta1, jet_phi1, jet_mass1)
v2.SetPtEtaPhiM(jet_pt2, jet_eta2, jet_phi2, jet_mass2)
M12 = (v1 + v2).M()
this_dM = abs(M12 - wmass)
if this_dM < dM:
idx_j1 = iJet
idx_j2 = jJet
whad_pt = (v1 + v2).Pt()
whad_eta = (v1 + v2).Eta()
whad_phi = (v1 + v2).Phi()
whad_mass = (v1 + v2).M()
whad_px = (v1 + v2).Px()
whad_py = (v1 + v2).Py()
whad_pz = (v1 + v2).Pz()
whad_E = (v1 + v2).E()
dM = this_dM
#self.out.fillBranch()
#self.out.fillBranch('Whad_px',whad_px)
#self.out.fillBranch('Whad_py',whad_py)
#self.out.fillBranch('Whad_pz',whad_pz)
#self.out.fillBranch('Whad_E',whad_E)
self.out.fillBranch(self.prefix + 'Whad_pt', whad_pt)
self.out.fillBranch(self.prefix + 'Whad_eta', whad_eta)
self.out.fillBranch(self.prefix + 'Whad_phi', whad_phi)
self.out.fillBranch(self.prefix + 'Whad_mass', whad_mass)
self.out.fillBranch(self.prefix + 'idx_j1', idx_j1)
self.out.fillBranch(self.prefix + 'idx_j2', idx_j2)
return True
def analyze(self, event):
"""process event, return True (go to next module) or False (fail, go to next event)"""
event = mappedEvent(event, mapname=self._branch_map)
values = []
ev = event.event
values.append(self.GetValue(event, "Lepton_pt[0]") * math.cos(self.GetValue(event, "Lepton_phi[0]")))
values.append(self.GetValue(event, "Lepton_pt[0]") * math.sin(self.GetValue(event, "Lepton_phi[0]")))
values.append(self.GetValue(event, "Lepton_pt[0]") * math.sinh(self.GetValue(event, "Lepton_eta[0]")))
values.append(self.GetValue(event, "Lepton_pt[1]") * math.cos(self.GetValue(event, "Lepton_phi[1]")))
values.append(self.GetValue(event, "Lepton_pt[1]") * math.sin(self.GetValue(event, "Lepton_phi[1]")))
values.append(self.GetValue(event, "Lepton_pt[1]") * math.sinh(self.GetValue(event, "Lepton_eta[1]")))
if self.GetValue(event, "nCleanJet")>=1:
values.append(self.GetValue(event, "CleanJet_pt[0]") * math.cos(self.GetValue(event, "CleanJet_phi[0]")))
values.append(self.GetValue(event, "CleanJet_pt[0]") * math.sin(self.GetValue(event, "CleanJet_phi[0]")))
values.append(self.GetValue(event, "CleanJet_pt[0]") * math.sinh(self.GetValue(event, "CleanJet_eta[0]")))
else:
values.append(0.0)
values.append(0.0)
values.append(0.0)
if self.GetValue(event, "nCleanJet")>=2:
values.append(self.GetValue(event, "CleanJet_pt[1]") * math.cos(self.GetValue(event, "CleanJet_phi[1]")))
values.append(self.GetValue(event, "CleanJet_pt[1]") * math.sin(self.GetValue(event, "CleanJet_phi[1]")))
values.append(self.GetValue(event, "CleanJet_pt[1]") * math.sinh(self.GetValue(event, "CleanJet_eta[1]")))
else:
values.append(0.0)
values.append(0.0)
values.append(0.0)
values.append(self.GetValue(event, "PuppiMET_pt") * math.cos(self.GetValue(event, "PuppiMET_phi")))
values.append(self.GetValue(event, "PuppiMET_pt") * math.sin(self.GetValue(event, "PuppiMET_phi")))
values.append(self.GetValue(event, "nCleanJet"))
values.append(self.GetValue(event, "detajj"))
values.append(self.GetValue(event, "dphill"))
values.append(self.GetValue(event, "drll"))
values.append(self.GetValue(event, "dphilmet"))
values.append(self.GetValue(event, "dphilmet1"))
values.append(self.GetValue(event, "dphilmet2"))
values.append(self.GetValue(event, "mjj"))
values.append(self.GetValue(event, "mll"))
values.append(self.GetValue(event, "mTi"))
values.append(self.GetValue(event, "mth"))
values.append(self.GetValue(event, "ht"))
values.append(self.GetValue(event, "mtw1"))
values.append(self.GetValue(event, "mtw2"))
values.append(self.GetValue(event, "ptll"))
values.append(self.GetValue(event, "mcoll"))
values.append(self.GetValue(event, "mcollWW"))
values.append(self.GetValue(event, "vht_pt") * math.cos(self.GetValue(event, "vht_phi")))
values.append(self.GetValue(event, "vht_pt") * math.sin(self.GetValue(event, "vht_phi")))
if ev%64 < 32:
intothisfold=0
else:
intothisfold=1
values_stacked = np.hstack(values).reshape(1, len(values))
values_preprocessed = self.preprocessing[intothisfold].transform(values_stacked)
response = self.classifiers[intothisfold].predict(values_preprocessed)
response = np.squeeze(response)
maxscore = 0
secondmax = 0
for i, r in enumerate(response):
self.out.fillBranch("DNN_"+self.classes[i], r)
if r > maxscore:
secondmax = maxscore
maxscore = r
maxindex = i
elif r > secondmax:
secondmax = r
self.out.fillBranch("DNN_categ", maxindex)
self.out.fillBranch("DNN_categ_maxscore", maxscore)
self.out.fillBranch("DNN_categ_difftosecond", maxscore-secondmax)
return True
def analyze(self, event):
"""process event, return True (go to next module) or False (fail, go to next event)"""
event = mappedEvent(event, mapname=self._branch_map)
Lepton = Collection(event, "Lepton")
nLepton = len(Lepton)
Jet = Collection(event, "CleanJet")
nJet = len(Jet)
OrigJet = Collection(event, "Jet")
hm = -999
me_vbf_hsm = -999
me_vbf_hm = -999
me_vbf_hp = -999
me_vbf_hl = -999
me_vbf_mixhm = -999
me_vbf_mixhp = -999
me_wh_hsm = -999
me_wh_hm = -999
me_wh_hp = -999
me_wh_hl = -999
me_wh_mixhm = -999
me_wh_mixhp = -999
me_zh_hsm = -999
me_zh_hm = -999
me_zh_hp = -999
me_zh_hl = -999
me_zh_mixhm = -999
me_zh_mixhp = -999
me_qcd_hsm = -999
me_qcd_hm = -999
me_qcd_mixhm = -999
pjjSm_wh = -999
pjjTr_wh = -999
pjjSm_zh = -999
pjjTr_zh = -999
meAvg_wh = -999
meAvg_zh = -999
if nJet > 1 and nLepton > 1:
L1 = ROOT.TLorentzVector()
L2 = ROOT.TLorentzVector()
L1.SetPtEtaPhiM(Lepton[0].pt, Lepton[0].eta, Lepton[0].phi, 0)
L2.SetPtEtaPhiM(Lepton[1].pt, Lepton[1].eta, Lepton[1].phi, 0)
LL = ROOT.TLorentzVector()
LL = L1 + L2
MET_phi = event.PuppiMET_phi
MET_pt = event.PuppiMET_pt
NuNu = ROOT.TLorentzVector()
nunu_px = MET_pt * math.cos(MET_phi)
nunu_py = MET_pt * math.sin(MET_phi)
nunu_pz = LL.Pz()
nunu_m = 30.0
nunu_e = math.sqrt(nunu_px * nunu_px + nunu_py * nunu_py +
nunu_pz * nunu_pz + nunu_m * nunu_m)
NuNu.SetPxPyPzE(nunu_px, nunu_py, nunu_pz, nunu_e)
Higgs = ROOT.TLorentzVector()
Higgs = LL + NuNu
hm = Higgs.M()
indx_j1 = 0
indx_j2 = 1
J1 = ROOT.TLorentzVector()
J2 = ROOT.TLorentzVector()
indx_oj1 = Jet[indx_j1].jetIdx
indx_oj2 = Jet[indx_j2].jetIdx
J1.SetPtEtaPhiM(Jet[indx_j1].pt, Jet[indx_j1].eta,
Jet[indx_j1].phi, OrigJet[indx_oj1].mass)
J2.SetPtEtaPhiM(Jet[indx_j2].pt, Jet[indx_j2].eta,
Jet[indx_j2].phi, OrigJet[indx_oj2].mass)
daughter_coll = ROOT.SimpleParticleCollection_t()
associated_coll = ROOT.SimpleParticleCollection_t()
daughter = ROOT.SimpleParticle_t(25, Higgs)
associated1 = ROOT.SimpleParticle_t(0, J1)
associated2 = ROOT.SimpleParticle_t(0, J2)
daughter_coll.push_back(daughter)
associated_coll.push_back(associated1)
associated_coll.push_back(associated2)
self.mela.setCandidateDecayMode(ROOT.TVar.CandidateDecay_Stable)
self.mela.setInputEvent(daughter_coll, associated_coll, 0, 0)
self.mela.setCurrentCandidateFromIndex(0)
ME_VBF = ROOT.melaHiggsEFT(self.mela, ROOT.TVar.JHUGen,
ROOT.TVar.JJVBF, 0, 1)
me_vbf_hsm = ME_VBF[0]
me_vbf_hm = ME_VBF[1]
me_vbf_hp = ME_VBF[2]
me_vbf_hl = ME_VBF[3]
me_vbf_mixhm = ME_VBF[4]
me_vbf_mixhp = ME_VBF[5]
ME_WH = ROOT.melaHiggsEFT(self.mela, ROOT.TVar.JHUGen,
ROOT.TVar.Had_WH, 0, 1)
me_wh_hsm = ME_WH[0]
me_wh_hm = ME_WH[1]
me_wh_hp = ME_WH[2]
me_wh_hl = ME_WH[3]
me_wh_mixhm = ME_WH[4]
me_wh_mixhp = ME_WH[5]
pjjSm_wh = ME_WH[7]
pjjTr_wh = ME_WH[8]
meAvg_wh = ME_WH[9]
ME_ZH = ROOT.melaHiggsEFT(self.mela, ROOT.TVar.JHUGen,
ROOT.TVar.Had_ZH, 0, 1)
me_zh_hsm = ME_ZH[0]
me_zh_hm = ME_ZH[1]
me_zh_hp = ME_ZH[2]
me_zh_hl = ME_ZH[3]
me_zh_mixhm = ME_ZH[4]
me_zh_mixhp = ME_ZH[5]
pjjSm_zh = ME_ZH[7]
pjjTr_zh = ME_ZH[8]
meAvg_zh = ME_ZH[9]
ME_QCD = ROOT.melaHiggsEFT(self.mela, ROOT.TVar.JHUGen,
ROOT.TVar.JJQCD, 1, 1)
me_qcd_hsm = ME_QCD[0]
me_qcd_hm = ME_QCD[1]
me_qcd_mixhm = ME_QCD[4]
self.mela.resetInputEvent()
self.out.fillBranch('hm', hm)
self.out.fillBranch('me_vbf_hsm', me_vbf_hsm)
self.out.fillBranch('me_vbf_hm', me_vbf_hm)
self.out.fillBranch('me_vbf_hp', me_vbf_hp)
self.out.fillBranch('me_vbf_hl', me_vbf_hl)
self.out.fillBranch('me_vbf_mixhm', me_vbf_mixhm)
self.out.fillBranch('me_vbf_mixhp', me_vbf_mixhp)
self.out.fillBranch('me_wh_hsm', me_wh_hsm)
self.out.fillBranch('me_wh_hm', me_wh_hm)
self.out.fillBranch('me_wh_hp', me_wh_hp)
self.out.fillBranch('me_wh_hl', me_wh_hl)
self.out.fillBranch('me_wh_mixhm', me_wh_mixhm)
self.out.fillBranch('me_wh_mixhp', me_wh_mixhp)
self.out.fillBranch('me_zh_hsm', me_zh_hsm)
self.out.fillBranch('me_zh_hm', me_zh_hm)
self.out.fillBranch('me_zh_hp', me_zh_hp)
self.out.fillBranch('me_zh_hl', me_zh_hl)
self.out.fillBranch('me_zh_mixhm', me_zh_mixhm)
self.out.fillBranch('me_zh_mixhp', me_zh_mixhp)
self.out.fillBranch('me_qcd_hsm', me_qcd_hsm)
self.out.fillBranch('me_qcd_hm', me_qcd_hm)
self.out.fillBranch('me_qcd_mixhm', me_qcd_mixhm)
self.out.fillBranch('pjjSm_wh', pjjSm_wh)
self.out.fillBranch('pjjTr_wh', pjjTr_wh)
self.out.fillBranch('pjjSm_zh', pjjSm_zh)
self.out.fillBranch('pjjTr_zh', pjjTr_zh)
self.out.fillBranch('meAvg_wh', meAvg_wh)
self.out.fillBranch('meAvg_zh', meAvg_zh)
return True
