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