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