def findMatch_pfc_old(lepton, pfcands):
drmin = 10
idx = -1
if lepton.pt() > 0:
leptonTlv = TLorentzVector()
leptonTlv.SetPxPyPzE(lepton.px(), lepton.py(), lepton.pz(),
lepton.energy())
for ipfc, pfc in enumerate(pfcands):
if pfc.trackRef().isNull(): continue
if pfc.trackRef().get().numberOfValidHits() == 0: continue
if pfc.trackRef().get().ndof() == 0: continue
if pfc.trackRef().get().charge() == 0: continue
# if not passesPreselection_basic_pfc(pfc): continue
if not pfc.charge() * lepton.charge() > 0: continue
# if not abs(pfc.pt() - lepton.pt()) / lepton.pt() < 0.2: continue
pfcTlv = TLorentzVector()
pfcTlv.SetPxPyPzE(pfc.px(), pfc.py(), pfc.pz(), pfc.energy())
dr = pfcTlv.DeltaR(leptonTlv)
if dr < drmin:
drmin = dr
idx = ipfc
return idx, drmin
def isBoostedTop(event, hadTop_p4=None, minPt=200., maxDR=0.4):
# categorize the event as boosted if there is a large R jet matched to top
# LargeR jet pT > 200 GeV from Delphes
for ljet in event.FatJet:
# pT cut on large R jet
if ljet.PT < minPt:
continue
# large R jet mass window: [120, 220] GeV
if ljet.Mass < 120. or ljet.Mass > 220.:
continue
# match the large jet with the hadronic top parton by dR
if hadTop_p4 is not None:
ljet_p4 = TLorentzVector()
ljet_p4.SetPtEtaPhiM(ljet.PT, ljet.Eta, ljet.Phi, ljet.Mass)
dR = ljet_p4.DeltaR(hadTop_p4)
if dR > maxDR:
continue
# ljet is matched to the hadronic top
return True
# None of the large R jets meet the requirements
return False
def findMatch_track_old_random(lepton, tracks):
drmin = 10
idx = -1
if lepton.pt() > 0:
leptonTlv = TLorentzVector()
leptonTlv.SetPxPyPzE(lepton.px(), lepton.py(), lepton.pz(),
lepton.energy())
for itrack, track in enumerate(tracks):
if track.numberOfValidHits() == 0: continue
if track.ndof() == 0: continue
if track.charge() == 0: continue
# if not passesPreselection_basic_track(track): continue
if not track.charge() * lepton.charge() < 0: continue
# if not abs(track.pt() - lepton.pt()) / lepton.pt() < 0.2: continue
trackTlv = TLorentzVector()
trackTlv.SetPxPyPzE(track.px(), track.py(), track.pz(),
track.pt() * TMath.CosH(track.eta()))
dr = trackTlv.DeltaR(leptonTlv)
if dr < drmin:
drmin = dr
idx = itrack
return idx, drmin
def std_process(ev):
# pass conditions
if not (abs(ev.leps_ID) == 13 and ev.HLT_mu and ev.lep_matched_HLT[0]):
return None
pass_lep = ev.lep_p4[0].pt() > 30 and abs(ev.lep_p4[0].eta()) < 2.4
if not pass_lep: return None
if len(ev.tau_p4) < 1: return None
# sv_ind = -1 if there was no valid SV refited
# otherwise it is an index into vectors on SVs
taus_main = [
(IDlev, p4, PDGid, sv_ind) for IDlev, p4, PDGid, sv_ind in zip(
ev.tau_IDlev, ev.tau_p4, ev.tau_id, ev.tau_refited_index)
if IDlev > 0 and p4.pt() > 30. and abs(p4.eta()) < 2.4
]
taus_main.sort(key=lambda it: (it[0], it[1].pt()), reverse=True)
#pass_tau = ev.tau_p4[0].pt() > 30 and abs(ev.tau_p4[0].eta()) < 2.4 and len(ev.tau_IDlev) > 0 and ev.tau_IDlev[0] > 2
pass_tau = len(taus_main) > 0 and taus_main[0][0] > 2
if not pass_tau: return None
# pass OS
if not (taus_main[0][2] * ev.lep_id[0] < 0): return None
# check there no b-jets among not-tau jets
main_tau = taus_main[0]
mtau = main_tau[1]
main_tau_tlor = TLorentzVector(mtau.X(), mtau.Y(), mtau.Z(), mtau.T())
n_bjets = 0
for i in xrange(ev.jet_p4.size()):
pfid = ev.jet_PFID[i]
p4 = ev.jet_initial_p4[i]
if pfid < 1 or abs(p4.eta()) > 2.5: continue # Loose PFID and eta
if ev.jet_matching_lep[i]: continue
tj_p4 = TLorentzVector(p4.X(), p4.Y(), p4.Z(), p4.T())
# if matches to tau
if tj_p4.DeltaR(main_tau_tlor) < 0.4: continue
# else count the b-tagged jets
jet_b_discr = ev.jet_b_discr[i]
if jet_b_discr > 0.8484: # medium b WP
n_bjets += 1
if n_bjets > 0: return None
# save stuff
output_histos['n_tau_cands'].Fill(len(taus_main))
output_histos['tau_pt'].Fill(mtau.pt())
# if the main tau has valid SV
#
if main_tau[3] < 0: return None
output_histos['n_tau_sv_cands'].Fill(len(taus_main))
output_histos['tau_sv_pt'].Fill(mtau.pt())
# TODO: WARNING! THE PT 0 PROBABLY DOES NOT CORRESPOND TO SV 0
output_histos['tau_sv_sign'].Fill(
ev.tau_SV_geom_flightLenSign[main_tau[3]])
def filterDR(obj, collection):
"""Returns the given object filtered from the given collection."""
objVec = TLorentzVector()
objVec.SetPtEtaPhiM(obj.pt(), obj.eta(), obj.phi(), obj.mass())
for p in collection:
pVec = TLorentzVector()
pVec.SetPtEtaPhiM(p.pt(), p.eta(), p.phi(), p.mass())
if objVec.DeltaR(pVec) > 0.3:
return obj
def calc_n_save_params(event):
# condition for roughly alliso presel
event_pass = abs(event.leps_ID_allIso) == 13 and event.nleps_veto_mu_all == 0 and event.nleps_veto_el_all == 0 # or abs(event.leps_ID_allIso) == 11
#&& tau_matching_allIso_lep_dR[0]>0.4 && lep_alliso_id[0] < 0.15
if not event_pass: return None
if abs(event.leps_ID_allIso) == 13:
iso_lep = event.lep_alliso_relIso[0] < 0.15
#lep_tlor = TLorentzVector(event.lep_alliso_p4[0])
#tj_p4 = TLorentzVector(p4.X(), p4.Y(), p4.Z(), p4.T())
lep_tlor = TLorentzVector(event.lep_alliso_p4[0].X(), event.lep_alliso_p4[0].Y(), event.lep_alliso_p4[0].Z(), event.lep_alliso_p4[0].T())
ntaus_os = 0
ntaus_ss = 0
first_done = False
for tau_id, tau_p4, lep_match in zip(event.tau_id, event.tau_p4, event.tau_matching_allIso_lep):
# don't match lep
if lep_match: continue
is_os = tau_id * event.lep_alliso_id[0] < 0
if is_os:
ntaus_os += 1
else:
ntaus_ss += 1
if not first_done:
histos[iso_lep]['first_ss_os'].Fill(is_os)
first_done = True
histos[(iso_lep, is_os)]["tau_pt"].Fill(tau_p4.pt())
lep_tau = event.lep_alliso_p4[0] + tau_p4
histos[(iso_lep, is_os)]["lep_tau_mass"].Fill(lep_tau.mass())
histos[(iso_lep, is_os)]["lep_tau_Mt"].Fill(lep_tau.Mt())
lep_minus_tau = event.lep_alliso_p4[0] - tau_p4
histos[(iso_lep, is_os)]["lep_tau_dPhi"].Fill(lep_minus_tau.Phi())
#tau_tlor = TLorentzVector(tau_p4)
tau_tlor = TLorentzVector(tau_p4.X(), tau_p4.Y(), tau_p4.Z(), tau_p4.T())
dR = lep_tlor.DeltaR(tau_tlor)
histos[(iso_lep, is_os)]["lep_tau_dR"].Fill(dR)
histos[iso_lep]["ntaus_os"].Fill(ntaus_os)
histos[iso_lep]["ntaus_ss"].Fill(ntaus_ss)
histos[iso_lep]["ntaus_os_ss"].Fill(ntaus_os, ntaus_ss)
def matchHasOverlap(Chain, index): #Only works for taus at the moment
hasOverlap = False
inputVec = TLorentzVector()
inputVec.SetPtEtaPhiE(Chain._lMatchPt[index], Chain._lMatchEta[index],
Chain._lMatchPhi[index], Chain._lMatchE[index])
for l in xrange(ord(Chain._gen_nL)):
if l == index or Chain._gen_lFlavor == 2: continue
lVec = TLorentzVector()
lVec.SetPtEtaPhiE(Chain._gen_lPt[l], Chain._gen_lEta[l],
Chain._gen_lPhi[l], Chain._gen_lE[l])
dR = inputVec.DeltaR(lVec)
if dR < .4: hasOverlap = True
return hasOverlap
def isCleanJet(Chain, index):
if Chain._jetPt[index] < 25.: return False
if not Chain._jetIsTight[index]: return False
jetVec = TLorentzVector()
jetVec.SetPtEtaPhiE(Chain._jetPt[index], Chain._jetEta[index],
Chain._jetPhi[index], Chain._jetE[index])
for l in xrange(Chain._nL):
lVec = TLorentzVector()
lVec.SetPtEtaPhiE(Chain._lPt[l], Chain._lEta[l], Chain._lPhi[l],
Chain._lE[l])
if jetVec.DeltaR(lVec) < 0.4:
return False
return True
def lepHasOverlap(Chain, index):
#Check the flavor of the lepton and initialize variables
hasOverlap = False
inputVec = TLorentzVector()
inputVec.SetPtEtaPhiE(Chain._lPt[index], Chain._lEta[index],
Chain._lPhi[index], Chain._lE[index])
#Loop over all leptons with a different flavor
for l in xrange(Chain._nL):
if l == index or Chain._lFlavor[l] == Chain._lFlavor[index]: continue
if not isEwkLooseLepton(Chain, l): continue
lVec = getFourVec(Chain._lPt[l], Chain._lEta[l], Chain._lPhi[l],
Chain._lE[l])
dR = inputVec.DeltaR(lVec)
if dR < .4: hasOverlap = True
return hasOverlap
def findMinDr_track(aTrack, tracks, threshold):
drmin = 10
idx = -1
matchingTrack = None
match = False
if aTrack.pt() > 0:
for itrack, track in enumerate(tracks):
if not passesPreselection_basic_track(track): continue
if not track.charge() * aTrack.charge() > 0: continue
if not abs(track.pt() - aTrack.pt()) / aTrack.pt() < 0.2: continue
if not abs(track.eta() - aTrack.eta()) < 0.1: continue
if not abs(deltaPhi(track.phi(), aTrack.phi())) < 1.57: continue
aTrackTlv = TLorentzVector()
aTrackTlv.SetPxPyPzE(aTrack.px(), aTrack.py(), aTrack.pz(),
aTrack.pt() * np.cosh(aTrack.eta()))
trkTlv = TLorentzVector()
trkTlv.SetPxPyPzE(track.px(), track.py(), track.pz(),
track.pt() * np.cosh(track.eta()))
dr = trkTlv.DeltaR(aTrackTlv)
if dr < drmin:
drmin = dr
idx = itrack
matchingTrack = track
if drmin < threshold: match = True
return match, idx, drmin, matchingTrack
def findMatchLepton(Chain, index):
out_index = None
inputVec = TLorentzVector()
inputVec.SetPtEtaPhiE(Chain._lPt[index], Chain._lEta[index],
Chain._lPhi[index], Chain._lE[index])
minDeltaR = 9999999.
for l in xrange(ord(Chain._gen_nL)):
if Chain._gen_lFlavor[l] == Chain._lFlavor[index]: continue
if not Chain._gen_lIsPrompt[l]: continue
lVec = TLorentzVector()
lVec.SetPtEtaPhiE(Chain._gen_lPt[l], Chain._gen_lEta[l],
Chain._gen_lPhi[l], Chain._gen_lE[l])
dR = inputVec.DeltaR(lVec)
if dR < minDeltaR:
out_index = l
minDeltaR = dR
if minDeltaR < .3:
return out_index
else:
return -1
def analyze(self, event):
"""Process event, return True (go to next module) or False (fail, go to next event)."""
## Event filter preselection
passedMETFilters = False
try:
if event.Flag_goodVertices and event.Flag_globalSuperTightHalo2016Filter and event.Flag_BadPFMuonFilter and event.Flag_EcalDeadCellTriggerPrimitiveFilter and event.Flag_HBHENoiseFilter and event.Flag_HBHENoiseIsoFilter and (
self.isMC or event.Flag_eeBadScFilter
) and event.Flag_ecalBadCalibFilter:
passedMETFilters = True
except:
passedMETFilters = False
if not passedMETFilters: return False
## Muon selection:
if not event.HLT_IsoMu27 or not event.Muon_pt[
0] > 30 or not event.Muon_tightId[
0] or not event.Muon_pfRelIso03_all[0] < 0.1:
return False
muon_p4 = TLorentzVector()
muon_p4.SetPtEtaPhiM(event.Muon_pt[0], event.Muon_eta[0],
event.Muon_phi[0], event.Muon_mass[0])
## Loop over Jets
jetIds = []
for ijet in range(event.nJet):
if event.Jet_pt[ijet] < 30: continue
if abs(event.Jet_eta[ijet]) > 2.5: continue
jetIds.append(ijet)
## Jet-based event selections
if len(jetIds) < 2: return False
## Compute dijet quantities
j1_p4 = TLorentzVector()
j1_p4.SetPtEtaPhiM(event.Jet_pt[jetIds[0]], event.Jet_eta[jetIds[0]],
event.Jet_phi[jetIds[0]], event.Jet_mass[jetIds[0]])
j2_p4 = TLorentzVector()
j2_p4.SetPtEtaPhiM(event.Jet_pt[jetIds[1]], event.Jet_eta[jetIds[1]],
event.Jet_phi[jetIds[1]], event.Jet_mass[jetIds[1]])
#self.out.jj_mass[0] = (j1_p4+j2_p4).M()
#self.out.jj_deltaEta[0] = abs(event.Jet_eta[jetIds[0]]-event.Jet_eta[jetIds[1]])
wj1_p4 = j1_p4
wj2_p4 = j2_p4
for ijet in range(event.nJet):
if ijet == jetIds[0] or ijet == jetIds[1]: continue
if event.Jet_pt[ijet] < 30 or abs(event.Jet_eta[ijet]) > 2.5:
continue
j_p4 = TLorentzVector()
j_p4.SetPtEtaPhiM(event.Jet_pt[ijet], event.Jet_eta[ijet],
event.Jet_phi[ijet], event.Jet_mass[ijet])
if j1_p4.DeltaR(j_p4) < 1.1: wj1_p4 += j_p4
if j2_p4.DeltaR(j_p4) < 1.1: wj2_p4 += j_p4
if wj1_p4.DeltaR(muon_p4) < 0.4 or wj2_p4.DeltaR(muon_p4) < 0.4:
return False
self.out.jj_mass_widejet[0] = (wj1_p4 + wj2_p4).M()
self.out.jj_deltaEta_widejet[0] = abs(wj1_p4.Eta() - wj2_p4.Eta())
if self.out.jj_mass_widejet[0] < 800: return False
#fatjetMass = 0.
#if event.nFatJet > 0: fatjetMass = event.FatJet_msoftdrop[0]
#if event.nFatJet > 1: secondaryFatjetMass = event.FatJet_msoftdrop[1]
## Fill jet branches
try:
self.out.HLT_AK8PFJet500[0] = event.HLT_AK8PFJet500
except:
self.out.HLT_AK8PFJet500[0] = -1
try:
self.out.HLT_PFJet500[0] = event.HLT_PFJet500
except:
self.out.HLT_PFJet500[0] = -1
try:
self.out.HLT_CaloJet500_NoJetID[0] = event.HLT_CaloJet500_NoJetID
except:
self.out.HLT_CaloJet500_NoJetID[0] = -1
try:
self.out.HLT_PFHT900[0] = event.HLT_PFHT900
except:
self.out.HLT_PFHT900[0] = -1
try:
self.out.HLT_AK8PFJet550[0] = event.HLT_AK8PFJet550
except:
self.out.HLT_AK8PFJet550[0] = -1
try:
self.out.HLT_PFJet550[0] = event.HLT_PFJet550
except:
self.out.HLT_PFJet550[0] = -1
try:
self.out.HLT_CaloJet550_NoJetID[0] = event.HLT_CaloJet550_NoJetID
except:
self.out.HLT_CaloJet550_NoJetID[0] = -1
try:
self.out.HLT_PFHT1050[0] = event.HLT_PFHT1050
except:
self.out.HLT_PFHT1050[0] = -1
try:
self.out.HLT_DoublePFJets128MaxDeta1p6_DoubleCaloBTagDeepCSV_p71[
0] = event.HLT_DoublePFJets128MaxDeta1p6_DoubleCaloBTagDeepCSV_p71
except:
self.out.HLT_DoublePFJets128MaxDeta1p6_DoubleCaloBTagDeepCSV_p71[
0] = -1
try:
self.out.HLT_DoublePFJets116MaxDeta1p6_DoubleCaloBTagDeepCSV_p71[
0] = event.HLT_DoublePFJets116MaxDeta1p6_DoubleCaloBTagDeepCSV_p71
except:
self.out.HLT_DoublePFJets116MaxDeta1p6_DoubleCaloBTagDeepCSV_p71[
0] = -1
try:
self.out.HLT_DoublePFJets40_CaloBTagDeepCSV_p71[
0] = event.HLT_DoublePFJets40_CaloBTagDeepCSV_p71
except:
self.out.HLT_DoublePFJets40_CaloBTagDeepCSV_p71[0] = -1
try:
self.out.HLT_DoublePFJets100_CaloBTagDeepCSV_p71[
0] = event.HLT_DoublePFJets100_CaloBTagDeepCSV_p71
except:
self.out.HLT_DoublePFJets100_CaloBTagDeepCSV_p71[0] = -1
try:
self.out.HLT_DoublePFJets200_CaloBTagDeepCSV_p71[
0] = event.HLT_DoublePFJets200_CaloBTagDeepCSV_p71
except:
self.out.HLT_DoublePFJets200_CaloBTagDeepCSV_p71[0] = -1
try:
self.out.HLT_DoublePFJets350_CaloBTagDeepCSV_p71[
0] = event.HLT_DoublePFJets350_CaloBTagDeepCSV_p71
except:
self.out.HLT_DoublePFJets350_CaloBTagDeepCSV_p71[0] = -1
self.out.tree.Fill()
return True
def analyze(self, event):
"""Process event, return True (go to next module) or False (fail, go to next event)."""
if self.isMC:
PUWeight = 1. #self.puTool.getWeight(event.Pileup_nTrueInt)
GenWeight = 1.
if 'signal' in self.name.lower():
jetIds = [ ]
for ijet in range(event.nJet):
if event.Jet_pt[ijet] < 30: continue
if abs(event.Jet_eta[ijet]) > 2.5: continue
if event.Jet_jetId[ijet]<6: continue
#if event.Jet_chEmEF[ijet]>0.9: continue ##FIXME
#if (self.year==2017 or self.year==2018) and event.Jet_chEmEF[ijet]>0.8:continue
jetIds.append(ijet)
BTagAK4Weight_deepJet = self.btagToolAK4_deepJet.getWeight(event,jetIds, "central")
BTagAK4Weight_deepJet_up = self.btagToolAK4_deepJet_up.getWeight(event,jetIds, "up")
BTagAK4Weight_deepJet_down = self.btagToolAK4_deepJet_down.getWeight(event,jetIds, "down")
self.out.events.Fill(0., BTagAK4Weight_deepJet)
else:
GenWeight = -1. if event.genWeight<0 else 1.
self.out.events.Fill(0., GenWeight)
try:
LHEWeight = event.LHEWeight_originalXWGTUP
self.out.original.Fill(0.,LHEWeight)
except:
self.out.original.Fill(0.,-1.)
self.out.pileup.Fill(event.Pileup_nTrueInt)
## Event filter preselection
passedMETFilters = False
try:
if event.Flag_goodVertices and event.Flag_globalSuperTightHalo2016Filter and event.Flag_BadPFMuonFilter and event.Flag_EcalDeadCellTriggerPrimitiveFilter and event.Flag_HBHENoiseFilter and event.Flag_HBHENoiseIsoFilter and (self.isMC or event.Flag_eeBadScFilter) and event.Flag_ecalBadCalibFilter:
passedMETFilters = True
except:
passedMETFilters = False
if not passedMETFilters: return False
## jet order check
if event.nJet < 2: return False
if event.Jet_pt[0]>event.Jet_pt[1]:
leading1 = 0
leading2 = 1
else:
leading1 = 1
leading2 = 0
for ijet in range(event.nJet)[2:]:
if event.Jet_pt[ijet] > event.Jet_pt[leading1]:
leading2=leading1
leading1=ijet
elif event.Jet_pt[ijet] > event.Jet_pt[leading2]:
leading2=ijet
## Loop over Jets
jetIds = [ ]
jetHT = 0.
jetBTagLoose, jetBTagMedium, jetBTagTight = 0, 0, 0
for ijet in range(event.nJet):
if event.Jet_pt[ijet] < 30: continue
if abs(event.Jet_eta[ijet]) > 2.5: continue
if event.Jet_jetId[ijet]<6: continue
#if event.Jet_chEmEF[ijet]>0.9: continue ## FIXME
#if (self.year==2017 or self.year==2018) and event.Jet_chEmEF[ijet]>0.8:continue
jetIds.append(ijet)
jetHT += event.Jet_pt[ijet]
if event.Jet_btagDeepFlavB[ijet] >= self.btagLoose: jetBTagLoose += 1
if event.Jet_btagDeepFlavB[ijet] >= self.btagMedium: jetBTagMedium += 1
if event.Jet_btagDeepFlavB[ijet] >= self.btagTight: jetBTagTight += 1
## Jet-based event selections
if len(jetIds)<2: return False
#if event.Jet_jetId[jetIds[0]] < 2: return False
#if event.Jet_jetId[jetIds[1]] < 2: return False
#if event.MET_pt/jetHT > 0.5: return False
### evaluate BTag weights ## put in beginning of analyze in order to get the weight into the normalization
#if 'signal' in self.name.lower():
# BTagAK4Weight_deepJet = self.btagToolAK4_deepJet.getWeight(event,jetIds)
# BTagAK4Weight_deepJet_up = self.btagToolAK4_deepJet_up.getWeight(event,jetIds)
# BTagAK4Weight_deepJet_down = self.btagToolAK4_deepJet_down.getWeight(event,jetIds)
## Compute dijet quantities
j1_p4 = TLorentzVector()
j1_p4.SetPtEtaPhiM(event.Jet_pt[jetIds[0]], event.Jet_eta[jetIds[0]], event.Jet_phi[jetIds[0]], event.Jet_mass[jetIds[0]])
j2_p4 = TLorentzVector()
j2_p4.SetPtEtaPhiM(event.Jet_pt[jetIds[1]], event.Jet_eta[jetIds[1]], event.Jet_phi[jetIds[1]], event.Jet_mass[jetIds[1]])
self.out.jj_mass[0] = (j1_p4+j2_p4).M()
self.out.jj_deltaEta[0] = abs(event.Jet_eta[jetIds[0]]-event.Jet_eta[jetIds[1]])
self.out.jj_deltaPhi[0] = abs(j1_p4.DeltaPhi(j2_p4)) #abs(event.Jet_phi[jetIds[0]]-event.Jet_phi[jetIds[1]]) this does not account for phi jump from 2pi to 0
## Dijet-based event selections
if self.out.jj_mass[0] < 800: return False # will need to change this when deriving the trigger efficiency
j1_p4_lepcorr = j1_p4 * (1. + event.Jet_chEmEF[jetIds[0]]+event.Jet_muEF[jetIds[0]])
j2_p4_lepcorr = j2_p4 * (1. + event.Jet_chEmEF[jetIds[1]]+event.Jet_muEF[jetIds[1]])
self.out.jj_mass_lepcorr[0] = (j1_p4_lepcorr+j2_p4_lepcorr).M()
met_p4 = TLorentzVector()
met_p4.SetPtEtaPhiM(event.MET_pt, 0., event.MET_phi, 0.)
j1_p4_metcorr = j1_p4 * (1. + event.MET_pt/j1_p4.Pt() * math.cos(j1_p4.DeltaPhi(met_p4)+3.1415))
j2_p4_metcorr = j2_p4 * (1. + event.MET_pt/j2_p4.Pt() * math.cos(j2_p4.DeltaPhi(met_p4)+3.1415))
self.out.jj_mass_metcorr[0] = (j1_p4_metcorr+j2_p4_metcorr).M()
wj1_p4 = j1_p4
wj2_p4 = j2_p4
for ijet in range(event.nJet):
if ijet == jetIds[0] or ijet == jetIds[1]: continue
if event.Jet_pt[ijet] < 30 or abs(event.Jet_eta[ijet]) > 2.5: continue
if event.Jet_jetId[ijet]<6: continue
#if event.Jet_chEmEF[ijet]>0.9: continue ## FIXME
#if (self.year==2017 or self.year==2018) and event.Jet_chEmEF[ijet]>0.8:continue
j_p4 = TLorentzVector()
j_p4.SetPtEtaPhiM(event.Jet_pt[ijet], event.Jet_eta[ijet], event.Jet_phi[ijet], event.Jet_mass[ijet])
if j1_p4.DeltaR(j_p4) < 1.1: wj1_p4 += j_p4
if j2_p4.DeltaR(j_p4) < 1.1: wj2_p4 += j_p4
self.out.jj_mass_widejet[0] = (wj1_p4+wj2_p4).M()
self.out.jj_deltaEta_widejet[0] = abs(wj1_p4.Eta() - wj2_p4.Eta())
nIsoElectrons = 0.
for iel in range(event.nElectron):
if event.Electron_pt[iel] > 50. and abs(event.Electron_eta[iel]) < 2.5 and event.Electron_cutBased[iel] >= 2: nIsoElectrons += 1
nIsoMuons = 0.
for imu in range(event.nMuon):
if event.Muon_pt[imu] > 50. and abs(event.Muon_eta[imu]) < 2.4 and event.Muon_highPtId[imu]>=2 and event.Muon_tkRelIso[imu]<0.1: nIsoMuons += 1
if self.isMC:
nGenMuons_1 = 0
nGenMuons_2 = 0
genMuon_pt_1 = 0.
genMuon_pt_2 = 0.
for igen in range(event.nGenPart):
if abs(event.GenPart_pdgId[igen]) == 13:
if ( (event.GenPart_eta[igen] - event.Jet_eta[jetIds[0]])**2 + (event.GenPart_phi[igen] - event.Jet_phi[jetIds[0]])**2 )**0.5 < 0.4:
if event.GenPart_pt[igen]>genMuon_pt_1:
genMuon_pt_1 = event.GenPart_pt[igen]
nGenMuons_1 += 1
if ( (event.GenPart_eta[igen] - event.Jet_eta[jetIds[1]])**2 + (event.GenPart_phi[igen] - event.Jet_phi[jetIds[1]])**2 )**0.5 < 0.4:
if event.GenPart_pt[igen]>genMuon_pt_2:
genMuon_pt_2 = event.GenPart_pt[igen]
nGenMuons_2 += 1
nLooseMuons1, nLooseMuons2 = 0, 0
ptMuons1, ptMuons2 = 0., 0.
MuonWeight_central_1, MuonWeight_central_2 = 1., 1.
MuonWeight_up_1, MuonWeight_up_2 = 1., 1.
MuonWeight_down_1, MuonWeight_down_2 = 1., 1.
################################################################################
n_gen_matched_muons_1, n_gen_matched_muons_2 = 0, 0
gen_matched_muon_pt_1, gen_matched_muon_pt_2 = 0., 0.
smallest_muon_dR_gen_reco_1, smallest_muon_dR_gen_reco_2 = 100., 100.
################################################################################
if event.Jet_muonIdx1[jetIds[0]] >=0 and event.Muon_looseId[event.Jet_muonIdx1[jetIds[0]]] and event.Muon_nStations[event.Jet_muonIdx1[jetIds[0]]] >=3:
nLooseMuons1 += 1
ptMuons1 += event.Muon_pt[event.Jet_muonIdx1[jetIds[0]]]
MuonWeight_central_1 = 1. + (event.Muon_pt[event.Jet_muonIdx1[jetIds[0]]] / 13000.)*(-7)
MuonWeight_up_1 = 1. + (event.Muon_pt[event.Jet_muonIdx1[jetIds[0]]] / 13000.)*(-7 + 28)
MuonWeight_down_1 = 1. + (event.Muon_pt[event.Jet_muonIdx1[jetIds[0]]] / 13000.)*(-7 - 28)
################################################################################
if self.isMC:
for igen in range(event.nGenPart):
if abs(event.GenPart_pdgId[igen]) == 13:
dR_gen_reco = ( (event.GenPart_eta[igen] - event.Muon_eta[event.Jet_muonIdx1[jetIds[0]]])**2 + (event.GenPart_phi[igen] - event.Muon_phi[event.Jet_muonIdx1[jetIds[0]]])**2 )**0.5
if dR_gen_reco < smallest_muon_dR_gen_reco_1:
smallest_muon_dR_gen_reco_1 = dR_gen_reco
if dR_gen_reco < 0.05:
n_gen_matched_muons_1 += 1
gen_matched_muon_pt_1 += event.Muon_pt[event.Jet_muonIdx1[jetIds[0]]]
################################################################################
if event.Jet_muonIdx2[jetIds[0]] >=0 and event.Muon_looseId[event.Jet_muonIdx2[jetIds[0]]] and event.Muon_nStations[event.Jet_muonIdx2[jetIds[0]]] >=3:
nLooseMuons1 += 1
ptMuons1 += event.Muon_pt[event.Jet_muonIdx2[jetIds[0]]]
################################################################################
if self.isMC:
for igen in range(event.nGenPart):
if abs(event.GenPart_pdgId[igen]) == 13:
dR_gen_reco = ( (event.GenPart_eta[igen] - event.Muon_eta[event.Jet_muonIdx2[jetIds[0]]])**2 + (event.GenPart_phi[igen] - event.Muon_phi[event.Jet_muonIdx2[jetIds[0]]])**2 )**0.5
if dR_gen_reco < smallest_muon_dR_gen_reco_1:
smallest_muon_dR_gen_reco_1 = dR_gen_reco
if dR_gen_reco < 0.05:
n_gen_matched_muons_1 += 1
gen_matched_muon_pt_1 += event.Muon_pt[event.Jet_muonIdx2[jetIds[0]]]
################################################################################
if event.Jet_muonIdx1[jetIds[1]] >=0 and event.Muon_looseId[event.Jet_muonIdx1[jetIds[1]]] and event.Muon_nStations[event.Jet_muonIdx1[jetIds[1]]] >=3:
nLooseMuons2 += 1
ptMuons2 += event.Muon_pt[event.Jet_muonIdx1[jetIds[1]]]
MuonWeight_central_2 = 1. + (event.Muon_pt[event.Jet_muonIdx1[jetIds[1]]] / 13000.)*(-7)
MuonWeight_up_2 = 1. + (event.Muon_pt[event.Jet_muonIdx1[jetIds[1]]] / 13000.)*(-7 + 28)
MuonWeight_down_2 = 1. + (event.Muon_pt[event.Jet_muonIdx1[jetIds[1]]] / 13000.)*(-7 - 28)
################################################################################
if self.isMC:
for igen in range(event.nGenPart):
if abs(event.GenPart_pdgId[igen]) == 13:
dR_gen_reco = ( (event.GenPart_eta[igen] - event.Muon_eta[event.Jet_muonIdx1[jetIds[1]]])**2 + (event.GenPart_phi[igen] - event.Muon_phi[event.Jet_muonIdx1[jetIds[1]]])**2 )**0.5
if dR_gen_reco < smallest_muon_dR_gen_reco_2:
smallest_muon_dR_gen_reco_2 = dR_gen_reco
if dR_gen_reco < 0.05:
n_gen_matched_muons_2 += 1
gen_matched_muon_pt_2 += event.Muon_pt[event.Jet_muonIdx1[jetIds[1]]]
################################################################################
if event.Jet_muonIdx2[jetIds[1]] >=0 and event.Muon_looseId[event.Jet_muonIdx2[jetIds[1]]] and event.Muon_nStations[event.Jet_muonIdx2[jetIds[1]]] >=3:
nLooseMuons2 += 1
ptMuons2 += event.Muon_pt[event.Jet_muonIdx2[jetIds[1]]]
################################################################################
if self.isMC:
for igen in range(event.nGenPart):
if abs(event.GenPart_pdgId[igen]) == 13:
dR_gen_reco = ( (event.GenPart_eta[igen] - event.Muon_eta[event.Jet_muonIdx2[jetIds[1]]])**2 + (event.GenPart_phi[igen] - event.Muon_phi[event.Jet_muonIdx2[jetIds[1]]])**2 )**0.5
if dR_gen_reco < smallest_muon_dR_gen_reco_2:
smallest_muon_dR_gen_reco_2 = dR_gen_reco
if dR_gen_reco < 0.05:
n_gen_matched_muons_2 += 1
gen_matched_muon_pt_2 += event.Muon_pt[event.Jet_muonIdx2[jetIds[1]]]
################################################################################
nMediumMuons1, nMediumMuons2 = 0, 0
if event.Jet_muonIdx1[jetIds[0]] >=0 and event.Muon_mediumId[event.Jet_muonIdx1[jetIds[0]]] and event.Muon_nStations[event.Jet_muonIdx1[jetIds[0]]] >=3:
nMediumMuons1 += 1
if event.Jet_muonIdx2[jetIds[0]] >=0 and event.Muon_mediumId[event.Jet_muonIdx2[jetIds[0]]] and event.Muon_nStations[event.Jet_muonIdx2[jetIds[0]]] >=3:
nMediumMuons1 += 1
if event.Jet_muonIdx1[jetIds[1]] >=0 and event.Muon_mediumId[event.Jet_muonIdx1[jetIds[1]]] and event.Muon_nStations[event.Jet_muonIdx1[jetIds[1]]] >=3:
nMediumMuons2 += 1
if event.Jet_muonIdx2[jetIds[1]] >=0 and event.Muon_mediumId[event.Jet_muonIdx2[jetIds[1]]] and event.Muon_nStations[event.Jet_muonIdx2[jetIds[1]]] >=3:
nMediumMuons2 += 1
ptRel1, ptRel2 = 0., 0.
if event.Jet_muonIdx1[jetIds[0]] >=0: ptRel1 = event.Muon_jetPtRelv2[event.Jet_muonIdx1[jetIds[0]]]
if event.Jet_muonIdx1[jetIds[1]] >=0: ptRel2 = event.Muon_jetPtRelv2[event.Jet_muonIdx1[jetIds[1]]]
## Fill jet branches
self.out.njets[0] = len(jetIds)
self.out.jpt_1[0] = event.Jet_pt[jetIds[0]]
self.out.jeta_1[0] = event.Jet_eta[jetIds[0]]
self.out.jphi_1[0] = event.Jet_phi[jetIds[0]]
self.out.jmass_1[0] = event.Jet_mass[jetIds[0]]
self.out.jCSV_1[0] = event.Jet_btagCSVV2[jetIds[0]]
self.out.jdeepCSV_1[0] = event.Jet_btagDeepB[jetIds[0]]
self.out.jdeepFlavour_1[0] = event.Jet_btagDeepFlavB[jetIds[0]]
self.out.jnconst_1[0] = event.Jet_nConstituents[jetIds[0]]
self.out.jchf_1[0] = event.Jet_chHEF[jetIds[0]]
self.out.jnhf_1[0] = event.Jet_neHEF[jetIds[0]]
self.out.jcef_1[0] = event.Jet_chEmEF[jetIds[0]]
self.out.jnef_1[0] = event.Jet_neEmEF[jetIds[0]]
self.out.jmuf_1[0] = event.Jet_muEF[jetIds[0]]
self.out.jmuonpt_1[0] = ptMuons1
self.out.jptRel_1[0] = ptRel1
self.out.jnelectrons_1[0] = event.Jet_nElectrons[jetIds[0]]
self.out.jnmuons_1[0] = event.Jet_nMuons[jetIds[0]]
self.out.jnmuons_loose_1[0] = nLooseMuons1
self.out.jnmuons_medium_1[0] = nMediumMuons1
if self.isMC:
self.out.jnmuons_gen_1[0] = nGenMuons_1
self.out.jnmuons_gen_pt_1[0] = genMuon_pt_1
self.out.jnmuons_loose_genmatched_1[0] = n_gen_matched_muons_1
self.out.jmuonpt_genmatched_1[0] = gen_matched_muon_pt_1
self.out.jflavour_1[0] = event.Jet_hadronFlavour[jetIds[0]]
else:
self.out.jflavour_1[0] = -1
self.out.jmask_1[0] = event.Jet_cleanmask[jetIds[0]]
self.out.jid_1[0] = event.Jet_jetId[jetIds[0]]
self.out.jpt_2[0] = event.Jet_pt[jetIds[1]]
self.out.jeta_2[0] = event.Jet_eta[jetIds[1]]
self.out.jphi_2[0] = event.Jet_phi[jetIds[1]]
self.out.jmass_2[0] = event.Jet_mass[jetIds[1]]
self.out.jCSV_2[0] = event.Jet_btagCSVV2[jetIds[1]]
self.out.jdeepCSV_2[0] = event.Jet_btagDeepB[jetIds[1]]
self.out.jdeepFlavour_2[0] = event.Jet_btagDeepFlavB[jetIds[1]]
self.out.jnconst_2[0] = event.Jet_nConstituents[jetIds[1]]
self.out.jchf_2[0] = event.Jet_chHEF[jetIds[1]]
self.out.jnhf_2[0] = event.Jet_neHEF[jetIds[1]]
self.out.jcef_2[0] = event.Jet_chEmEF[jetIds[1]]
self.out.jnef_2[0] = event.Jet_neEmEF[jetIds[1]]
self.out.jmuf_2[0] = event.Jet_muEF[jetIds[1]]
self.out.jmuonpt_2[0] = ptMuons2
self.out.jptRel_2[0] = ptRel2
self.out.jnelectrons_2[0] = event.Jet_nElectrons[jetIds[1]]
self.out.jnmuons_2[0] = event.Jet_nMuons[jetIds[1]]
self.out.jnmuons_loose_2[0] = nLooseMuons2
self.out.jnmuons_medium_2[0] = nMediumMuons2
if self.isMC:
self.out.jnmuons_gen_2[0] = nGenMuons_2
self.out.jnmuons_gen_pt_2[0] = genMuon_pt_2
self.out.jnmuons_loose_genmatched_2[0] = n_gen_matched_muons_2
self.out.jmuonpt_genmatched_2[0] = gen_matched_muon_pt_2
self.out.jflavour_2[0] = event.Jet_hadronFlavour[jetIds[1]]
self.out.jmuon_gen_reco_dR_1[0] = smallest_muon_dR_gen_reco_1
self.out.jmuon_gen_reco_dR_2[0] = smallest_muon_dR_gen_reco_2
else:
self.out.jflavour_2[0] = -1
self.out.jmask_2[0] = event.Jet_cleanmask[jetIds[1]]
self.out.jid_2[0] = event.Jet_jetId[jetIds[1]]
self.out.jsorted[0] = 0
if leading1==0 and leading2==1: self.out.jsorted[0] = 1
#self.out.MET_over_SumEt[0] = event.MET_pt/jetHT
if event.nFatJet >= 1 and event.FatJet_pt[0] > 200.:
self.out.fatjetmass_1[0] = event.FatJet_msoftdrop[0]
self.out.fatjettau21_1[0] = (event.FatJet_tau2[0]/event.FatJet_tau1[0]) if event.FatJet_tau1[0] > 0. else -1.
self.out.fatjettau21ddt_1[0] = self.out.fatjettau21_1[0] + 0.082*ROOT.TMath.Log(event.FatJet_msoftdrop[0]**2/event.FatJet_pt[0])
self.out.fatjetHbbvsQCD_1[0] = event.FatJet_deepTagMD_HbbvsQCD[0]
self.out.fatjetWvsQCD_1[0] = event.FatJet_deepTagMD_WvsQCD[0]
self.out.fatjetZHbbvsQCD_1[0] = event.FatJet_deepTagMD_ZHbbvsQCD[0]
self.out.fatjetZbbvsQCD_1[0] = event.FatJet_deepTagMD_ZbbvsQCD[0]
self.out.fatjetZvsQCD_1[0] = event.FatJet_deepTagMD_ZvsQCD[0]
self.out.fatjetbbvsLight_1[0] = event.FatJet_deepTagMD_bbvsLight[0]
if event.nFatJet >= 2 and event.FatJet_pt[1] > 200.:
self.out.fatjetmass_2[0] = event.FatJet_msoftdrop[1]
self.out.fatjettau21_2[0] = (event.FatJet_tau2[1]/event.FatJet_tau1[1]) if event.FatJet_tau1[1] > 0. else -1.
self.out.fatjettau21ddt_2[0] = self.out.fatjettau21_2[0] + 0.082*ROOT.TMath.Log(event.FatJet_msoftdrop[1]**2/event.FatJet_pt[1])
self.out.fatjetHbbvsQCD_2[0] = event.FatJet_deepTagMD_HbbvsQCD[1]
self.out.fatjetWvsQCD_2[0] = event.FatJet_deepTagMD_WvsQCD[1]
self.out.fatjetZHbbvsQCD_2[0] = event.FatJet_deepTagMD_ZHbbvsQCD[1]
self.out.fatjetZbbvsQCD_2[0] = event.FatJet_deepTagMD_ZbbvsQCD[1]
self.out.fatjetZvsQCD_2[0] = event.FatJet_deepTagMD_ZvsQCD[1]
self.out.fatjetbbvsLight_2[0] = event.FatJet_deepTagMD_bbvsLight[1]
self.out.ptBalance[0] = (event.Jet_pt[jetIds[0]] - event.Jet_pt[jetIds[1]])/(event.Jet_pt[jetIds[0]] + event.Jet_pt[jetIds[1]])
self.out.HT[0] = jetHT
self.out.MET[0] = event.MET_pt
self.out.nelectrons[0] = nIsoElectrons
self.out.nmuons[0] = nIsoMuons
self.out.nbtagLoose[0] = jetBTagLoose
self.out.nbtagMedium[0] = jetBTagMedium
self.out.nbtagTight[0] = jetBTagTight
## writing the b-tag category directly into the n-tuple. 0:untagged, 1:loose, 2:medium, 3:tight
self.out.jbtag_WP_1[0] = 0
if event.Jet_btagDeepFlavB[jetIds[0]] > self.btagTight:
self.out.jbtag_WP_1[0] = 3
elif event.Jet_btagDeepFlavB[jetIds[0]] > self.btagMedium:
self.out.jbtag_WP_1[0] = 2
elif event.Jet_btagDeepFlavB[jetIds[0]] > self.btagLoose:
self.out.jbtag_WP_1[0] = 1
self.out.jbtag_WP_2[0] = 0
if event.Jet_btagDeepFlavB[jetIds[1]] > self.btagTight:
self.out.jbtag_WP_2[0] = 3
elif event.Jet_btagDeepFlavB[jetIds[1]] > self.btagMedium:
self.out.jbtag_WP_2[0] = 2
elif event.Jet_btagDeepFlavB[jetIds[1]] > self.btagLoose:
self.out.jbtag_WP_2[0] = 1
## fill trigger branches (different years have different triggers 500<->550, 900<->1050)
try:
self.out.HLT_AK8PFJet500[0] = event.HLT_AK8PFJet500
except:
self.out.HLT_AK8PFJet500[0] = -1
try:
self.out.HLT_PFJet500[0] = event.HLT_PFJet500
except:
self.out.HLT_PFJet500[0] = -1
try:
self.out.HLT_CaloJet500_NoJetID[0] = event.HLT_CaloJet500_NoJetID
except:
self.out.HLT_CaloJet500_NoJetID[0] = -1
try:
self.out.HLT_PFHT900[0] = event.HLT_PFHT900
except:
self.out.HLT_PFHT900[0] = -1
try:
self.out.HLT_AK8PFJet550[0] = event.HLT_AK8PFJet550
except:
self.out.HLT_AK8PFJet550[0] = -1
try:
self.out.HLT_PFJet550[0] = event.HLT_PFJet550
except:
self.out.HLT_PFJet550[0] = -1
try:
self.out.HLT_CaloJet550_NoJetID[0] = event.HLT_CaloJet550_NoJetID
except:
self.out.HLT_CaloJet550_NoJetID[0] = -1
try:
self.out.HLT_PFHT1050[0] = event.HLT_PFHT1050
except:
self.out.HLT_PFHT1050[0] = -1
try:
self.out.HLT_DoublePFJets128MaxDeta1p6_DoubleCaloBTagDeepCSV_p71[0] = event.HLT_DoublePFJets128MaxDeta1p6_DoubleCaloBTagDeepCSV_p71
except:
self.out.HLT_DoublePFJets128MaxDeta1p6_DoubleCaloBTagDeepCSV_p71[0] = -1
try:
self.out.HLT_DoublePFJets116MaxDeta1p6_DoubleCaloBTagDeepCSV_p71[0] = event.HLT_DoublePFJets116MaxDeta1p6_DoubleCaloBTagDeepCSV_p71
except:
self.out.HLT_DoublePFJets116MaxDeta1p6_DoubleCaloBTagDeepCSV_p71[0] = -1
try:
self.out.HLT_DoublePFJets40_CaloBTagDeepCSV_p71[0] = event.HLT_DoublePFJets40_CaloBTagDeepCSV_p71
except:
self.out.HLT_DoublePFJets40_CaloBTagDeepCSV_p71[0] = -1
try:
self.out.HLT_DoublePFJets100_CaloBTagDeepCSV_p71[0] = event.HLT_DoublePFJets100_CaloBTagDeepCSV_p71
except:
self.out.HLT_DoublePFJets100_CaloBTagDeepCSV_p71[0] = -1
try:
self.out.HLT_DoublePFJets200_CaloBTagDeepCSV_p71[0] = event.HLT_DoublePFJets200_CaloBTagDeepCSV_p71
except:
self.out.HLT_DoublePFJets200_CaloBTagDeepCSV_p71[0] = -1
try:
self.out.HLT_DoublePFJets350_CaloBTagDeepCSV_p71[0] = event.HLT_DoublePFJets350_CaloBTagDeepCSV_p71
except:
self.out.HLT_DoublePFJets350_CaloBTagDeepCSV_p71[0] = -1
## add weights
try:
self.out.btagWeight_DeepCSVB[0] = event.btagWeight_DeepCSVB
except:
self.out.btagWeight_DeepCSVB[0] = -100.
try:
self.out.LHEWeight_originalXWGTUP[0] = event.LHEWeight_originalXWGTUP
except:
self.out.LHEWeight_originalXWGTUP[0] = -100.
try:
self.out.LHEReweightingWeight[0] = event.LHEReweightingWeight
except:
self.out.LHEReweightingWeight[0] = -100.
try:
self.out.LHEScaleWeight[0] = event.LHEScaleWeight
except:
self.out.LHEScaleWeight[0] = -100.
try:
self.out.PSWeight[0] = event.PSWeight
except:
self.out.PSWeight[0] = -100.
#try:
# self.out.genWeight[0] = event.genWeight
#except:
# self.out.genWeight[0] = -100.
if self.isMC:
self.out.GenWeight[0] = GenWeight
self.out.PUWeight[0] = PUWeight
else:
self.out.GenWeight[0] = 1.
self.out.PUWeight[0] = 1.
if 'signal' in self.name.lower():
self.out.BTagAK4Weight_deepJet[0] = BTagAK4Weight_deepJet
self.out.BTagAK4Weight_deepJet_up[0] = BTagAK4Weight_deepJet_up
self.out.BTagAK4Weight_deepJet_down[0] = BTagAK4Weight_deepJet_down
self.out.MuonWeight[0] = MuonWeight_central_1 * MuonWeight_central_2
self.out.MuonWeight_up[0] = MuonWeight_up_1 * MuonWeight_up_2
self.out.MuonWeight_down[0] = MuonWeight_down_1 * MuonWeight_down_2
## event weight lumi
#eventweightlumi = 1.
#if self.isMC:
# eventweightlumi = self.Leq #minimalist approach, store the things to be multiplied later separately into nTuple
# #eventweightlumi = self.Leq * event.LHEWeight_originalXWGTUP
# #eventweightlumi = self.Leq * event.lheweight * event.btagweight #event.puweight
#self.out.eventweightlumi[0] = eventweightlumi
self.out.isMC[0] = int(self.isMC)
self.out.tree.Fill()
return True
hist = TH2D(file.Get("hist"))
score=0
full=0
tau1 = TLorentzVector()
tau2 = TLorentzVector()
vpool = TLorentzVector()
for i in range(0,len(pooldata[0])):
tau1.SetPtEtaPhiE(tausdata[i*2][0],tausdata[i*2][1],tausdata[i*2][2],tausdata[i*2][3])
tau2.SetPtEtaPhiE(tausdata[i*2+1][0],tausdata[i*2+1][1],tausdata[i*2+1][2],tausdata[i*2+1][3])
truthjet = 0;
for j in range(0,pool):
if(pooldata[j][i][4]==1):
truthjet = j
vpool.SetPtEtaPhiE(pooldata[j][i][0],pooldata[j][i][1],pooldata[j][i][2],pooldata[j][i][3])
break;
drFCNC = vpool.DeltaR(tau1+tau2)
for j in range(0,pool):
if(j == truthjet):
continue
vpool.SetPtEtaPhiE(pooldata[j][i][0],pooldata[j][i][1],pooldata[j][i][2],pooldata[j][i][3])
if(drFCNC>vpool.DeltaR(tau1+tau2)):
score+=1
else:
score-=1
full+=1
hist.Fill(drFCNC,vpool.DeltaR(tau1+tau2),testweight[i])
print(score,full)
file.cd()
hist.Write("hist",TObject.kWriteDelete)
matched_ak4_0 = 0
matched_ak4_1 = 0
jet_0.SetPtEtaPhiM(data_chain.fj_ak8_pt[0], data_chain.fj_ak8_eta[0],
data_chain.fj_ak8_phi[0],
data_chain.fj_ak8_pruned_mass[0])
jet_1.SetPtEtaPhiM(data_chain.fj_ak8_pt[1], data_chain.fj_ak8_eta[1],
data_chain.fj_ak8_phi[1],
data_chain.fj_ak8_pruned_mass[1])
# Jet Matching
for n in range(data_chain.jet_num):
ak4_jet = TLorentzVector(0, 0, 0, 0)
ak4_jet.SetPtEtaPhiM(data_chain.jet_pt[n], data_chain.jet_eta[n],
data_chain.jet_phi[n], data_chain.jet_m[n])
if (ak4_jet.DeltaR(jet_0) < 0.6):
matched_ak4_0 = n
break
for n in range(data_chain.jet_num):
ak4_jet = TLorentzVector(0, 0, 0, 0)
ak4_jet.SetPtEtaPhiM(data_chain.jet_pt[n], data_chain.jet_eta[n],
data_chain.jet_phi[n], data_chain.jet_m[n])
if (ak4_jet.DeltaR(jet_1) < 0.6):
matched_ak4_1 = n
break
if (data_chain.jet_csv[matched_ak4_0] < 0.9):
continue
#make basic checks before continuing
def fillHistogram(self, tree):
for count in range(tree.GetEntries()):
muon_pt = 0
electron_pt = 0
jet_pt = 0
lep_pt = 0
met_pt = 0
tree.GetEntry(count)
jets = getJets(tree)
muons = getMuons(tree)
electrons = getElectrons(tree)
METs = getMissingET(tree)
jetTL = TLorentzVector()
leptonTL = TLorentzVector()
METTL = TLorentzVector()
for jet in jets:
if jet['btag'] == 1:
#print count, jet['pt'], jet['btag']
jet_pt = jet['pt']
jetTL.SetPtEtaPhiM(jet['pt'], jet['eta'], jet['phi'],
jet['mass'])
break
for met in METs:
METTL.SetPtEtaPhiM(met['MET'], met['eta'], met['phi'], 0)
met_pt = met['MET']
break
for muon in muons:
#print count, muon['pt']
muon_pt = muon['pt']
lep_pt = muon['pt']
leptonTL.SetPtEtaPhiM(muon['pt'], muon['eta'], muon['phi'],
muon['mass'])
break
for electron in electrons:
#print count, electron['pt']
electron_pt = electron['pt']
if muon_pt > 0 and electron_pt > muon_pt:
lep_pt = electron['pt']
leptonTL.SetPtEtaPhiM(muon['pt'], muon['eta'], muon['phi'],
muon['mass'])
break
if lep_pt * jet_pt > 0:
#print jet_pt/(jet_pt+muon_pt)
self.TH1F_ratio.Fill(jet_pt / (jet_pt + lep_pt))
self.TH1F_pt.Fill(met_pt)
#elif electron_pt*jet_pt > 0:
#print jet_pt/(jet_pt+electron_pt)
# self.TH1F_ratio.Fill(jet_pt/(jet_pt+electron_pt))
# self.TH1F_pt.Fill(electron_pt)
if jet_pt * met_pt * lep_pt:
self.TH1F_deltaR_MET_b.Fill(jetTL.DeltaR(METTL))
self.TH1F_deltaR_MET_l.Fill(leptonTL.DeltaR(METTL))
self.TH1F_deltaR_b_l.Fill(leptonTL.DeltaR(jetTL))
self.TH1F_deltaPhi_MET_b.Fill(jetTL.DeltaPhi(METTL))
self.TH1F_deltaPhi_MET_l.Fill(leptonTL.DeltaPhi(METTL))
self.TH1F_deltaPhi_b_l.Fill(leptonTL.DeltaPhi(jetTL))
def analyze(self, event):
eventWeightLumi, lheWeight, stitchWeight, puWeight, qcdnloWeight, qcdnnloWeight, ewknloWeight, topWeight = 1., 1., 1., 1., 1., 1., 1., 1.
triggerWeight, leptonWeight = 1., 1.
isDoubleElectronTrigger, isDoubleMuonTrigger, isMuonElectronTrigger = False, False, False
nCleanElectron, nCleanMuon, nCleanTau, nCleanPhoton, nCleanJet, nCleanBTagJet, HT30 = 0, 0, 0, 0, 0, 0, 0
cosThetaStar, cosTheta1, cosTheta2, phi, phi1 = -2., -2., -2., -4., -4.
is4e, is4m, is2e2m = False, False, False
for t in self.DoubleElectronTriggers:
if hasattr(event, t) and getattr(event, t):
isDoubleElectronTrigger = True
for t in self.DoubleMuonTriggers:
if hasattr(event, t) and getattr(event, t):
isDoubleMuonTrigger = True
for t in self.MuonElectronTriggers:
if hasattr(event, t) and getattr(event, t):
isMuonElectronTrigger = True
lheWeight = 1.
if self.isMC:
# Event weight
if not self.isLO and hasattr(event, "LHEWeight_originalXWGTUP"):
lheWeight = event.LHEWeight_originalXWGTUP
# PU weight
puWeight = self.puTool.getWeight(event.Pileup_nTrueInt)
self.hists["Cutflow"].Fill(1, lheWeight)
cleanElectrons, cleanMuons = [], []
# Electrons
for i in range(event.nElectron):
if event.Electron_pt[i] > 7. and abs(
event.Electron_eta[i]
) < 2.5 and event.Electron_mvaFall17V2Iso_WP90[i] and abs(
event.Electron_dxy[i]) < 0.5 and abs(
event.Electron_dz[i]
) < 1.0 and event.Electron_sip3d[i] < 4.:
cleanElectrons += [i]
# Muons
for i in range(event.nMuon):
if event.Muon_pt[i] > 5. and abs(event.Muon_eta[i]) < 2.4 and abs(
event.Muon_dxy[i]) < 0.5 and abs(
event.Muon_dz[i]) < 1.0 and event.Muon_looseId[
i] and event.Muon_pfRelIso03_all[
i] < 0.35 and event.Muon_sip3d[i] < 4.:
cleanMuons += [i]
il1, il2, il3, il4 = -1, -1, -1, -1
l1, l2, l3, l4, z1, z2 = TLorentzVector(), TLorentzVector(
), TLorentzVector(), TLorentzVector(), TLorentzVector(
), TLorentzVector()
lm1, lp1, lm2, lp2 = TLorentzVector(), TLorentzVector(
), TLorentzVector(), TLorentzVector()
# ZZ -> 4mu
if len(cleanMuons) >= 4:
# Try to reconstruct Z1
for i in range(len(cleanMuons)):
for j in range(len(cleanMuons)):
if i == j or (il1 >= 0 and il2 >= 0): continue
if event.Muon_charge[i] * event.Muon_charge[j] > 0:
continue
l1.SetPtEtaPhiM(event.Muon_pt[i], event.Muon_eta[i],
event.Muon_phi[i], event.Muon_mass[i])
l2.SetPtEtaPhiM(event.Muon_pt[j], event.Muon_eta[j],
event.Muon_phi[j], event.Muon_mass[j])
if 40 < (l1 + l2).M() < 120.:
z1, il1, il2 = (l1 + l2), i, j
lm1, lp1 = (l1,
l2) if event.Muon_charge[i] < 0 else (l2,
l1)
# Look for Z2
for i in range(len(cleanMuons)):
for j in range(len(cleanMuons)):
if i == j or i == il1 or j == il1 or i == il2 or j == il2 or (
il3 >= 0 and il4 >= 0):
continue
if event.Muon_charge[i] * event.Muon_charge[j] > 0:
continue
l3.SetPtEtaPhiM(event.Muon_pt[i], event.Muon_eta[i],
event.Muon_phi[i], event.Muon_mass[i])
l4.SetPtEtaPhiM(event.Muon_pt[j], event.Muon_eta[j],
event.Muon_phi[j], event.Muon_mass[j])
if (l3 + l4).M() > 4.:
z2, il3, il4 = (l3 + l4), i, j
lm2, lp2 = (l3,
l4) if event.Muon_charge[i] < 0 else (l4,
l3)
if il1 >= 0 and il2 >= 0 and il3 >= 0 and il4 >= 0 and isDoubleMuonTrigger:
is4m = True
# ZZ -> 4e
elif len(cleanElectrons) >= 4:
# Try to reconstruct Z1
for i in range(len(cleanElectrons)):
for j in range(len(cleanElectrons)):
if i == j or (il1 >= 0 and il2 >= 0): continue
if event.Electron_charge[i] * event.Electron_charge[j] > 0:
continue
l1.SetPtEtaPhiM(event.Electron_pt[i],
event.Electron_eta[i],
event.Electron_phi[i],
event.Electron_mass[i])
l2.SetPtEtaPhiM(event.Electron_pt[j],
event.Electron_eta[j],
event.Electron_phi[j],
event.Electron_mass[j])
if 40 < (l1 + l2).M() < 120.:
z1, il1, il2 = (l1 + l2), i, j
lm1, lp1 = (l1,
l2) if event.Muon_charge[i] < 0 else (l2,
l1)
# Look for Z2
for i in range(len(cleanElectrons)):
for j in range(len(cleanElectrons)):
if i == j or i == il1 or j == il1 or i == il2 or j == il2 or (
il3 >= 0 and il4 >= 0):
continue
if event.Electron_charge[i] * event.Electron_charge[j] > 0:
continue
l3.SetPtEtaPhiM(event.Electron_pt[i],
event.Electron_eta[i],
event.Electron_phi[i],
event.Electron_mass[i])
l4.SetPtEtaPhiM(event.Electron_pt[j],
event.Electron_eta[j],
event.Electron_phi[j],
event.Electron_mass[j])
if (l3 + l4).M() > 4.:
z2, il3, il4 = (l3 + l4), i, j
lm2, lp2 = (l3,
l4) if event.Muon_charge[i] < 0 else (l4,
l3)
if il1 >= 0 and il2 >= 0 and il3 >= 0 and il4 >= 0 and isDoubleElectronTrigger:
is4e = True
# ZZ -> 2e2mu
elif len(cleanMuons) >= 2 and len(cleanElectrons) >= 2:
# Try to reconstruct Z1 (mumu)
for i in range(len(cleanMuons)):
for j in range(len(cleanMuons)):
if i == j or (il1 >= 0 and il2 >= 0): continue
if event.Muon_charge[i] * event.Muon_charge[j] > 0:
continue
l1.SetPtEtaPhiM(event.Muon_pt[i], event.Muon_eta[i],
event.Muon_phi[i], event.Muon_mass[i])
l2.SetPtEtaPhiM(event.Muon_pt[j], event.Muon_eta[j],
event.Muon_phi[j], event.Muon_mass[j])
if (l1 + l2).M() > 4.:
z1, il1, il2 = (l1 + l2), i, j
lm1, lp1 = (l1,
l2) if event.Muon_charge[i] < 0 else (l2,
l1)
# Look for Z2 (ee)
for i in range(len(cleanElectrons)):
for j in range(len(cleanElectrons)):
if i == j or (il3 >= 0 and il3 >= 0): continue
if event.Electron_charge[i] * event.Electron_charge[j] > 0:
continue
l3.SetPtEtaPhiM(event.Electron_pt[i],
event.Electron_eta[i],
event.Electron_phi[i],
event.Electron_mass[i])
l4.SetPtEtaPhiM(event.Electron_pt[j],
event.Electron_eta[j],
event.Electron_phi[j],
event.Electron_mass[j])
if (l3 + l4).M() > 4.:
z2, il3, il4 = (l3 + l4), i, j
lm2, lp2 = (l3,
l4) if event.Muon_charge[i] < 0 else (l4,
l3)
# Swap Z1 and Z2 if needed
if z2.M() > z1.M():
z1, z2 = z2, z1
l1, l2, l3, l4 = l3, l4, l1, l2
lm1, lp1, lm2, lp2 = lm2, lp2, lm1, lp1
il1, il2, il3, il4 = il3, il4, il1, il2
if il1 >= 0 and il2 >= 0 and il3 >= 0 and il4 >= 0 and (
40. < z1.M() < 120.) and z2.M() > 4. and (
isDoubleElectronTrigger or isDoubleMuonTrigger
or isMuonElectronTrigger):
is2e2m = True
if not is4m and not is4e and not is2e2m:
if self.verbose >= 2: print "- No ZZ candidate reconstructed"
return False
self.hists["Cutflow"].Fill(2, lheWeight)
h = z1 + z2
z1_pt = z1.Pt()
z1_eta = z1.Eta()
z1_phi = z1.Phi()
z1_mass = z1.M()
z1_dEta = abs(l1.Eta() - l2.Eta())
z1_dPhi = abs(l1.DeltaPhi(l2))
z1_dR = l1.DeltaR(l2)
z2_pt = z2.Pt()
z2_eta = z2.Eta()
z2_phi = z2.Phi()
z2_mass = z2.M()
z2_dEta = abs(l3.Eta() - l4.Eta())
z2_dPhi = abs(l3.DeltaPhi(l4))
z2_dR = l3.DeltaR(l4)
h_pt = h.Pt()
h_eta = h.Eta()
h_phi = h.Phi()
h_mass = h.M()
h_dEta = abs(z1.Eta() - z2.Eta())
h_dPhi = abs(z1.DeltaPhi(z2))
h_dR = z1.DeltaR(z2)
cosThetaStar = self.returnCosThetaStar(h, z1)
cosTheta1 = self.returnCosTheta1(z1, lp1, lm1, z2)
cosTheta2 = self.returnCosTheta1(z2, lp2, lm2, z1)
phi = self.returnPhi(h, lp1, lm1, lp2, lm2)
phi1 = self.returnPhi1(h, lp1, lm1)
# Weights
if self.isMC:
if is4e: triggerWeight = 0.982 / 0.991
elif is4m: triggerWeight = 1.000 / 0.997
elif is2e2m: triggerWeight = 0.983 / 0.995
# IdSF1 = self.muSFs.getIdSF(event.Muon_pt[0], event.Muon_eta[0], 2)
# IsoSF1 = self.muSFs.getIsoSF(event.Muon_pt[0], event.Muon_eta[0])
# IdSF2 = self.muSFs.getIdSF(event.Muon_pt[1], event.Muon_eta[1], 2)
# IsoSF2 = self.muSFs.getIsoSF(event.Muon_pt[1], event.Muon_eta[1])
# IdIsoSF3 = self.elSFs.getIdIsoSF(event.Electron_pt[0], event.Electron_eta[0])
# leptonWeight = IdSF1 * IsoSF1 * IdSF2 * IsoSF2 * IdIsoSF3
passedMETFilters = True
filters = [
"Flag_goodVertices", "Flag_globalSuperTightHalo2016Filter",
"Flag_BadPFMuonFilter", "Flag_EcalDeadCellTriggerPrimitiveFilter",
"Flag_HBHENoiseFilter", "Flag_HBHENoiseIsoFilter",
"Flag_ecalBadCalibFilter", "Flag_ecalBadCalibFilterV2"
]
if not self.isMC: filters += ["Flag_eeBadScFilter"]
for f in filters:
if hasattr(event, f) and getattr(event, f) == False:
passedMETFilters = False
### Event variables ###
# Muons
nCleanMuon = len(cleanMuons)
# Electrons
nCleanElectron = len(cleanElectrons)
# Taus
for i in range(event.nTau):
if event.Tau_pt[i] > 20. and abs(
event.Tau_eta[i]) < 2.5 and event.Tau_idDeepTau2017v2p1VSe[
i] >= 16 and event.Tau_idDeepTau2017v2p1VSmu[
i] >= 8 and event.Tau_idDeepTau2017v2p1VSjet[
i] >= 16 and event.Tau_rawIsodR03[i] < 0.15:
nCleanTau += 1
# Photons
for i in range(event.nPhoton):
if event.Photon_pt[i] > 15. and abs(
event.Photon_eta[i]) < 2.5 and event.Photon_pfRelIso03_all[
i] < 0.15 and event.Photon_mvaID_WP90[i]:
nCleanPhoton += 1
# Jets and Event variables
for i in range(event.nJet):
if event.Jet_jetId[i] >= 6 and abs(event.Jet_eta[i]) < 2.5:
HT30 += event.Jet_pt[i]
nCleanJet += 1
if event.Jet_btagDeepB[i] >= self.btagMedium:
nCleanBTagJet += 1
if self.isMC:
eventWeightLumi = self.lumiWeight * lheWeight * puWeight * topWeight * qcdnloWeight * qcdnnloWeight * ewknloWeight * triggerWeight * leptonWeight
self.out.fillBranch("isMC", self.isMC)
self.out.fillBranch("is2016", (self.year == 2016))
self.out.fillBranch("is2017", (self.year == 2017))
self.out.fillBranch("is2018", (self.year == 2018))
self.out.fillBranch("is4m", is4m)
self.out.fillBranch("is4e", is4e)
self.out.fillBranch("is2e2m", is2e2m)
self.out.fillBranch("isDoubleElectronTrigger", isDoubleElectronTrigger)
self.out.fillBranch("isDoubleMuonTrigger", isDoubleMuonTrigger)
self.out.fillBranch("isMuonElectronTrigger", isMuonElectronTrigger)
self.out.fillBranch("passedMETFilters", passedMETFilters)
self.out.fillBranch("nCleanElectron", nCleanElectron)
self.out.fillBranch("nCleanMuon", nCleanMuon)
self.out.fillBranch("nCleanTau", nCleanTau)
self.out.fillBranch("nCleanPhoton", nCleanPhoton)
self.out.fillBranch("nCleanJet", nCleanJet)
self.out.fillBranch("nCleanBTagJet", nCleanBTagJet)
self.out.fillBranch("HT30", HT30)
self.out.fillBranch("iLepton1", il1)
self.out.fillBranch("iLepton2", il2)
self.out.fillBranch("iLepton3", il3)
self.out.fillBranch("iLepton4", il4)
self.out.fillBranch("Z1_pt", z1_pt)
self.out.fillBranch("Z1_eta", z1_eta)
self.out.fillBranch("Z1_phi", z1_phi)
self.out.fillBranch("Z1_mass", z1_mass)
self.out.fillBranch("Z1_dEta", z1_dEta)
self.out.fillBranch("Z1_dPhi", z1_dPhi)
self.out.fillBranch("Z1_dR", z1_dR)
self.out.fillBranch("Z2_pt", z2_pt)
self.out.fillBranch("Z2_eta", z2_eta)
self.out.fillBranch("Z2_phi", z2_phi)
self.out.fillBranch("Z2_mass", z2_mass)
self.out.fillBranch("Z2_dEta", z2_dEta)
self.out.fillBranch("Z2_dPhi", z2_dPhi)
self.out.fillBranch("Z2_dR", z2_dR)
self.out.fillBranch("H_pt", h_pt)
self.out.fillBranch("H_eta", h_eta)
self.out.fillBranch("H_phi", h_phi)
self.out.fillBranch("H_mass", h_mass)
self.out.fillBranch("H_dEta", h_dEta)
self.out.fillBranch("H_dPhi", h_dPhi)
self.out.fillBranch("H_dR", h_dR)
self.out.fillBranch("cosThetaStar", cosThetaStar)
self.out.fillBranch("cosTheta1", cosTheta1)
self.out.fillBranch("cosTheta2", cosTheta2)
self.out.fillBranch("phi", phi)
self.out.fillBranch("phi1", phi1)
#self.out.fillBranch("genCosThetaStar", genCosThetaStar)
#self.out.fillBranch("genCosTheta1", genCosTheta1)
#self.out.fillBranch("genPhi1", genPhi1)
self.out.fillBranch("lumiWeight", self.lumiWeight)
self.out.fillBranch("lheWeight", lheWeight)
self.out.fillBranch("stitchWeight", stitchWeight)
self.out.fillBranch("puWeight", puWeight)
self.out.fillBranch("topWeight", topWeight)
self.out.fillBranch("qcdnloWeight", qcdnloWeight)
self.out.fillBranch("qcdnnloWeight", qcdnnloWeight)
self.out.fillBranch("ewknloWeight", ewknloWeight)
self.out.fillBranch("triggerWeight", triggerWeight)
self.out.fillBranch("leptonWeight", leptonWeight)
self.out.fillBranch("eventWeightLumi", eventWeightLumi)
if self.verbose >= 2: print "+ Tree filled"
return True
continue
TLs4 = TLorentzVector()
TLs4.SetPtEtaPhiE(s4.pt(), s4.eta(), s4.phi(), s4.e())
### Reconstructed KS/Lambda collections
# EDM
# KS = f.Events.recoVertexCompositeCandidates_generalV0Candidates_Kshort_RECO.product()
# MiniAOD
nKSL = 0
KS = f.Events.recoVertexCompositePtrCandidates_slimmedKshortVertices__RECO.product(
)
TLk = TLorentzVector()
mK = []
for k in KS:
kl = k.p4()
TLk.SetPtEtaPhiM(kl.pt(), kl.eta(), kl.phi(), kl.mass())
if TLk.DeltaR(TLs4) < 0.5:
print k.numberOfDaughters(), k.daughter(0), k.daughter(
0).pt(), k.daughter(0).eta(), k.daughter(0).phi(), k.daughter(
1), k.daughter(1).pt(), k.daughter(1).eta(), k.daughter(
1).phi(), "V", k.vx(), k.vy(), k.vz() #, dir(k)
print "Match K", k.pt() / s4.pt(), k.mass(), isS
nKSL += 1
mK.append(TLk.Clone())
# EDM
# Lam = f.Events.recoVertexCompositeCandidates_generalV0Candidates_Lambda_RECO.product()\
# MiniAOD
Lam = f.Events.recoVertexCompositePtrCandidates_slimmedLambdaVertices__RECO.product(
)
for k in Lam:
k = k.p4()
TLk.SetPtEtaPhiE(k.pt(), k.eta(), k.phi(), k.e())
dtype=np.dtype([('E', 'f8'), ('px', 'f8'), ('py', 'f8'),
('pz', 'f8')]))
# Jet clustering
sequence = cluster(
vects, R=1.0, p=-1,
ep=True) # antikt: p = -1 , Cambridge/Aachen: p = 0, kt: p = 1
jets = sequence.inclusive_jets(ptmin=100.0)
if not (not jets):
clstr_val = clstr_val + 1
gotawjet = -1
if len(jets) == 1:
jeta = TLorentzVector(jets[0].px, jets[0].py, jets[0].pz, jets[0].e)
dra = jeta.DeltaR(
wpart) # angular distance between w-particle and jet position
if (dra <= 0.5):
wjet = jeta
gotawjet = 0
elif (dra > 0.5):
pass
elif len(jets) == 2:
jeta = TLorentzVector(jets[0].px, jets[0].py, jets[0].pz, jets[0].e)
jetb = TLorentzVector(jets[1].px, jets[1].py, jets[1].pz, jets[1].e)
dra = jeta.DeltaR(wpart)
drb = jetb.DeltaR(wpart)
if (dra < drb and dra < 0.5):
gotawjet = 0
elif (drb <= 0.5):
gotawjet = 1
else:
numBjets = 0
ak8jetsP4 = []
higgsjets = []
higgsSoftDropM = []
# Higgs Tagging with cuts
for j in range(0, nak8jet):
# fill histos with ak8pt and ak8eta
ak8jetP4 = TLorentzVector(0.0, 0.0, 0.0, 0.0)
ak8jetP4.SetPtEtaPhiM(ak8jet_pt[j], ak8jet_eta[j], ak8jet_phi[j],
ak8jet_sdmass[j])
hak8JetPt.Fill(ak8jetP4.Pt(), evtwt)
hak8JetEta.Fill(ak8jetP4.Eta(), evtwt)
hak8JetTau21.Fill(ak8jet_tau2[j] / ak8jet_tau1[j], evtwt)
hdRak8JetlepP4.Fill(ak8jetP4.DeltaR(lepP4), evtwt)
hak8Jetsdmass.Fill(ak8jet_sdmass[j], evtwt)
if ak8jetP4.Pt() < 200.0: continue
if abs(ak8jetP4.Eta()) > 2.4: continue
numak8jets += 1
if len(ak8jet_sj1pt) == 0 or len(ak8jet_sj2pt) == 0: continue
if ak8jet_sdmass[j] < 40: continue
if len(ak8jet_sj1csvv2) <= j or len(ak8jet_sj2csvv2) <= j: continue
hak8jetsj1csvv2.Fill(ak8jet_sj1csvv2[j], evtwt)
hak8jetsj2csvv2.Fill(ak8jet_sj2csvv2[j], evtwt)
# b tagging of subjets
if ak8jet_sj1csvv2[j] < csvv2m: continue
if ak8jet_sj2csvv2[j] < csvv2m: continue
#for i in range(0, len(centjets)):
def analyze(self, event):
"""Process event, return True (go to next module) or False (fail, go to next event)."""
## Event filter preselection
passedMETFilters = False
try:
if event.Flag_goodVertices and event.Flag_globalSuperTightHalo2016Filter and event.Flag_BadPFMuonFilter and event.Flag_EcalDeadCellTriggerPrimitiveFilter and event.Flag_HBHENoiseFilter and event.Flag_HBHENoiseIsoFilter and (self.isMC or event.Flag_eeBadScFilter) and event.Flag_ecalBadCalibFilter:
passedMETFilters = True
except:
passedMETFilters = False
if not passedMETFilters: return False
## jet order check
if event.nJet < 2: return False
if event.Jet_pt_nom[0]>event.Jet_pt_nom[1]:
leading1 = 0
leading2 = 1
else:
leading1 = 1
leading2 = 0
for ijet in range(event.nJet)[2:]:
if event.Jet_pt_nom[ijet] > event.Jet_pt_nom[leading1]:
leading2=leading1
leading1=ijet
elif event.Jet_pt_nom[ijet] > event.Jet_pt_nom[leading2]:
leading2=ijet
## Loop over Jets
jetIds = [ ]
jetHT = 0.
for ijet in range(event.nJet):
if event.Jet_pt_nom[ijet] < 30: continue
if abs(event.Jet_eta[ijet]) > 2.5: continue
if event.Jet_jetId[ijet]<6: continue
jetIds.append(ijet)
jetHT += event.Jet_pt_nom[ijet]
## Jet-based event selections
if len(jetIds)<2: return False
## Compute dijet quantities
j1_p4 = TLorentzVector()
j1_p4.SetPtEtaPhiM(event.Jet_pt_nom[jetIds[0]], event.Jet_eta[jetIds[0]], event.Jet_phi[jetIds[0]], event.Jet_mass_nom[jetIds[0]])
j2_p4 = TLorentzVector()
j2_p4.SetPtEtaPhiM(event.Jet_pt_nom[jetIds[1]], event.Jet_eta[jetIds[1]], event.Jet_phi[jetIds[1]], event.Jet_mass_nom[jetIds[1]])
self.out.jj_mass[0] = (j1_p4+j2_p4).M()
self.out.jj_deltaEta[0] = abs(event.Jet_eta[jetIds[0]]-event.Jet_eta[jetIds[1]])
## Dijet-based event selections
if self.out.jj_mass[0] < 800: return False # will need to change this when deriving the trigger efficiency
j1_p4_lepcorr = j1_p4 * (1. + event.Jet_chEmEF[jetIds[0]]+event.Jet_muEF[jetIds[0]])
j2_p4_lepcorr = j2_p4 * (1. + event.Jet_chEmEF[jetIds[1]]+event.Jet_muEF[jetIds[1]])
self.out.jj_mass_lepcorr[0] = (j1_p4_lepcorr+j2_p4_lepcorr).M()
met_p4 = TLorentzVector()
met_p4.SetPtEtaPhiM(event.MET_pt_nom, 0., event.MET_phi, 0.)
j1_p4_metcorr = j1_p4 * (1. + event.MET_pt_nom/j1_p4.Pt() * math.cos(j1_p4.DeltaPhi(met_p4)+3.1415))
j2_p4_metcorr = j2_p4 * (1. + event.MET_pt_nom/j2_p4.Pt() * math.cos(j2_p4.DeltaPhi(met_p4)+3.1415))
self.out.jj_mass_metcorr[0] = (j1_p4_metcorr+j2_p4_metcorr).M()
wj1_p4 = j1_p4
wj2_p4 = j2_p4
for ijet in range(event.nJet):
if ijet == jetIds[0] or ijet == jetIds[1]: continue
if event.Jet_pt_nom[ijet] < 30 or abs(event.Jet_eta[ijet]) > 2.5: continue
if event.Jet_jetId[ijet]<6: continue
j_p4 = TLorentzVector()
j_p4.SetPtEtaPhiM(event.Jet_pt_nom[ijet], event.Jet_eta[ijet], event.Jet_phi[ijet], event.Jet_mass_nom[ijet])
if j1_p4.DeltaR(j_p4) < 1.1: wj1_p4 += j_p4
if j2_p4.DeltaR(j_p4) < 1.1: wj2_p4 += j_p4
self.out.jj_mass_widejet[0] = (wj1_p4+wj2_p4).M()
self.out.jj_deltaEta_widejet[0] = abs(wj1_p4.Eta() - wj2_p4.Eta())
nIsoElectrons = 0.
for iel in range(event.nElectron):
if event.Electron_pt[iel] > 50. and abs(event.Electron_eta[iel]) < 2.5 and event.Electron_cutBased[iel] >= 2: nIsoElectrons += 1
nIsoMuons = 0.
for imu in range(event.nMuon):
if event.Muon_pt[imu] > 50. and abs(event.Muon_eta[imu]) < 2.4 and event.Muon_highPtId[imu]>=2 and event.Muon_tkRelIso[imu]<0.1: nIsoMuons += 1
nLooseMuons1, nLooseMuons2 = 0, 0
ptMuons1, ptMuons2 = 0., 0.
if event.Jet_muonIdx1[jetIds[0]] >=0 and event.Muon_looseId[event.Jet_muonIdx1[jetIds[0]]]:
nLooseMuons1 += 1
ptMuons1 += event.Muon_pt[event.Jet_muonIdx1[jetIds[0]]]
if event.Jet_muonIdx2[jetIds[0]] >=0 and event.Muon_looseId[event.Jet_muonIdx2[jetIds[0]]]:
nLooseMuons1 += 1
ptMuons1 += event.Muon_pt[event.Jet_muonIdx2[jetIds[0]]]
if event.Jet_muonIdx1[jetIds[1]] >=0 and event.Muon_looseId[event.Jet_muonIdx1[jetIds[1]]]:
nLooseMuons2 += 1
ptMuons2 += event.Muon_pt[event.Jet_muonIdx1[jetIds[1]]]
if event.Jet_muonIdx2[jetIds[1]] >=0 and event.Muon_looseId[event.Jet_muonIdx2[jetIds[1]]]:
nLooseMuons2 += 1
ptMuons2 += event.Muon_pt[event.Jet_muonIdx2[jetIds[1]]]
ptRel1, ptRel2 = 0., 0.
if event.Jet_muonIdx1[jetIds[0]] >=0: ptRel1 = event.Muon_jetPtRelv2[event.Jet_muonIdx1[jetIds[0]]]
if event.Jet_muonIdx1[jetIds[1]] >=0: ptRel2 = event.Muon_jetPtRelv2[event.Jet_muonIdx1[jetIds[1]]]
## Fill jet branches
self.out.njets[0] = len(jetIds)
self.out.jid_1[0] = event.Jet_jetId[jetIds[0]]
self.out.jid_2[0] = event.Jet_jetId[jetIds[1]]
#self.out.MET_over_SumEt[0] = event.MET_pt/jetHT
if event.nFatJet >= 1 and event.FatJet_pt[0] > 200.:
self.out.fatjetmass_1[0] = event.FatJet_msoftdrop[0]
if event.nFatJet >= 2 and event.FatJet_pt[1] > 200.:
self.out.fatjetmass_2[0] = event.FatJet_msoftdrop[1]
self.out.nelectrons[0] = nIsoElectrons
self.out.nmuons[0] = nIsoMuons
## fill trigger branches (different years have different triggers 500<->550, 900<->1050)
try:
self.out.HLT_AK8PFJet500[0] = event.HLT_AK8PFJet500
except:
self.out.HLT_AK8PFJet500[0] = -1
try:
self.out.HLT_PFJet500[0] = event.HLT_PFJet500
except:
self.out.HLT_PFJet500[0] = -1
try:
self.out.HLT_CaloJet500_NoJetID[0] = event.HLT_CaloJet500_NoJetID
except:
self.out.HLT_CaloJet500_NoJetID[0] = -1
try:
self.out.HLT_PFHT900[0] = event.HLT_PFHT900
except:
self.out.HLT_PFHT900[0] = -1
try:
self.out.HLT_AK8PFJet550[0] = event.HLT_AK8PFJet550
except:
self.out.HLT_AK8PFJet550[0] = -1
try:
self.out.HLT_PFJet550[0] = event.HLT_PFJet550
except:
self.out.HLT_PFJet550[0] = -1
try:
self.out.HLT_CaloJet550_NoJetID[0] = event.HLT_CaloJet550_NoJetID
except:
self.out.HLT_CaloJet550_NoJetID[0] = -1
try:
self.out.HLT_PFHT1050[0] = event.HLT_PFHT1050
except:
self.out.HLT_PFHT1050[0] = -1
self.out.isMC[0] = int(self.isMC)
self.out.tree.Fill()
return True
def analyze(self, event):
eventWeightLumi, lheWeight, stitchWeight, puWeight, qcdnloWeight, qcdnnloWeight, ewknloWeight, topWeight = 1., 1., 1., 1., 1., 1., 1., 1.
triggerWeight, leptonWeight = 1., 1.
isSingleMuonTrigger, isSingleMuonPhotonTrigger, isSingleMuonNoFiltersPhotonTrigger, isDoubleMuonTrigger, isDoubleMuonPhotonTrigger, isJPsiTrigger, isDisplacedTrigger = False, False, False, False, False, False, False
nCleanElectron, nCleanMuon, nCleanTau, nCleanPhoton, nCleanJet, nCleanBTagJet, HT30 = 0, 0, 0, 0, 0, 0, 0
cosThetaStar, cosTheta1, phi1 = -2., -2., -4.
genCosThetaStar, genCosTheta1, genPhi1 = -2., -2., -4.
for t in self.SingleMuonTriggers:
if hasattr(event, t) and getattr(event, t): isSingleMuonTrigger = True
for t in self.SingleMuonPhotonTriggers:
if hasattr(event, t) and getattr(event, t): isSingleMuonPhotonTrigger = True
for t in self.SingleMuonNoFiltersPhotonTriggers:
if hasattr(event, t) and getattr(event, t): isSingleMuonNoFiltersPhotonTrigger = True
for t in self.DoubleMuonTriggers:
if hasattr(event, t) and getattr(event, t): isDoubleMuonTrigger = True
for t in self.DoubleMuonPhotonTriggers:
if hasattr(event, t) and getattr(event, t): isDoubleMuonPhotonTrigger = True
for t in self.JPsiTriggers:
if hasattr(event, t) and getattr(event, t): isJPsiTrigger = True
for t in self.DisplacedTriggers:
if hasattr(event, t) and getattr(event, t): isDisplacedTrigger = True
lheWeight = 1.
if self.isMC:
# Event weight
if not self.isLO and hasattr(event, "LHEWeight_originalXWGTUP"): lheWeight = event.LHEWeight_originalXWGTUP
# PU weight
puWeight = self.puTool.getWeight(event.Pileup_nTrueInt)
self.hists["Nevents"].Fill(0, lheWeight)
self.hists["Acceptance"].Fill(0, lheWeight)
self.hists["Cutflow"].Fill(0, lheWeight)
# Gen studies
if self.isMC and self.isSignal:
genHIdx, genJPsiIdx, genMuon1Idx, genMuon2Idx, genPhotonIdx = -1, -1, -1, -1, -1
# print "-"*40
for i in range(event.nGenPart):
# print i, "\t", event.GenPart_pdgId[i], "\t", event.GenPart_status[i], "\t", event.GenPart_statusFlags[i], "\t", event.GenPart_pt[i]
if event.GenPart_pdgId[i] == 25 or event.GenPart_pdgId[i] == 23: genHIdx = i
if event.GenPart_pdgId[i] == 443 and event.GenPart_genPartIdxMother[i] >= 0 and event.GenPart_pdgId[event.GenPart_genPartIdxMother[i]] == 25: genJPsiIdx = i
if event.GenPart_pdgId[i] == 22 and event.GenPart_status[i] in [1, 23] and event.GenPart_genPartIdxMother[i] >= 0 and event.GenPart_pdgId[event.GenPart_genPartIdxMother[i]] == 25: genPhotonIdx = i #and (genPhotonIdx < 0 or event.GenPart_pt[i] > event.GenPart_pt[genPhotonIdx])
if event.GenPart_pdgId[i] == -13 and event.GenPart_status[i] == 1 and event.GenPart_genPartIdxMother[i] >= 0 and event.GenPart_pdgId[event.GenPart_genPartIdxMother[i]] != 22 and (genMuon1Idx < 0 or event.GenPart_pt[i] > event.GenPart_pt[genMuon1Idx]): genMuon1Idx = i
if event.GenPart_pdgId[i] == +13 and event.GenPart_status[i] == 1 and event.GenPart_genPartIdxMother[i] >= 0 and event.GenPart_pdgId[event.GenPart_genPartIdxMother[i]] != 22 and (genMuon2Idx < 0 or event.GenPart_pt[i] > event.GenPart_pt[genMuon2Idx]): genMuon2Idx = i
if genHIdx >= 0 and genJPsiIdx >= 0 and genPhotonIdx >= 0 and genMuon1Idx >= 0 and genMuon2Idx >= 0:
genH, genJPsi, genMuon1, genMuon2, genPhoton = TLorentzVector(), TLorentzVector(), TLorentzVector(), TLorentzVector(), TLorentzVector()
if genHIdx >= 0: genH.SetPtEtaPhiM(event.GenPart_pt[genHIdx], event.GenPart_eta[genHIdx], event.GenPart_phi[genHIdx], event.GenPart_mass[genHIdx])
if genJPsiIdx >= 0: genJPsi.SetPtEtaPhiM(event.GenPart_pt[genJPsiIdx], event.GenPart_eta[genJPsiIdx], event.GenPart_phi[genJPsiIdx], event.GenPart_mass[genJPsiIdx])
if genPhotonIdx >= 0: genPhoton.SetPtEtaPhiM(event.GenPart_pt[genPhotonIdx], event.GenPart_eta[genPhotonIdx], event.GenPart_phi[genPhotonIdx], event.GenPart_mass[genPhotonIdx])
if genMuon1Idx >= 0: genMuon1.SetPtEtaPhiM(event.GenPart_pt[genMuon1Idx], event.GenPart_eta[genMuon1Idx], event.GenPart_phi[genMuon1Idx], event.GenPart_mass[genMuon1Idx])
if genMuon2Idx >= 0: genMuon2.SetPtEtaPhiM(event.GenPart_pt[genMuon2Idx], event.GenPart_eta[genMuon2Idx], event.GenPart_phi[genMuon2Idx], event.GenPart_mass[genMuon2Idx])
# Recalculate candidate 4-vectors for consistent calculation of angular variables
genJPsi = genMuon1 + genMuon2
genH = genJPsi + genPhoton
genCosThetaStar, genCosTheta1, genPhi1 = self.returnCosThetaStar(genH, genJPsi), self.returnCosTheta1(genJPsi, genMuon1, genMuon2, genPhoton), self.returnPhi1(genH, genMuon1, genMuon2)
self.hists["genH_pt"].Fill(genH.Pt(), lheWeight)
self.hists["genH_eta"].Fill(genH.Eta(), lheWeight)
self.hists["genH_phi"].Fill(genH.Phi(), lheWeight)
self.hists["genH_mass"].Fill(genH.M(), lheWeight)
self.hists["genJPsi_pt"].Fill(genJPsi.Pt(), lheWeight)
self.hists["genJPsi_eta"].Fill(genJPsi.Eta(), lheWeight)
self.hists["genJPsi_phi"].Fill(genJPsi.Phi(), lheWeight)
self.hists["genJPsi_mass"].Fill(genJPsi.M(), lheWeight)
self.hists["genPhoton_pt"].Fill(genPhoton.Pt(), lheWeight)
self.hists["genPhoton_eta"].Fill(genPhoton.Eta(), lheWeight)
self.hists["genMuon1_pt"].Fill(max(genMuon1.Pt(), genMuon2.Pt()), lheWeight)
self.hists["genMuon1_eta"].Fill(genMuon1.Eta(), lheWeight)
self.hists["genMuon2_pt"].Fill(min(genMuon1.Pt(), genMuon2.Pt()), lheWeight)
self.hists["genMuon2_eta"].Fill(genMuon2.Eta(), lheWeight)
self.hists["genCosThetaStar"].Fill(genCosThetaStar, lheWeight)
self.hists["genCosTheta1"].Fill(genCosTheta1, lheWeight)
self.hists["genPhi1"].Fill(genPhi1, lheWeight)
self.hists["genCosThetaStarZtoMM"].Fill(self.returnCosThetaStar(genH, genMuon1), lheWeight)
# Reweight
topWeight = 3./4. * (1. + genCosTheta1**2) # Transverse polarization (H, Z)
if 'ZToJPsiG' in self.sampleName:
stitchWeight = 3./2. * (1. - genCosTheta1**2) # Longitudinal polarization (Z)
# Acceptance
if abs(genPhoton.Eta()) < 2.5:
self.hists["Acceptance"].Fill(1, lheWeight)
if abs(genMuon1.Eta()) < 2.4:
self.hists["Acceptance"].Fill(2, lheWeight)
if abs(genMuon2.Eta()) < 2.4:
self.hists["Acceptance"].Fill(3, lheWeight)
self.hists["Cutflow"].Fill(1, lheWeight)
if genPhoton.Pt() > 15. and genMuon1.Pt() > 5. and genMuon2.Pt() > 5.:
self.hists["Acceptance"].Fill(4, lheWeight)
# Muons
m1, m2 = -1, -1
for i in range(event.nMuon):
if event.Muon_pt[i] > self.thMuons[0 if m1 < 0 else 1] and abs(event.Muon_eta[i]) < 2.4 and event.Muon_looseId[i]:
if m1 < 0: m1 = i
if m2 < 0 and m1 >= 0 and event.Muon_charge[m1] != event.Muon_charge[i]: m2 = i
if m1 < 0 or m2 < 0:
if self.verbose >= 2: print "- No OS loose muons in acceptance"
return False
self.hists["Cutflow"].Fill(2, lheWeight)
muon1, muon2 = TLorentzVector(), TLorentzVector()
muon1.SetPtEtaPhiM(event.Muon_pt[m1], event.Muon_eta[m1], event.Muon_phi[m1], event.Muon_mass[m1])
muon2.SetPtEtaPhiM(event.Muon_pt[m2], event.Muon_eta[m2], event.Muon_phi[m2], event.Muon_mass[m2])
muonP = muon1 if event.Muon_charge[m1] > event.Muon_charge[m2] else muon2
muonM = muon1 if event.Muon_charge[m1] < event.Muon_charge[m2] else muon2
muon1v2, muon2v2 = TVector2(muon1.Px(), muon1.Py()), TVector2(muon2.Px(), muon2.Py())
jpsi = muon1 + muon2
if jpsi.M() < 2. or jpsi.M() > 12.:
if self.verbose >= 2: print "- Dimuon invariant mass < 2 or > 12 GeV"
return False
self.hists["Cutflow"].Fill(3, lheWeight)
# Photons
p0 = -1
for i in range(event.nPhoton):
if event.Photon_pt[i] > self.thPhoton[0] and abs(event.Photon_eta[i]) < 2.5 and event.Photon_pfRelIso03_all[i] < 0.25: # and event.Photon_mvaID_WP80[i]:
if p0 < 0: p0 = i
if p0 < 0:
if self.verbose >= 2: print "- No isolated photons in acceptance"
return False
self.hists["Cutflow"].Fill(4, lheWeight)
photon = TLorentzVector()
photon.SetPtEtaPhiM(event.Photon_pt[p0], event.Photon_eta[p0], event.Photon_phi[p0], event.Photon_mass[p0])
photonv2 = TVector2(photon.Px(), photon.Py())
met, metPlusPhoton = TVector2(), TVector2()
met.SetMagPhi(event.MET_pt, event.MET_phi)
metPlusPhoton.Set(met.Px() + photon.Px(), met.Py() + photon.Py())
h = jpsi + photon
jpsi_pt = jpsi.Pt()
jpsi_eta = jpsi.Eta()
jpsi_phi = jpsi.Phi()
jpsi_mass = jpsi.M()
jpsi_dEta = abs(muon1.Eta() - muon2.Eta())
jpsi_dPhi = abs(muon1.DeltaPhi(muon2))
jpsi_dR = muon1.DeltaR(muon2)
h_pt = h.Pt()
h_eta = h.Eta()
h_phi = h.Phi()
h_mass = h.M()
h_dEta = abs(jpsi.Eta() - photon.Eta())
h_dPhi = abs(jpsi.DeltaPhi(photon))
h_dR = jpsi.DeltaR(photon)
Muon1TrkIso, Muon2TrkIso = event.Muon_tkRelIso[m1], event.Muon_tkRelIso[m2]
if jpsi_dR < 0.3:
Muon1TrkIso = max(0., (Muon1TrkIso * event.Muon_pt[m1] * event.Muon_tunepRelPt[m1] - event.Muon_pt[m2] * event.Muon_tunepRelPt[m2])) / (event.Muon_pt[m1] * event.Muon_tunepRelPt[m1])
Muon2TrkIso = max(0., (Muon2TrkIso * event.Muon_pt[m2] * event.Muon_tunepRelPt[m2] - event.Muon_pt[m1] * event.Muon_tunepRelPt[m1])) / (event.Muon_pt[m2] * event.Muon_tunepRelPt[m2])
minMuonTrkIso = min(Muon1TrkIso, Muon2TrkIso)
maxMuonTrkIso = max(Muon1TrkIso, Muon2TrkIso)
minMuonIso = min(event.Muon_pfRelIso03_all[m1], event.Muon_pfRelIso03_all[m2])
maxMuonIso = max(event.Muon_pfRelIso03_all[m1], event.Muon_pfRelIso03_all[m2])
minMuonMetDPhi = min(abs(muon1v2.DeltaPhi(met)), abs(muon2v2.DeltaPhi(met)))
maxMuonMetDPhi = max(abs(muon1v2.DeltaPhi(met)), abs(muon2v2.DeltaPhi(met)))
photonMetDPhi = abs(photonv2.DeltaPhi(met))
metPlusPhotonDPhi = abs(met.DeltaPhi(metPlusPhoton))
cosThetaStar = self.returnCosThetaStar(h, jpsi)
cosTheta1 = self.returnCosTheta1(jpsi, muonP, muonM, photon)
phi1 = self.returnPhi1(h, muonP, muonM)
# Weights
# if self.isMC:
# triggerWeight = self.muSFs.getTriggerSF(event.Muon_pt[m1], event.Muon_eta[m1])
# IdSF1 = self.muSFs.getIdSF(event.Muon_pt[0], event.Muon_eta[0], 2)
# IsoSF1 = self.muSFs.getIsoSF(event.Muon_pt[0], event.Muon_eta[0])
# IdSF2 = self.muSFs.getIdSF(event.Muon_pt[1], event.Muon_eta[1], 2)
# IsoSF2 = self.muSFs.getIsoSF(event.Muon_pt[1], event.Muon_eta[1])
# IdIsoSF3 = self.elSFs.getIdIsoSF(event.Electron_pt[0], event.Electron_eta[0])
# leptonWeight = IdSF1 * IsoSF1 * IdSF2 * IsoSF2 * IdIsoSF3
passedMETFilters = True
filters = ["Flag_goodVertices", "Flag_globalSuperTightHalo2016Filter", "Flag_BadPFMuonFilter", "Flag_EcalDeadCellTriggerPrimitiveFilter", "Flag_HBHENoiseFilter", "Flag_HBHENoiseIsoFilter", "Flag_ecalBadCalibFilter", "Flag_ecalBadCalibFilterV2"]
if not self.isMC: filters += ["Flag_eeBadScFilter"]
for f in filters:
if hasattr(event, f) and getattr(event, f) == False: passedMETFilters = False
# try:
## if event.Flag_goodVertices: print "Flag_goodVertices"
## if event.Flag_globalSuperTightHalo2016Filter: print "Flag_globalSuperTightHalo2016Filter"
## if event.Flag_BadPFMuonFilter: print "Flag_BadPFMuonFilter"
## if event.Flag_EcalDeadCellTriggerPrimitiveFilter: print "Flag_EcalDeadCellTriggerPrimitiveFilter"
## if event.Flag_HBHENoiseFilter: print "Flag_HBHENoiseFilter"
## if event.Flag_HBHENoiseIsoFilter: print "Flag_HBHENoiseIsoFilter"
### if (self.isMC or event.Flag_eeBadScFilter): print "Flag_eeBadScFilter"
## if event.Flag_ecalBadCalibFilter: print "Flag_ecalBadCalibFilterV2"
# if event.Flag_goodVertices and event.Flag_globalSuperTightHalo2016Filter and event.Flag_BadPFMuonFilter and event.Flag_EcalDeadCellTriggerPrimitiveFilter and event.Flag_HBHENoiseFilter and event.Flag_HBHENoiseIsoFilter: # and event.Flag_ecalBadCalibFilter: #and (self.isMC or event.Flag_eeBadScFilter): FIXME
# passedMETFilters = True
## if not self.isMC:
## if not event.Flag_eeBadScFilter:
## passedMETFilters = False
# except:
# passedMETFilters = False
### Event variables ###
# Muons
for i in range(event.nMuon):
if i != m1 and i != m2 and event.Muon_pt[i] > 10. and abs(event.Muon_eta[i]) < 2.4 and event.Muon_looseId[i] and event.Muon_pfRelIso03_all[i] < 0.15:
nCleanMuon += 1
# Electrons
for i in range(event.nElectron):
if event.Electron_pt[i] > 10. and abs(event.Electron_eta[i]) < 2.5 and event.Electron_cutBased[i] >= 2:
nCleanElectron += 1
# Taus
for i in range(event.nTau):
if event.Tau_pt[i] > 20. and abs(event.Tau_eta[i]) < 2.5 and event.Tau_idDeepTau2017v2p1VSe[i] >= 16 and event.Tau_idDeepTau2017v2p1VSmu[i] >= 8 and event.Tau_idDeepTau2017v2p1VSjet[i] >= 16 and event.Tau_rawIsodR03[i] < 0.15:
nCleanTau += 1
# Photons
for i in range(event.nPhoton):
if i != p0 and event.Photon_pt[i] > 15. and abs(event.Photon_eta[i]) < 2.5 and event.Photon_pfRelIso03_all[i] < 0.15 and event.Photon_mvaID_WP90[i]:
nCleanPhoton += 1
# Jets and Event variables
for i in range(event.nJet):
if event.Jet_jetId[i] >= 6 and abs(event.Jet_eta[i]) < 2.5:
HT30 += event.Jet_pt[i]
nCleanJet += 1
if event.Jet_btagDeepB[i] >= self.btagMedium: nCleanBTagJet += 1
if self.isMC: eventWeightLumi = self.lumiWeight * lheWeight * puWeight * topWeight * qcdnloWeight * qcdnnloWeight * ewknloWeight * triggerWeight * leptonWeight
self.out.fillBranch("isMC", self.isMC)
self.out.fillBranch("is2016", (self.year == 2016))
self.out.fillBranch("is2017", (self.year == 2017))
self.out.fillBranch("is2018", (self.year == 2018))
self.out.fillBranch("isSingleMuonTrigger", isSingleMuonTrigger)
self.out.fillBranch("isSingleMuonPhotonTrigger", isSingleMuonPhotonTrigger)
self.out.fillBranch("isSingleMuonNoFiltersPhotonTrigger", isSingleMuonNoFiltersPhotonTrigger)
self.out.fillBranch("isDoubleMuonTrigger", isDoubleMuonTrigger)
self.out.fillBranch("isDoubleMuonPhotonTrigger", isDoubleMuonPhotonTrigger)
self.out.fillBranch("isJPsiTrigger", isJPsiTrigger)
self.out.fillBranch("passedMETFilters", passedMETFilters)
self.out.fillBranch("nCleanElectron", nCleanElectron)
self.out.fillBranch("nCleanMuon", nCleanMuon)
self.out.fillBranch("nCleanTau", nCleanTau)
self.out.fillBranch("nCleanPhoton", nCleanPhoton)
self.out.fillBranch("nCleanJet", nCleanJet)
self.out.fillBranch("nCleanBTagJet", nCleanBTagJet)
self.out.fillBranch("HT30", HT30)
self.out.fillBranch("iPhoton", p0)
self.out.fillBranch("iMuon1", m1)
self.out.fillBranch("iMuon2", m2)
#
self.out.fillBranch("Muon1_pt", event.Muon_pt[m1])
self.out.fillBranch("Muon1_eta", event.Muon_eta[m1])
self.out.fillBranch("Muon2_pt", event.Muon_pt[m2])
self.out.fillBranch("Muon2_eta", event.Muon_eta[m2])
self.out.fillBranch("Muon1_pfRelIso03_all", event.Muon_pfRelIso03_all[m1])
self.out.fillBranch("Muon2_pfRelIso03_all", event.Muon_pfRelIso03_all[m2])
self.out.fillBranch("Muon1_mediumId", event.Muon_mediumId[m1])
self.out.fillBranch("Muon2_mediumId", event.Muon_mediumId[m2])
self.out.fillBranch("Muon1_ip3d", event.Muon_ip3d[m1])
self.out.fillBranch("Muon2_ip3d", event.Muon_ip3d[m2])
self.out.fillBranch("minMuonIso", minMuonIso)
self.out.fillBranch("maxMuonIso", maxMuonIso)
self.out.fillBranch("minMuonTrkIso", minMuonTrkIso)
self.out.fillBranch("maxMuonTrkIso", maxMuonTrkIso)
self.out.fillBranch("Muon12_diffdxy", abs(event.Muon_dxy[m1]-event.Muon_dxy[m2]))
self.out.fillBranch("Muon12_diffdz", abs(event.Muon_dz[m1]-event.Muon_dz[m2]))
self.out.fillBranch("Muon12_signdxy", abs(event.Muon_dxy[m1]-event.Muon_dxy[m2]) / math.sqrt(event.Muon_dxyErr[m1]**2 + event.Muon_dxyErr[m2]**2))
self.out.fillBranch("Muon12_signdz", abs(event.Muon_dz[m1]-event.Muon_dz[m2]) / math.sqrt(event.Muon_dzErr[m1]**2 + event.Muon_dzErr[m2]**2))
self.out.fillBranch("Photon1_pt", event.Photon_pt[p0])
self.out.fillBranch("Photon1_eta", event.Photon_eta[p0])
self.out.fillBranch("Photon1_mvaID_WP80", event.Photon_mvaID_WP80[p0])
self.out.fillBranch("Photon1_pfRelIso03_all", event.Photon_pfRelIso03_all[p0])
#
self.out.fillBranch("JPsi_pt", jpsi_pt)
self.out.fillBranch("JPsi_eta", jpsi_eta)
self.out.fillBranch("JPsi_phi", jpsi_phi)
self.out.fillBranch("JPsi_mass", jpsi_mass)
self.out.fillBranch("JPsi_dEta", jpsi_dEta)
self.out.fillBranch("JPsi_dPhi", jpsi_dPhi)
self.out.fillBranch("JPsi_dR", jpsi_dR)
self.out.fillBranch("H_pt", h_pt)
self.out.fillBranch("H_eta", h_eta)
self.out.fillBranch("H_phi", h_phi)
self.out.fillBranch("H_mass", h_mass)
self.out.fillBranch("H_dEta", h_dEta)
self.out.fillBranch("H_dPhi", h_dPhi)
self.out.fillBranch("H_dR", h_dR)
self.out.fillBranch("minMuonMetDPhi", minMuonMetDPhi)
self.out.fillBranch("maxMuonMetDPhi", maxMuonMetDPhi)
self.out.fillBranch("photonMetDPhi", photonMetDPhi)
self.out.fillBranch("metPlusPhotonDPhi", metPlusPhotonDPhi)
self.out.fillBranch("cosThetaStar", cosThetaStar)
self.out.fillBranch("cosTheta1", cosTheta1)
self.out.fillBranch("phi1", phi1)
self.out.fillBranch("genCosThetaStar", genCosThetaStar)
self.out.fillBranch("genCosTheta1", genCosTheta1)
self.out.fillBranch("genPhi1", genPhi1)
self.out.fillBranch("lumiWeight", self.lumiWeight)
self.out.fillBranch("lheWeight", lheWeight)
self.out.fillBranch("stitchWeight", stitchWeight)
self.out.fillBranch("puWeight", puWeight)
self.out.fillBranch("topWeight", topWeight)
self.out.fillBranch("qcdnloWeight", qcdnloWeight)
self.out.fillBranch("qcdnnloWeight", qcdnnloWeight)
self.out.fillBranch("ewknloWeight", ewknloWeight)
self.out.fillBranch("triggerWeight", triggerWeight)
self.out.fillBranch("leptonWeight", leptonWeight)
self.out.fillBranch("eventWeightLumi", eventWeightLumi)
if self.verbose >= 2: print "+ Tree filled"
return True
pz3 = float(b[0].split()[8])
e3 = float(b[0].split()[9])
px4 = float(bbar[0].split()[6])
py4 = float(bbar[0].split()[7])
pz4 = float(bbar[0].split()[8])
e4 = float(bbar[0].split()[9])
p3 = TLorentzVector(px3, py3, pz3, e3)
p4 = TLorentzVector(px4, py4, pz4, e4)
pb = p3 + p4
pt_b.append(p3.Pt())
eta_b.append(p3.Eta())
pt_bbar.append(p4.Pt())
eta_bbar.append(p4.Eta())
DR.append(abs(p3.DeltaR(p4)))
h1_met = TH1F("genMET", "", 100, 0, 1000)
for i in met:
h1_met.Fill(i)
h1_DR = TH1F("DR(b,bbar)", "", 5, 0, 5)
for i in DR:
h1_DR.Fill(i)
h_ptb = TH1F("pT of b", "", 100, 0, 1000)
for i in pt_b:
h_ptb.Fill(i)
h_etab = TH1F("Eta of b", "", 10, -5, 5)
for i in eta_b:
def process_event_for_fake_taus(ev):
global prefix
# pass conditions
# tt gen = lepton + jets
t_wid = abs(ev.gen_t_w_decay_id)
tb_wid = abs(ev.gen_tb_w_decay_id)
prefix, is_lep_jets = 'lj', (t_wid == 1 and
(tb_wid == 11 or tb_wid == 13)) or (
tb_wid == 1 and
(t_wid == 11 or t_wid == 13))
prefix, is_lep_tau = 'tau', (t_wid > 15 * 15 and
(tb_wid == 11 or tb_wid == 13)) or (
tb_wid > 15 * 15 and
(t_wid == 11 or t_wid == 13))
if not (is_lep_jets or is_lep_tau):
return None
# reco conditions: 1 good 3ch high SV tau
#if not (abs(ev.leps_ID) == 13 and ev.HLT_mu and ev.lep_matched_HLT[0]): continue
if not (abs(ev.leps_ID) == 13 or abs(ev.leps_ID) == 11): return None
if len(ev.tau_p4) < 1: return None
# medium tau and SV > 2.
taus_main = zip(ev.tau_IDlev, ev.tau_p4, ev.tau_id, ev.tau_refited_index)
taus_main.sort(key=lambda it: (it[0], it[1].pt()), reverse=True)
# use tau_refited_index to access teh geometric SV
if taus_main[0][0] < 3: return None
# SV data
main_tau = taus_main[0]
main_tau_refit_index = main_tau[3]
if main_tau_refit_index > -1:
main_tau_SV_sign = ev.tau_SV_geom_flightLenSign[main_tau_refit_index]
main_tau_SV_leng = ev.tau_SV_geom_flightLen[main_tau_refit_index]
# dalitz parameters
tau_track_lengs = len(ev.tau_SV_fit_track_OS_p4) == len(
ev.tau_SV_fit_track_SS1_p4) == len(ev.tau_SV_fit_track_SS2_p4)
if not tau_track_lengs:
print "the problem in tau track lists tau_track_lengs"
return None
out_of_range = main_tau_refit_index > len(ev.tau_SV_fit_track_OS_p4)
out_of_range |= main_tau_refit_index > len(ev.tau_SV_fit_track_SS1_p4)
out_of_range |= main_tau_refit_index > len(ev.tau_SV_fit_track_SS2_p4)
if out_of_range:
print "the problem in tau track lists main_tau_refit_index"
return None
dalitz_m1 = (ev.tau_SV_fit_track_OS_p4[main_tau_refit_index] +
ev.tau_SV_fit_track_SS1_p4[main_tau_refit_index]).mass()
dalitz_m2 = (ev.tau_SV_fit_track_OS_p4[main_tau_refit_index] +
ev.tau_SV_fit_track_SS2_p4[main_tau_refit_index]).mass()
tau_track_mass = (
ev.tau_SV_fit_track_OS_p4[main_tau_refit_index] +
ev.tau_SV_fit_track_SS1_p4[main_tau_refit_index] +
ev.tau_SV_fit_track_SS2_p4[main_tau_refit_index]).mass()
# trying the algorithm with more energetic track
if ev.tau_SV_fit_track_SS1_p4[main_tau_refit_index].energy(
) > ev.tau_SV_fit_track_SS2_p4[main_tau_refit_index].energy():
more_en_ss_track = ev.tau_SV_fit_track_SS1_p4[main_tau_refit_index]
less_en_ss_track = ev.tau_SV_fit_track_SS2_p4[main_tau_refit_index]
else:
more_en_ss_track = ev.tau_SV_fit_track_SS2_p4[main_tau_refit_index]
less_en_ss_track = ev.tau_SV_fit_track_SS1_p4[main_tau_refit_index]
dalitz_m1_perE = (ev.tau_SV_fit_track_OS_p4[main_tau_refit_index] +
more_en_ss_track).mass()
dalitz_m2_perE = (ev.tau_SV_fit_track_OS_p4[main_tau_refit_index] +
less_en_ss_track).mass()
more_en_ss_track_energy = more_en_ss_track.energy()
less_en_ss_track_energy = less_en_ss_track.energy()
else:
main_tau_SV_sign = -11.
main_tau_SV_leng = -11.
dalitz_m1 = -11.
dalitz_m2 = -11.
tau_track_mass = -11.
dalitz_m1_perE = -11.
dalitz_m2_perE = -11.
more_en_ss_track_energy = -11.
less_en_ss_track_energy = -11.
# SV > 2.
if main_tau_SV_sign < 2.: return None
# basic data on the main tau
main_tau_p4 = main_tau[1]
if main_tau_p4.pt() < 21.: return None
#TLorentzVector::TLorentzVector(double x, double y, double z, double t) =>
tau_p4_tlor = TLorentzVector(main_tau_p4.X(), main_tau_p4.Y(),
main_tau_p4.Z(), main_tau_p4.T())
# for fake tous figure out is the origin b or W
# print out the final products around tau, sorted by dR
print 'tau', round2(main_tau_p4.eta()), round2(
main_tau_p4.phi()), round3(main_tau_SV_sign), round3(main_tau_SV_leng)
fake_taus_t_w = []
fake_taus_t_b = []
fake_taus_tb_w = []
fake_taus_tb_b = []
final_products = [
('tw1', fake_taus_t_w, ev.gen_t_w1_final_pdgIds,
ev.gen_t_w1_final_statuses, ev.gen_t_w1_final_p4s),
#('tw2', fake_taus_t_w, ev.gen_t_w2_final_pdgIds, ev.gen_t_w2_final_statuses, ev.gen_t_w2_final_p4s), # repetition
('tb', fake_taus_t_b, ev.gen_t_b_final_pdgIds,
ev.gen_t_b_final_statuses, ev.gen_t_b_final_p4s),
('tbw1', fake_taus_tb_w, ev.gen_tb_w1_final_pdgIds,
ev.gen_tb_w1_final_statuses, ev.gen_tb_w1_final_p4s),
#('tbw2', fake_taus_tb_w, ev.gen_tb_w2_final_pdgIds, ev.gen_tb_w2_final_statuses, ev.gen_tb_w2_final_p4s),
('tbb', fake_taus_tb_b, ev.gen_tb_b_final_pdgIds,
ev.gen_tb_b_final_statuses, ev.gen_tb_b_final_p4s),
]
# process the products per origin
if is_lep_jets:
for origin, fakes_close_in_dR, pdgIDs, statuses, p4s in final_products:
#tau_p4_tlor = TLorentzVector(main_tau_p4)
products_per_dR = []
for prod in zip(pdgIDs, statuses, p4s):
# skip neutrinos (did not remove them in b decays)
# actually should have kept them everywhere
if abs(prod[0]) in (12, 14, 16): continue
#dR = prod[2].DeltaR(main_tau_p4)
#prod_p4_tlor = TLorentzVector(prod[2])
prod_p4_tlor = TLorentzVector(prod[2].X(), prod[2].Y(),
prod[2].Z(), prod[2].T())
dR = prod_p4_tlor.DeltaR(tau_p4_tlor)
if dR > 0.4: continue
else:
a_close_fake = (dR, prod[0], prod[1], prod[2])
products_per_dR.append(a_close_fake)
fakes_close_in_dR.append(a_close_fake)
if not products_per_dR: continue
# sort by dR
products_per_dR.sort(key=lambda p: p[0])
fakes_close_in_dR.sort(key=lambda p: p[0])
# print in 1 line
#products_per_dR.append((round3(dR), prod[0], prod[1], round(prod[2].eta(),2), round(prod[2].phi(), 2)))
print origin, [(round3(prod[0]), prod[1], prod[2],
round2(prod[3].eta()), round2(prod[3].phi()))
for prod in products_per_dR]
if is_lep_jets:
#is_w = (ev.gen_t_w1_final_pdgIds.size() + ev.gen_tb_w1_final_pdgIds.size()) > 0
#is_b = (ev.gen_t_b_final_pdgIds.size() + ev.gen_tb_b_final_pdgIds.size() ) > 0
is_w = (len(fake_taus_t_w) + len(fake_taus_tb_w)) > 0
is_b = (len(fake_taus_t_b) + len(fake_taus_tb_b)) > 0
if is_w and not (is_b):
prefix = 'ljw'
elif is_b and not (is_w):
prefix = 'ljb'
else:
prefix = 'ljo'
for origin, products_per_dR in [('tw', fake_taus_t_w),
('tb', fake_taus_t_b),
('tbw', fake_taus_tb_w),
('tbb', fake_taus_tb_b)]:
# save info about products
if origin in ('tb', 'tbb'):
for dR, pdgID, _, _ in products_per_dR:
output_histos('tau_fake_tb').Fill(abs(pdgID))
if dR < 0.1:
output_histos('tau_fake_tb_close').Fill(abs(pdgID))
elif 'w' in origin:
for dR, pdgID, _, _ in products_per_dR:
output_histos('tau_fake_tw').Fill(abs(pdgID))
if dR < 0.1:
output_histos('tau_fake_tw_close').Fill(abs(pdgID))
output_histos('tau_IDlev').Fill(main_tau[0])
output_histos('tau_pt').Fill(main_tau_p4.pt())
output_histos('tau_eta').Fill(main_tau_p4.eta())
output_histos('tau_mass').Fill(main_tau_p4.mass())
output_histos('tau_track_mass').Fill(tau_track_mass)
output_histos('tau_R1').Fill(ev.tau_leadChargedHadrCand_pt[0] /
main_tau_p4.pt())
output_histos('tau_R2').Fill(ev.tau_leadCand_pt[0] / main_tau_p4.pt())
# SV related params
output_histos('tau_sv_sign').Fill(main_tau_SV_sign)
output_histos('tau_sv_leng').Fill(main_tau_SV_leng)
output_histos('tau_sv_leng_VS_energy').Fill(main_tau_SV_leng,
main_tau_p4.energy())
output_histos('tau_m1').Fill(dalitz_m1)
output_histos('tau_m2').Fill(dalitz_m2)
output_histos('tau_m1_m2').Fill(dalitz_m1, dalitz_m2)
output_histos('tau_perE_m1').Fill(dalitz_m1_perE)
output_histos('tau_perE_m2').Fill(dalitz_m2_perE)
output_histos('tau_perE_m1_m2').Fill(dalitz_m1_perE, dalitz_m2_perE)
output_histos('tau_perE_e1').Fill(more_en_ss_track_energy)
output_histos('tau_perE_e2').Fill(less_en_ss_track_energy)
output_histos('tau_perE_e1_e2').Fill(more_en_ss_track_energy,
less_en_ss_track_energy)
output_histos('tau_perE_e1_m2').Fill(more_en_ss_track_energy,
dalitz_m2_perE)
output_histos('tau_perE_e1_m1').Fill(more_en_ss_track_energy,
dalitz_m1_perE)
output_histos('tau_perE_e2_m2').Fill(less_en_ss_track_energy,
dalitz_m2_perE)
output_histos('tau_perE_e2_m1').Fill(less_en_ss_track_energy,
dalitz_m1_perE)
def analyze(self, event):
## initialize ##
# Just copy from former parts
self.out.fillBranch("MVAinput_nGoodJet", event._tree.b_out_nGoodJet)
self.out.fillBranch("MVAinput_Z_mass", event._tree.b_out_Z_mass)
self.out.fillBranch("MVAinput_W_mass", event._tree.b_out_W_MT)
self.out.fillBranch("MVAinput_ZWL_dPhi",
event._tree.b_out_TriLepton_WleptonZdPhi)
self.out.fillBranch("MVAinput_ZWL_dR",
event._tree.b_out_TriLepton_WleptonZdR)
self.out.fillBranch("MVAinput_MET", event._tree.b_out_MET_pt)
self.out.fillBranch("MVAinput_MET_Phi", event._tree.b_out_MET_phi)
self.out.fillBranch("MVAinput_TLepton_mass",
event._tree.b_out_TriLepton_mass)
self.out.fillBranch("MVAinput_nbJet", event._tree.b_out_nBjet)
# Basic event selection for WZCR/TTCR
if ((event._tree.b_out_GoodLeptonCode != 111)
or (event._tree.b_out_nGoodLepton > 3)
or (event._tree.b_out_W_MT > 300)):
self.out.fillBranch("MVAinput_Status", 0)
#self.out.fillBranch("MVAinput_nGoodJet", 0)
self.out.fillBranch("MVAinput_WLZL1_dPhi", 0)
self.out.fillBranch("MVAinput_WLZL1_dR", 0)
self.out.fillBranch("MVAinput_WLZL2_dPhi", 0)
self.out.fillBranch("MVAinput_WLZL2_dR", 0)
self.out.fillBranch("MVAinput_ZL1ZL2_dPhi", 0)
self.out.fillBranch("MVAinput_ZL1ZL2_dR", 0)
#self.out.fillBranch("MVAinput_Z_mass", 0)
#self.out.fillBranch("MVAinput_W_mass", 0)
#self.out.fillBranch("MVAinput_ZWL_dPhi", 0)
#self.out.fillBranch("MVAinput_ZWL_dR", 0)
#self.out.fillBranch("MVAinput_MET", 0)
#self.out.fillBranch("MVAinput_MET_Phi", 0)
#self.out.fillBranch("MVAinput_TLepton_mass", 0)
self.out.fillBranch("MVAinput_J1_DeepJetB", 0)
self.out.fillBranch("MVAinput_J1_pt", 0)
self.out.fillBranch("MVAinput_ZL1J1_dPhi", 0)
self.out.fillBranch("MVAinput_ZL1J1_dR", 0)
self.out.fillBranch("MVAinput_ZL2J1_dPhi", 0)
self.out.fillBranch("MVAinput_ZL2J1_dR", 0)
self.out.fillBranch("MVAinput_WLJ1_dPhi", 0)
self.out.fillBranch("MVAinput_WLJ1_dR", 0)
#self.out.fillBranch("MVAinput_nbJet", 0)
self.out.fillBranch("MVAinput_bJ_DeepJetB", 0)
self.out.fillBranch("MVAinput_qJ_DeepJetB", 0)
self.out.fillBranch("MVAinput_bJ_pt", 0)
self.out.fillBranch("MVAinput_qJ_pt", 0)
self.out.fillBranch("MVAinput_bJqJ_dPhi", 0)
self.out.fillBranch("MVAinput_bJqJ_dR", 0)
self.out.fillBranch("MVAinput_WLbJ_dPhi", 0)
self.out.fillBranch("MVAinput_WLqJ_dR", 0)
self.out.fillBranch("MVAinput_WLbJ_dPhi", 0)
self.out.fillBranch("MVAinput_WLbJ_dR", 0)
self.out.fillBranch("MVAinput_ZL1bJ_dPhi", 0)
self.out.fillBranch("MVAinput_ZL1bJ_dR", 0)
self.out.fillBranch("MVAinput_ZL1qJ_dPhi", 0)
self.out.fillBranch("MVAinput_ZL1qJ_dR", 0)
self.out.fillBranch("MVAinput_ZL2bJ_dPhi", 0)
self.out.fillBranch("MVAinput_ZL2bJ_dR", 0)
self.out.fillBranch("MVAinput_ZL2qJ_dPhi", 0)
self.out.fillBranch("MVAinput_ZL2qJ_dR", 0)
#self.out.fillBranch("MVAinput_SMTop_mass", 0)
#self.out.fillBranch("MVAinput_FCNCTop_mass", 0)
#self.out.fillBranch("MVAinput_TopTop_dEta", 0)
#self.out.fillBranch("MVAinput_TopTop_dPhi", 0)
return True
else:
# Booking and filling variables for basic variables
Z1Lepton = TLorentzVector()
Z2Lepton = TLorentzVector()
WLepton = TLorentzVector()
ConstZ = TLorentzVector()
Jet1 = TLorentzVector() # For WZCR
bJet = TLorentzVector() # For TTCR
qJet = TLorentzVector() # For TTCR
WLepton.SetPtEtaPhiM(event._tree.b_out_Lepton1_pt,
event._tree.b_out_Lepton1_eta,
event._tree.b_out_Lepton1_phi,
event._tree.b_out_Lepton1_mass)
Z1Lepton.SetPtEtaPhiM(event._tree.b_out_Lepton2_pt,
event._tree.b_out_Lepton2_eta,
event._tree.b_out_Lepton2_phi,
event._tree.b_out_Lepton2_mass)
Z2Lepton.SetPtEtaPhiM(event._tree.b_out_Lepton2_pt,
event._tree.b_out_Lepton2_eta,
event._tree.b_out_Lepton2_phi,
event._tree.b_out_Lepton2_mass)
ConstZ.SetPtEtaPhiM(event._tree.b_out_Z_pt,
event._tree.b_out_Z_eta,
event._tree.b_out_Z_phi,
event._tree.b_out_Z_mass)
self.out.fillBranch("MVAinput_WLZL1_dPhi",
WLepton.DeltaPhi(Z1Lepton))
self.out.fillBranch("MVAinput_WLZL1_dR", WLepton.DeltaR(Z1Lepton))
self.out.fillBranch("MVAinput_WLZL2_dPhi",
WLepton.DeltaPhi(Z2Lepton))
self.out.fillBranch("MVAinput_WLZL2_dR", WLepton.DeltaR(Z2Lepton))
self.out.fillBranch("MVAinput_ZL1ZL2_dPhi",
Z1Lepton.DeltaPhi(Z2Lepton))
self.out.fillBranch("MVAinput_ZL1ZL2_dR",
Z1Lepton.DeltaR(Z1Lepton))
# For WZCR case
if ( ( abs( ConstZ.M() - 91.2) < 7.5 ) and ( event._tree.b_out_nGoodJet >= 1 ) and\
( event._tree.b_out_nBjet == 0 ) and ( event._tree.b_out_LeadingLepton_pt > 25 ) and ( event._tree.b_out_Z_charge == 0 ) ):
Jet1.SetPtEtaPhiM(event._tree.b_out_GoodJet_pt[0],
event._tree.b_out_GoodJet_eta[0],
event._tree.b_out_GoodJet_phi[0],
event._tree.b_out_GoodJet_mass[0])
self.out.fillBranch("MVAinput_J1_DeepJetB",
event._tree.b_out_GoodJet_DeepFlavB[0]
) # Should be changed to DeepJet b tagger
self.out.fillBranch("MVAinput_J1_pt", Jet1.Pt())
self.out.fillBranch("MVAinput_ZL1J1_dPhi",
Z1Lepton.DeltaPhi(Jet1))
self.out.fillBranch("MVAinput_ZL1J1_dR", Z1Lepton.DeltaR(Jet1))
self.out.fillBranch("MVAinput_ZL2J1_dPhi",
Z2Lepton.DeltaPhi(Jet1))
self.out.fillBranch("MVAinput_ZL2J1_dR", Z2Lepton.DeltaR(Jet1))
self.out.fillBranch("MVAinput_WLJ1_dPhi",
WLepton.DeltaPhi(Jet1))
self.out.fillBranch("MVAinput_WLJ1_dR", WLepton.DeltaR(Jet1))
self.out.fillBranch("MVAinput_Status",
1) # Status flag 1 : WZCR
return True
# For TTCR case
elif ( not( 20 < abs(ConstZ.M() - 91.2) < 60 ) and ( 2 <= event._tree.b_out_nGoodJet <= 3) and\
( event._tree.b_out_nBjet >= 1 ) and ( event._tree.b_out_LeadingLepton_pt > 25 ) and ( event._tree.b_out_Z_charge == 0 ) ):
BJet = TLorentzVector()
QJet = TLorentzVector()
BJet.SetPtEtaPhiM(event._tree.b_out_GoodJet_pt[0],
event._tree.b_out_GoodJet_eta[0],
event._tree.b_out_GoodJet_phi[0],
event._tree.b_out_GoodJet_mass[0])
QJet.SetPtEtaPhiM(event._tree.b_out_GoodJet_pt[1],
event._tree.b_out_GoodJet_eta[1],
event._tree.b_out_GoodJet_phi[1],
event._tree.b_out_GoodJet_mass[1])
btagBj = event._tree.b_out_GoodJet_DeepFlavB[
0] # Should be changed to DeepJet b tagger
btagQj = event._tree.b_out_GoodJet_DeepFlavB[
1] # Should be changed to DeepJet b tagger
if (btagBj < btagQj):
BJet, QJet = QJet, BJet
btagBj, btagQj = btagBj, btagQj
#SMTop = TLorentzVector()
#FCNCTop = TLorentzVector()
#SMTop.SetPtEtaPhiM(event._tree.b_out_KinTopWb_pt, event._tree.b_out_KinTopWb_eta, event._tree.b_out_KinTopWb_phi, event._tree.b_out_KinTopWb_mass)
#FCNCTop.SetPtEtaPhiM(event._tree.b_out_KinTopZq_pt, event._tree.b_out_KinTopZq_eta, event._tree.b_out_KinTopZq_phi, event._tree.b_out_KinTopZq_mass)
self.out.fillBranch("MVAinput_bJ_DeepJetB", btagBj)
self.out.fillBranch("MVAinput_qJ_DeepJetB", btagQj)
self.out.fillBranch("MVAinput_bJ_pt", BJet.Pt())
self.out.fillBranch("MVAinput_qJ_pt", QJet.Pt())
self.out.fillBranch("MVAinput_bJqJ_dPhi", BJet.DeltaPhi(QJet))
self.out.fillBranch("MVAinput_bJqJ_dR", BJet.DeltaR(QJet))
self.out.fillBranch("MVAinput_WLbJ_dPhi",
WLepton.DeltaPhi(BJet))
self.out.fillBranch("MVAinput_WLbJ_dR", WLepton.DeltaR(BJet))
self.out.fillBranch("MVAinput_WLqJ_dPhi",
WLepton.DeltaPhi(QJet))
self.out.fillBranch("MVAinput_WLqJ_dR", WLepton.DeltaR(QJet))
self.out.fillBranch("MVAinput_ZL1bJ_dPhi",
Z1Lepton.DeltaPhi(BJet))
self.out.fillBranch("MVAinput_ZL1bJ_dR", Z1Lepton.DeltaR(BJet))
self.out.fillBranch("MVAinput_ZL1qJ_dPhi",
Z1Lepton.DeltaPhi(QJet))
self.out.fillBranch("MVAinput_ZL1qJ_dR", Z1Lepton.DeltaR(QJet))
self.out.fillBranch("MVAinput_ZL2bJ_dPhi",
Z2Lepton.DeltaPhi(BJet))
self.out.fillBranch("MVAinput_ZL2bJ_dR", Z2Lepton.DeltaR(BJet))
self.out.fillBranch("MVAinput_ZL2qJ_dPhi",
Z2Lepton.DeltaPhi(QJet))
self.out.fillBranch("MVAinput_ZL2qJ_dR", Z2Lepton.DeltaR(QJet))
# Top varlables not handled at here.
# if ( event._tree.b_out_KinTop_status == 1 ): # Check 2 top are reconstructed
# self.out.fillBranch("MVAinput_SMTop_mass", SMTop[3])
# self.out.fillBranch("MVAinput_FCNCTop_mass", FCNCTop[3])
# self.out.fillBranch("MVAinput_TopTop_dEta", abs(SMTop[1] - FCNCTop[1]))
# self.out.fillBranch("MVAinput_TopTop_dPhi", abs(SMTop[2] - FCNCTop[2]))
# self.out.fillBranch("MVAinput_Status", 2) # Status flag 2 : TTCR
# else:
# self.out.fillBranch("MVAinput_SMTop_mass", 0)
# self.out.fillBranch("MVAinput_FCNCTop_mass", 0)
# self.out.fillBranch("MVAinput_TopTop_dEta", 0)
# self.out.fillBranch("MVAinput_TopTop_dPhi", 0)
# self.out.fillBranch("MVAinput_Status", 3) # Status flag 3 : TTCR but 2 top are not reconstructed
return True
# check there no b-jets among not-tau jets
main_tau = taus_main[0]
mtau = main_tau[1]
main_tau_tlor = TLorentzVector(mtau.X(), mtau.Y(), mtau.Z(), mtau.T())
n_bjets = 0
for i in xrange(ev.jet_p4.size()):
pfid = ev.jet_PFID[i]
p4 = ev.jet_initial_p4[i]
if pfid < 1 or abs(p4.eta()) > 2.5: continue # Loose PFID and eta
if ev.jet_matching_lep[i]: continue
tj_p4 = TLorentzVector(p4.X(), p4.Y(), p4.Z(), p4.T())
# if matches to tau
if tj_p4.DeltaR(main_tau_tlor) < 0.4: continue
# else count the b-tagged jets
jet_b_discr = ev.jet_b_discr[i]
if jet_b_discr > 0.8484: # medium b WP
n_bjets += 1
if n_bjets > 0: continue
# save stuff
n_tau_cands.Fill(len(taus_main))
tau_pt.Fill(mtau.pt())
# if the main tau has valid SV
#
if main_tau[3] < 0: continue
def analyze(self, event):
iSkim = 0
eventWeightLumi, lheWeight, stitchWeight, puWeight, qcdnloWeight, qcdnnloWeight, ewknloWeight, topWeight = 1., 1., 1., 1., 1., 1., 1., 1.
triggerWeight, leptonWeight = 1., 1.
MinMuonIso, MaxMuonIso, MinMuonMetDPhi, MaxMuonMetDPhi, MinMuonJetDR = -1., -1., -1., -1., -1.
mZ, mW, mT, ptZ, ptW = -1., -1., -1., -1., -1.
dEtaLL, dPhiLL, dRLL = -1., -1., -1.
mJJ, ptJJ, dEtaJJ, dPhiJJ, dRJJ = -1., -1., -1., -1., -1.
mLLJJ, mNJ = -1., -1.
mHadW, mLepTop1, mLepTop2, mHadTop1, mHadTop2 = -1., -1., -1., -1., -1.
isSingleMuIsoTrigger, isSingleMuTrigger, isDoubleMuonTrigger, isSingleEleIsoTrigger, isSingleEleTrigger = False, False, False, False, False
for t in self.SingleMuIsoTriggers:
if hasattr(event, t) and getattr(event, t):
isSingleMuIsoTrigger = True
for t in self.SingleMuTriggers:
if hasattr(event, t) and getattr(event, t):
isSingleMuTrigger = True
for t in self.DoubleMuonTriggers:
if hasattr(event, t) and getattr(event, t):
isDoubleMuonTrigger = True
for t in self.SingleEleIsoTriggers:
if hasattr(event, t) and getattr(event, t):
isSingleEleIsoTrigger = True
for t in self.SingleEleTriggers:
if hasattr(event, t) and getattr(event, t):
isSingleEleTrigger = True
lheWeight = 1.
if self.isMC:
# Event weight
if not self.isLO and hasattr(event, "LHEWeight_originalXWGTUP"):
lheWeight = event.LHEWeight_originalXWGTUP
GenVpt = self.VptCorr.getGenVpt(
event) if not self.VptCorr is None else 0.
# MC stitching weight
# W+jets inclusive and exclusive
if 'WJetsToLNu_TuneCUETP8M1_13TeV-amcatnloFXFX-pythia8' in self.fileName and 'Summer16' in self.fileName:
if event.LHE_Vpt > 100.: stitchWeight = 0.
# Z+jets and Z+gamma
if self.fileName.startswith(
'ZGTo2LG_TuneCUETP8M1') or self.fileName.startswith(
'ZGToLLG_01J_5f_TuneCP5') or self.fileName.startswith(
'DYJetsToLL_M-50_Tune'):
nGenPhotons = 0
photonPtTh = 15. if self.fileName.startswith(
'ZGTo2LG_TuneCUETP8M1') or self.fileName.startswith(
'DYJetsToLL_M-50_TuneCUETP8M1') else 20.
for i in range(event.nGenPart):
if GenPart_pdgId[i] == 22 and TMath.Odd(
GenPart_statusFlags[i]
) and GenPart_pt > photonPtTh:
nGenPhotons += 1
if self.fileName.startswith('ZG') and nGenPhotons <= 0:
stitchWeight = 0.
if self.fileName.startswith(
'DYJetsToLL_M-50') and nGenPhotons >= 1:
stitchWeight = 0.
# PU weight
puWeight = self.puTool.getWeight(event.Pileup_nTrueInt)
# Higher order correction weights
if not self.VptCorr is None:
if not 'amcatnlo' in self.fileName:
qcdnloWeight = self.VptCorr.getWeightQCDNLO(GenVpt)
qcdnnloWeight = self.VptCorr.getWeightQCDNNLO(GenVpt)
ewknloWeight = self.VptCorr.getWeightEWKNLO(GenVpt)
if 'TTTo' in self.fileName:
Top1_pt, Top2_pt = getTTPt(event)
topWeight = getTTptWeight(Top1_pt, Top2_pt)
self.hists["Events"].Fill(0, lheWeight)
# electrons = Collection(event, "Electron")
# muons = Collection(event, "Muon")
# jets = Collection(event, "Jet")
# eventSum = ROOT.TLorentzVector()
# #select events with at least 2 muons
# if len(muons) >=2 :
# for lep in muons : #loop on muons
# eventSum += lep.p4()
# for lep in electrons : #loop on electrons
# eventSum += lep.p4()
# for j in jets : #loop on jets
# eventSum += j.p4()
# Clean collections
# Electrons
cleanElectron = []
for i in range(event.nElectron):
if event.Electron_pt[i] > 10. and event.Electron_cutBased[i] >= 2:
p4 = TLorentzVector()
p4.SetPtEtaPhiM(event.Electron_pt[i], event.Electron_eta[i],
event.Electron_phi[i], event.Electron_mass[i])
cleanElectron.append(p4)
# Muons
cleanMuon = []
for i in range(event.nMuon):
if event.Muon_pt[i] > 10. and event.Muon_mediumId[
i] and event.Muon_pfRelIso03_all[i] < 0.15:
p4 = TLorentzVector()
p4.SetPtEtaPhiM(event.Muon_pt[i], event.Muon_eta[i],
event.Muon_phi[i], event.Muon_mass[i])
cleanMuon.append(p4)
# Jets and Event variables
cleanJet, cleanBJet, cleanNonBJet = [], [], []
HT30, Nj20, Nj30, Nj40, nBJet = 0., 0, 0, 0, 0
CSVs = []
twoJets, allJets = TLorentzVector(), TLorentzVector()
for i in range(event.nJet):
if event.Jet_jetId[i] >= 6 and abs(event.Jet_eta[i]) < 2.5:
p4 = TLorentzVector()
p4.SetPtEtaPhiM(event.Jet_pt[i], event.Jet_eta[i],
event.Jet_phi[i], event.Jet_mass[i])
# remove overlaps with electrons and muons
cleanFromLeptons = True
for e in range(len(cleanElectron)):
if cleanElectron[e].DeltaR(p4) < 0.4:
cleanFromLeptons = False
for m in range(len(cleanMuon)):
if cleanMuon[m].DeltaR(p4) < 0.4: cleanFromLeptons = False
# fill variables
if cleanFromLeptons:
if event.Jet_pt[i] > 20.:
Nj20 += 1
if event.Jet_pt[i] > 30.:
HT30 += event.Jet_pt[i]
Nj30 += 1
cleanJet.append(p4)
if event.Jet_btagDeepB[i] >= self.btagMedium:
cleanBJet.append(p4)
else:
cleanNonBJet.append(p4)
CSVs.append([i, event.Jet_btagDeepB[i]])
if len(cleanJet) < 2: twoJets += p4
allJets += p4
if event.Jet_pt[i] > 40.:
Nj40 += 1
# b-tag ranking
nBJet = len(cleanBJet)
CSV1, CSV2, CSV3, CSV4, iCSV1, iCSV2, iCSV3, iCSV4 = 0., 0., 0., 0., -1, -1, -1, -1
CSVs.sort(key=lambda x: x[1], reverse=True)
if len(CSVs) > 0: iCSV1, CSV1 = CSVs[0][0], CSVs[0][1]
if len(CSVs) > 1: iCSV2, CSV2 = CSVs[1][0], CSVs[1][1]
if len(CSVs) > 2: iCSV3, CSV3 = CSVs[2][0], CSVs[2][1]
if len(CSVs) > 3: iCSV4, CSV4 = CSVs[3][0], CSVs[3][1]
if len(cleanJet) >= 2:
mJJ = (cleanJet[0] + cleanJet[1]).M()
ptJJ = (cleanJet[0] + cleanJet[1]).Pt()
dEtaJJ = abs(cleanJet[0].Eta() - cleanJet[1].Eta())
dPhiJJ = abs(cleanJet[0].DeltaPhi(cleanJet[1]))
dRJJ = cleanJet[0].DeltaR(cleanJet[1])
mNJ = allJets.M()
Lepton1, Lepton2, Lepton3, Neutrino, MET, LLJJ, Vis = TLorentzVector(
), TLorentzVector(), TLorentzVector(), TLorentzVector(
), TLorentzVector(), TLorentzVector(), TLorentzVector()
MET.SetPtEtaPhiM(event.MET_pt, 0., event.MET_phi, 0.)
# Categorization:
# iSkim = 1: 2 muons (OS or SS)
# iSkim = 2: 1 muon and 1 electron (no OS requirement)
# iSkim = 3: 3 muons (assumed that they are not 3 same-sign)
# iSkim = 4: 2 muons (OS) and 1 electron
# iSkim = 5: 1 muons, 3 jets, >= 1 btag
# iSkim = 6: 2 electrons
# case 3a: 3 lepton CR (3mu)
if iSkim == 0 and event.nMuon >= 3:
if (isSingleMuIsoTrigger or isSingleMuTrigger) and event.Muon_pt[
0] > 27. and event.Muon_pt[1] > 15. and event.Muon_pt[
2] > 15. and event.Muon_mediumId[
0] and event.Muon_mediumId[
1] and event.Muon_mediumId[2]:
Lepton1.SetPtEtaPhiM(event.Muon_pt[0], event.Muon_eta[0],
event.Muon_phi[0], event.Muon_mass[0])
Lepton2.SetPtEtaPhiM(event.Muon_pt[1], event.Muon_eta[1],
event.Muon_phi[1], event.Muon_mass[1])
Lepton3.SetPtEtaPhiM(event.Muon_pt[2], event.Muon_eta[2],
event.Muon_phi[2], event.Muon_mass[2])
if event.Muon_charge[0] * event.Muon_charge[1] < 0:
mll = (Lepton1 + Lepton2).M()
ptll = (Lepton1 + Lepton2).Pt()
detall = abs(Lepton1.Eta() - Lepton2.Eta())
dphill = abs(Lepton1.DeltaPhi(Lepton2))
drll = Lepton1.DeltaR(Lepton2)
else:
mll = (Lepton1 + Lepton3).M()
ptll = (Lepton1 + Lepton3).Pt()
detall = abs(Lepton1.Eta() - Lepton3.Eta())
dphill = abs(Lepton1.DeltaPhi(Lepton3))
drll = Lepton1.DeltaR(Lepton3)
if mll > 15.:
iSkim = 3
# Variables
mZ, ptZ = mll, ptll
dEtaLL, dPhiLL, dRLL = detall, dphill, drll
MinMuonIso = min(
min(event.Muon_pfRelIso03_all[0],
event.Muon_pfRelIso03_all[1]),
event.Muon_pfRelIso03_all[2])
MaxMuonIso = max(
max(event.Muon_pfRelIso03_all[0],
event.Muon_pfRelIso03_all[1]),
event.Muon_pfRelIso03_all[2])
MinMuonMetDPhi = min(
min(abs(Lepton1.DeltaPhi(MET)),
abs(Lepton2.DeltaPhi(MET))),
abs(Lepton3.DeltaPhi(MET)))
MaxMuonMetDPhi = max(
max(abs(Lepton1.DeltaPhi(MET)),
abs(Lepton2.DeltaPhi(MET))),
abs(Lepton3.DeltaPhi(MET)))
MinMuonJetDR = min(
min(getMinMuonJetDR(cleanJet, Lepton1),
getMinMuonJetDR(cleanJet, Lepton2)),
getMinMuonJetDR(cleanJet, Lepton3))
LLJJ = twoJets + Lepton1 + Lepton2
Vis = allJets + Lepton1 + Lepton2 + Lepton3
# Weights
if self.isMC:
triggerWeight = self.muSFs.getTriggerSF(
event.Muon_pt[0], event.Muon_eta[0])
IdSF1 = self.muSFs.getIdSF(event.Muon_pt[0],
event.Muon_eta[0], 2)
IsoSF1 = self.muSFs.getIsoSF(event.Muon_pt[0],
event.Muon_eta[0])
IdSF2 = self.muSFs.getIdSF(event.Muon_pt[1],
event.Muon_eta[1], 2)
IsoSF2 = self.muSFs.getIsoSF(event.Muon_pt[1],
event.Muon_eta[1])
IdSF3 = self.muSFs.getIdSF(event.Muon_pt[2],
event.Muon_eta[2], 2)
IsoSF3 = self.muSFs.getIsoSF(event.Muon_pt[2],
event.Muon_eta[2])
leptonWeight = IdSF1 * IsoSF1 * IdSF2 * IsoSF2 * IdSF3 * IsoSF3
# case 3b: 3 lepton CR (2mu 1e)
if iSkim == 0 and event.nMuon >= 2 and event.nElectron >= 1:
if (isSingleMuIsoTrigger or isSingleMuTrigger) and event.Muon_pt[
0] > 27. and event.Muon_pt[1] > 15. and event.Electron_pt[
0] > 15. and event.Muon_mediumId[
0] and event.Muon_mediumId[
1] and event.Electron_cutBased[
0] >= 2 and event.Muon_charge[
0] * event.Muon_charge[1] < 0:
Lepton1.SetPtEtaPhiM(event.Muon_pt[0], event.Muon_eta[0],
event.Muon_phi[0], event.Muon_mass[0])
Lepton2.SetPtEtaPhiM(event.Muon_pt[1], event.Muon_eta[1],
event.Muon_phi[1], event.Muon_mass[1])
Lepton3.SetPtEtaPhiM(event.Electron_pt[0],
event.Electron_eta[0],
event.Electron_phi[0],
event.Electron_mass[0])
mll = (Lepton1 + Lepton2).M()
ptll = (Lepton1 + Lepton2).Pt()
if mll > 15.:
iSkim = 4
# Variables
mZ, ptZ = mll, ptll
dEtaLL = abs(Lepton1.Eta() - Lepton2.Eta())
dPhiLL = abs(Lepton1.DeltaPhi(Lepton2))
dRLL = Lepton1.DeltaR(Lepton2)
MinMuonIso = min(event.Muon_pfRelIso03_all[0],
event.Muon_pfRelIso03_all[1])
MaxMuonIso = max(event.Muon_pfRelIso03_all[0],
event.Muon_pfRelIso03_all[1])
MinMuonMetDPhi = min(
min(abs(Lepton1.DeltaPhi(MET)),
abs(Lepton2.DeltaPhi(MET))),
abs(Lepton3.DeltaPhi(MET)))
MaxMuonMetDPhi = max(
max(abs(Lepton1.DeltaPhi(MET)),
abs(Lepton2.DeltaPhi(MET))),
abs(Lepton3.DeltaPhi(MET)))
MinMuonJetDR = min(getMinMuonJetDR(cleanJet, Lepton1),
getMinMuonJetDR(cleanJet, Lepton2))
LLJJ = twoJets + Lepton1 + Lepton2
Vis = allJets + Lepton1 + Lepton2 + Lepton3
# Weights
if self.isMC:
triggerWeight = self.muSFs.getTriggerSF(
event.Muon_pt[0], event.Muon_eta[0])
IdSF1 = self.muSFs.getIdSF(event.Muon_pt[0],
event.Muon_eta[0], 2)
IsoSF1 = self.muSFs.getIsoSF(event.Muon_pt[0],
event.Muon_eta[0])
IdSF2 = self.muSFs.getIdSF(event.Muon_pt[1],
event.Muon_eta[1], 2)
IsoSF2 = self.muSFs.getIsoSF(event.Muon_pt[1],
event.Muon_eta[1])
IdIsoSF3 = self.elSFs.getIdIsoSF(
event.Electron_pt[0], event.Electron_eta[0])
leptonWeight = IdSF1 * IsoSF1 * IdSF2 * IsoSF2 * IdIsoSF3
# case 1: Z->mumu CR (2 mu)
if iSkim == 0 and event.nMuon >= 2:
if (isSingleMuIsoTrigger or isSingleMuTrigger) and event.Muon_pt[
0] > 27. and event.Muon_pt[1] > 7. and event.Muon_mediumId[
0] and event.Muon_mediumId[1]:
Lepton1.SetPtEtaPhiM(event.Muon_pt[0], event.Muon_eta[0],
event.Muon_phi[0], event.Muon_mass[0])
Lepton2.SetPtEtaPhiM(event.Muon_pt[1], event.Muon_eta[1],
event.Muon_phi[1], event.Muon_mass[1])
mll = (Lepton1 + Lepton2).M()
ptll = (Lepton1 + Lepton2).Pt()
if mll > 15.:
iSkim = 1
# Variables
mZ, ptZ = mll, ptll
dEtaLL = abs(Lepton1.Eta() - Lepton2.Eta())
dPhiLL = abs(Lepton1.DeltaPhi(Lepton2))
dRLL = Lepton1.DeltaR(Lepton2)
MinMuonIso = min(event.Muon_pfRelIso03_all[0],
event.Muon_pfRelIso03_all[1])
MaxMuonIso = max(event.Muon_pfRelIso03_all[0],
event.Muon_pfRelIso03_all[1])
MinMuonMetDPhi = min(abs(Lepton1.DeltaPhi(MET)),
abs(Lepton2.DeltaPhi(MET)))
MaxMuonMetDPhi = max(abs(Lepton1.DeltaPhi(MET)),
abs(Lepton2.DeltaPhi(MET)))
MinMuonJetDR = min(getMinMuonJetDR(cleanJet, Lepton1),
getMinMuonJetDR(cleanJet, Lepton2))
LLJJ = twoJets + Lepton1 + Lepton2
Vis = allJets + Lepton1 + Lepton2
# Weights
if self.isMC:
triggerWeight = self.muSFs.getTriggerSF(
event.Muon_pt[0], event.Muon_eta[0])
IdSF1 = self.muSFs.getIdSF(event.Muon_pt[0],
event.Muon_eta[0], 2)
IdSF2 = self.muSFs.getIdSF(event.Muon_pt[1],
event.Muon_eta[1], 2)
IsoSF1 = self.muSFs.getIsoSF(event.Muon_pt[0],
event.Muon_eta[0])
IsoSF2 = self.muSFs.getIsoSF(event.Muon_pt[1],
event.Muon_eta[1])
leptonWeight = IdSF1 * IdSF2 * IsoSF1 * IsoSF2
# case 4: Z->ee CR (2 electrons)
if iSkim == 0 and event.nElectron >= 2:
if isSingleEleIsoTrigger and event.Electron_pt[
0] > 35. and event.Electron_pt[
1] > 10. and event.Electron_cutBased[
0] > 0 and event.Electron_cutBased[1] > 0:
Lepton1.SetPtEtaPhiM(event.Electron_pt[0],
event.Electron_eta[0],
event.Electron_phi[0],
event.Electron_mass[0])
Lepton2.SetPtEtaPhiM(event.Electron_pt[1],
event.Electron_eta[1],
event.Electron_phi[1],
event.Electron_mass[1])
mll = (Lepton1 + Lepton2).M()
ptll = (Lepton1 + Lepton2).Pt()
if mll > 15.:
iSkim = 6
# Variables
mZ, ptZ = mll, ptll
dEtaLL = abs(Lepton1.Eta() - Lepton2.Eta())
dPhiLL = abs(Lepton1.DeltaPhi(Lepton2))
dRLL = Lepton1.DeltaR(Lepton2)
MinMuonIso = event.Electron_pfRelIso03_all[0]
MaxMuonIso = event.Electron_pfRelIso03_all[0]
MinMuonMetDPhi = min(abs(Lepton1.DeltaPhi(MET)),
abs(Lepton2.DeltaPhi(MET)))
MaxMuonMetDPhi = max(abs(Lepton1.DeltaPhi(MET)),
abs(Lepton2.DeltaPhi(MET)))
MinMuonJetDR = min(getMinMuonJetDR(cleanJet, Lepton1),
getMinMuonJetDR(cleanJet, Lepton2))
LLJJ = twoJets + Lepton1 + Lepton2
Vis = allJets + Lepton1 + Lepton2
# Weights
if self.isMC:
triggerWeight = self.elSFs.getTriggerSF(
event.Electron_pt[0], event.Electron_eta[0])
leptonWeight = self.elSFs.getIdIsoSF(
event.Electron_pt[0],
event.Electron_eta[0]) * self.elSFs.getIdIsoSF(
event.Electron_pt[1], event.Electron_eta[1])
# case 2: ttbar and Z OF CR (1 muon and 1 electron)
if iSkim == 0 and event.nMuon >= 1 and event.nElectron >= 1:
if (isSingleMuIsoTrigger or isSingleMuTrigger
) and event.Muon_pt[0] > 27. and event.Electron_pt[
0] > 20. and event.Muon_mediumId[
0] and event.Electron_cutBased[0] >= 2:
Lepton1.SetPtEtaPhiM(event.Muon_pt[0], event.Muon_eta[0],
event.Muon_phi[0], event.Muon_mass[0])
Lepton2.SetPtEtaPhiM(event.Electron_pt[0],
event.Electron_eta[0],
event.Electron_phi[0],
event.Electron_mass[0])
mll = (Lepton1 + Lepton2).M()
ptll = (Lepton1 + Lepton2).Pt()
if mll > 15.:
iSkim = 2
# Variables
mZ, ptZ = mll, ptll
dEtaLL = abs(Lepton1.Eta() - Lepton2.Eta())
dPhiLL = abs(Lepton1.DeltaPhi(Lepton2))
dRLL = Lepton1.DeltaR(Lepton2)
MinMuonIso = event.Muon_pfRelIso03_all[0]
MaxMuonIso = event.Muon_pfRelIso03_all[0]
MinMuonMetDPhi = abs(Lepton1.DeltaPhi(MET))
MaxMuonMetDPhi = abs(Lepton1.DeltaPhi(MET))
MinMuonJetDR = min(getMinMuonJetDR(cleanJet, Lepton1),
getMinMuonJetDR(cleanJet, Lepton2))
LLJJ = twoJets + Lepton1 + Lepton2
Vis = allJets + Lepton1 + Lepton2
# Weights
if self.isMC:
triggerWeight = self.muSFs.getTriggerSF(
Lepton1.Pt(), Lepton1.Eta())
IdSF1 = self.muSFs.getIdSF(event.Muon_pt[0],
event.Muon_eta[0], 2)
IsoSF1 = self.muSFs.getIsoSF(event.Muon_pt[0],
event.Muon_eta[0])
IdIsoSF2 = self.elSFs.getIdIsoSF(
event.Electron_pt[0], event.Electron_eta[0])
leptonWeight = IdSF1 * IsoSF1 * IdIsoSF2
# case 4: ttbar CR (1 muon and >= 3 jets)
if iSkim == 0 and event.nMuon >= 1:
if (isSingleMuIsoTrigger or isSingleMuTrigger
) and event.Muon_pt[0] > 27. and event.Muon_mediumId[
0] and event.Muon_pfRelIso03_all[0] < 0.15:
Lepton1.SetPtEtaPhiM(event.Muon_pt[0], event.Muon_eta[0],
event.Muon_phi[0], event.Muon_mass[0])
pzN = recoverNeutrinoPz(Lepton1, MET)
Neutrino.SetPxPyPzE(MET.Px(), MET.Py(), pzN, MET.Pt())
mW = (Lepton1 + Neutrino).M()
ptW = (Lepton1 + Neutrino).Pt()
mT = math.sqrt(2. * Lepton1.Pt() * MET.Pt() *
(1. - math.cos(Lepton1.DeltaPhi(MET))))
if Nj30 >= 3: # and nBJet >= 1:
iSkim = 5
# Variables
MinMuonIso = event.Muon_pfRelIso03_all[0]
MaxMuonIso = event.Muon_pfRelIso03_all[0]
MinMuonMetDPhi = abs(Lepton1.DeltaPhi(MET))
MaxMuonMetDPhi = abs(Lepton1.DeltaPhi(MET))
MinMuonJetDR = getMinMuonJetDR(cleanJet, Lepton1)
LLJJ = twoJets + Lepton1
Vis = allJets + Lepton1
# W and Top reconstruction
if len(cleanBJet) >= 2:
mLepTop1 = (Lepton1 + Neutrino + cleanBJet[0]).M()
mLepTop2 = (Lepton1 + Neutrino + cleanBJet[1]).M()
elif len(cleanBJet) >= 1:
mLepTop1 = (Lepton1 + Neutrino + cleanBJet[0]).M()
mHadTop2 = mHadTop1
if len(cleanNonBJet) >= 2:
mHadW = (cleanNonBJet[0] + cleanNonBJet[1]).M()
if len(cleanBJet) >= 2:
mHadTop1 = (cleanNonBJet[0] + cleanNonBJet[1] +
cleanBJet[0]).M()
mHadTop2 = (cleanNonBJet[0] + cleanNonBJet[1] +
cleanBJet[1]).M()
elif len(cleanBJet) >= 1:
mHadTop1 = (cleanNonBJet[0] + cleanNonBJet[1] +
cleanBJet[0]).M()
mHadTop2 = mHadTop1
# Weights
if self.isMC:
triggerWeight = self.muSFs.getTriggerSF(
Lepton1.Pt(), Lepton1.Eta())
IdSF1 = self.muSFs.getIdSF(event.Muon_pt[0],
event.Muon_eta[0], 2)
IsoSF1 = self.muSFs.getIsoSF(event.Muon_pt[0],
event.Muon_eta[0])
leptonWeight = IdSF1 * IsoSF1
passedMETFilters = True
filters = [
"Flag_goodVertices", "Flag_globalSuperTightHalo2016Filter",
"Flag_BadPFMuonFilter", "Flag_EcalDeadCellTriggerPrimitiveFilter",
"Flag_HBHENoiseFilter", "Flag_HBHENoiseIsoFilter",
"Flag_ecalBadCalibFilter", "Flag_ecalBadCalibFilterV2"
]
if not self.isMC: filters += ["Flag_eeBadScFilter"]
for f in filters:
if hasattr(event, f) and getattr(event, f) == False:
passedMETFilters = False
# try:
## if event.Flag_goodVertices: print "Flag_goodVertices"
## if event.Flag_globalSuperTightHalo2016Filter: print "Flag_globalSuperTightHalo2016Filter"
## if event.Flag_BadPFMuonFilter: print "Flag_BadPFMuonFilter"
## if event.Flag_EcalDeadCellTriggerPrimitiveFilter: print "Flag_EcalDeadCellTriggerPrimitiveFilter"
## if event.Flag_HBHENoiseFilter: print "Flag_HBHENoiseFilter"
## if event.Flag_HBHENoiseIsoFilter: print "Flag_HBHENoiseIsoFilter"
### if (self.isMC or event.Flag_eeBadScFilter): print "Flag_eeBadScFilter"
## if event.Flag_ecalBadCalibFilter: print "Flag_ecalBadCalibFilterV2"
# if event.Flag_goodVertices and event.Flag_globalSuperTightHalo2016Filter and event.Flag_BadPFMuonFilter and event.Flag_EcalDeadCellTriggerPrimitiveFilter and event.Flag_HBHENoiseFilter and event.Flag_HBHENoiseIsoFilter: # and event.Flag_ecalBadCalibFilter: #and (self.isMC or event.Flag_eeBadScFilter): FIXME
# passedMETFilters = True
## if not self.isMC:
## if not event.Flag_eeBadScFilter:
## passedMETFilters = False
# except:
# passedMETFilters = False
if iSkim == 0: return False
if self.isMC:
eventWeightLumi = self.lumiWeight * lheWeight * puWeight * topWeight * qcdnloWeight * qcdnnloWeight * ewknloWeight * triggerWeight * leptonWeight
self.out.fillBranch("iSkim", iSkim)
self.out.fillBranch("isMC", self.isMC)
self.out.fillBranch("isSingleMuIsoTrigger", isSingleMuIsoTrigger)
self.out.fillBranch("isSingleMuTrigger", isSingleMuTrigger)
self.out.fillBranch("isDoubleMuonTrigger", isDoubleMuonTrigger)
self.out.fillBranch("isSingleEleIsoTrigger", isSingleEleIsoTrigger)
self.out.fillBranch("isSingleEleTrigger", isSingleEleTrigger)
self.out.fillBranch("passedMETFilters", passedMETFilters)
self.out.fillBranch("nCleanElectron", len(cleanElectron))
self.out.fillBranch("nCleanMuon", len(cleanMuon))
self.out.fillBranch("nCleanJet", len(cleanJet))
self.out.fillBranch("Z_mass", mZ)
self.out.fillBranch("Z_pt", ptZ)
self.out.fillBranch("W_mass", mW)
self.out.fillBranch("W_tmass", mT)
self.out.fillBranch("W_pt", ptW)
self.out.fillBranch("ll_dEta", dEtaLL)
self.out.fillBranch("ll_dPhi", dPhiLL)
self.out.fillBranch("ll_dR", dRLL)
self.out.fillBranch("Wqq_mass", mHadW)
self.out.fillBranch("Tlvb1_mass", mLepTop1)
self.out.fillBranch("Tlvb2_mass", mLepTop2)
self.out.fillBranch("Tqqb1_mass", mHadTop1)
self.out.fillBranch("Tqqb2_mass", mHadTop2)
self.out.fillBranch("jj_mass", mJJ)
self.out.fillBranch("jj_pt", ptJJ)
self.out.fillBranch("jj_dEta", dEtaJJ)
self.out.fillBranch("jj_dPhi", dPhiJJ)
self.out.fillBranch("jj_dR", dRJJ)
self.out.fillBranch("nj_mass", mNJ)
self.out.fillBranch("vis_mass", Vis.M())
self.out.fillBranch("lljj_mass", LLJJ.M())
self.out.fillBranch("minMuonIso", MinMuonIso)
self.out.fillBranch("maxMuonIso", MaxMuonIso)
self.out.fillBranch("minMuonMetDPhi", MinMuonMetDPhi)
self.out.fillBranch("maxMuonMetDPhi", MaxMuonMetDPhi)
self.out.fillBranch("minMuonJetDR", MinMuonJetDR)
self.out.fillBranch("HT30", HT30)
self.out.fillBranch("nj20", Nj20)
self.out.fillBranch("nj30", Nj30)
self.out.fillBranch("nj40", Nj40)
self.out.fillBranch("nBJet", nBJet)
self.out.fillBranch("CSV1", CSV1)
self.out.fillBranch("CSV2", CSV2)
self.out.fillBranch("CSV3", CSV3)
self.out.fillBranch("CSV4", CSV4)
self.out.fillBranch("iCSV1", iCSV1)
self.out.fillBranch("iCSV2", iCSV2)
self.out.fillBranch("iCSV3", iCSV3)
self.out.fillBranch("iCSV4", iCSV4)
self.out.fillBranch("lumiWeight", self.lumiWeight)
self.out.fillBranch("lheWeight", lheWeight)
self.out.fillBranch("stitchWeight", stitchWeight)
self.out.fillBranch("puWeight", puWeight)
self.out.fillBranch("topWeight", topWeight)
self.out.fillBranch("qcdnloWeight", qcdnloWeight)
self.out.fillBranch("qcdnnloWeight", qcdnnloWeight)
self.out.fillBranch("ewknloWeight", ewknloWeight)
self.out.fillBranch("triggerWeight", triggerWeight)
self.out.fillBranch("leptonWeight", leptonWeight)
self.out.fillBranch("eventWeightLumi", eventWeightLumi)
return True
q2 *= 1e+3
# Objects definition cuts
G = 1.0
if isMuon:
G *= Heaviside(2.5-abs(l1.Eta()))
G *= Heaviside(2.5-abs(l2.Eta()))
G *= Heaviside(l1.Pt()-7.0e+3)
G *= Heaviside(l2.Pt()-7.0e+3)
else:
G *= Heaviside(2.47-abs(l1.Eta()))
G *= Heaviside(2.47-abs(l2.Eta()))
G *= Heaviside(l1.Pt()-7.0e+3)
G *= Heaviside(l2.Pt()-7.0e+3)
if q1.DeltaR(q2) > 1.0:
G *= Heaviside(4.5-abs(q1.Eta()))
G *= Heaviside(4.5-abs(q2.Eta()))
G *= Heaviside(q1.Pt()-30.0e+3)
G *= Heaviside(q2.Pt()-30.0e+3)
else:
G *= Heaviside( (q1+q2).Pt()-200.0e+3 )
G *= Heaviside( 2.0-abs((q1+q2).Eta()) )
# Event selection
Es = 1.0
if isMuon:
Es *= Heaviside(99e+3-(l1+l2).M())
Es *= Heaviside((l1+l2).M()-83e+3)
else:
def hist(sample, color, output, expected_Nevets):
chain = TChain("events")
#files = glob("/afs/cern.ch/work/a/axiong/public/FCCsoft/heppy/FCChhAnalyses/Zprime_jj/out_0_500/*.root")
homedirectory = "/afs/cern.ch/work/a/axiong/public/FCCsoft/heppy/FCChhAnalyses/"
# ...Zprime_jj... depends on the location of TreeProducer.py used, subject to change
rootfile = "/heppy.FCChhAnalyses.Zprime_jj.TreeProducer.TreeProducer_1/tree.root"
# Add all files to TChain
for i in range(5):
filename = homedirectory + sample + str(i) + rootfile
file = TFile(filename)
chain.AddFile(filename)
print("root file from chunk" + str(i) + " is added")
# declare histograms
h1d_mjj = TH1F('jj_mass', '', 130, 0, 2000)
h1d_pt1 = TH1F('jj_pt1', '', 130, 0, 1500)
h1d_pt2 = TH1F('jj_pt2', '', 130, 0, 1000)
h1d_eta1 = TH1F('jj_eta1', '', 25, -5.0, 5.0)
h1d_eta2 = TH1F('jj_eta2', '', 25, -5.0, 5.0)
h1d_chi = TH1F('jj_chi', '', 25, 0, 18)
h1d_delR = TH1F('jj_delR', '', 25, -1, 6)
h1d_ht = TH1F("ht", '', 100, 0, 3000)
h1d_deleta = TH1F('deleta', '', 20, -4, 4)
#mychain = chain.Get( 'events' )
entries = chain.GetEntries()
# Event loop
for jentry in xrange(entries):
ientry = chain.LoadTree(jentry)
if ientry < 0:
break
nb = chain.GetEntry(jentry)
if nb <= 0:
continue
# feed data of two leading jets into TLorentzVector
jet1 = TLorentzVector()
jet1.SetPtEtaPhiE(chain.jet1_pt, chain.jet1_eta, chain.jet1_phi,
chain.jet1_e)
jet2 = TLorentzVector()
jet2.SetPtEtaPhiE(chain.jet2_pt, chain.jet2_eta, chain.jet2_phi,
chain.jet2_e)
jet12 = jet1 + jet2
# Fill the histograms
h1d_mjj.Fill(jet12.M())
h1d_pt1.Fill(chain.jet1_pt)
h1d_pt2.Fill(chain.jet2_pt)
h1d_eta1.Fill(chain.jet1_eta)
h1d_eta2.Fill(chain.jet2_eta)
dr = jet1.DeltaR(jet2)
h1d_delR.Fill(dr)
h1d_chi.Fill(np.exp(2 *
(np.absolute(chain.jet1_eta - chain.jet2_eta))))
h1d_deleta.Fill(chain.jet1_eta - chain.jet2_eta)
h1d_ht.Fill(chain.Ht)
hist = [
h1d_mjj, h1d_chi, h1d_delR, h1d_pt1, h1d_pt2, h1d_eta1, h1d_eta2,
h1d_deleta, h1d_ht
]
title = [
"dijet mass distribution", "angular variable distribution",
"angular seperation", "Lead pt distribution",
"Sublead pt distribution", "Rapitity distribution",
"Rapitity distribution 2", "rapidity difference", "Jet Pt sum"
]
x_title = [
"mjj (GeV)", "chi", 'del_R', "pt(GeV)", "pt(GeV)", "eta", "eta",
"eta1-eta2", "Ht (GeV)"
]
color = [color]
Line_color = color * 9
f = TFile(output, "recreate")
for i in range(9):
hist[i].SetTitle(title[i])
hist[i].GetXaxis().SetTitle(x_title[i])
hist[i].GetYaxis().SetTitle('# of events')
scale = expected_Nevets / hist[i].Integral()
hist[i].SetLineColor(Line_color[i])
hist[i].Scale(scale)
hist[i].Write()
print "finished processing the sample"
print ""
taup_has_pionn = len(g_taup_pionn) != 0
taum_has_pionn = len(g_taum_pionn) != 0
# tau pions
for genpi in g_taum_pions:
min_ind = None
min_deltaR = 9999
matched_x = False
for i in range(0, len(
rec_pions)): # check if particles correspond to one another based on delta r, charge, and delta pt
recpi = rec_pions[i]
gen_lv = TLorentzVector()
gen_lv.SetPtEtaPhiM(genpi.pt(), genpi.eta(), genpi.phi(), 0.139)
rec_lv = TLorentzVector()
rec_lv.SetPtEtaPhiM(recpi.pt(), recpi.eta(), recpi.phi(), 0.139)
deltaR = gen_lv.DeltaR(rec_lv)
deltaPT = (rec_lv.Pt() - gen_lv.Pt()) / gen_lv.Pt()
if recpi.pdgId() == genpi.pdgId() and abs(deltaR) < 0.1 and abs(deltaPT) < 0.3 and deltaR < min_deltaR and abs(genpi.eta()) < 2.5 and not recpi in matched_pionm:
min_ind = i
matched_x = True
min_deltaR = deltaR
if matched_x:
matched_pionm.append(rec_pions[min_ind])
if taum_has_pionn:
for genph in g_taum_photons:
min_ind = None
min_deltaR = 9999
matched_x = False
