def select(self):
self.clear_particles()
# require TTree to be loaded
if not self.ch:
print 'ElectronSelector. Warning! No input TTree'
return
# Loop over taus and select candidates
for i in range(0, self.ch.el_n):
et = self.ch.el_cl_E[i] / cosh(self.ch.el_tracketa[i])
eta = self.ch.el_tracketa[i]
phi = self.ch.el_trackphi[i]
p = ParticleBase(
_index=i,
_pt=et,
_eta=eta,
_phi=phi,
_m=0.,
)
if p.Pt() < self.min_pt: continue
if abs(p.Eta()) > self.max_eta: continue
#crack region
for region in self.excluded_eta_regions:
cleta = self.ch.el_cl_eta[i]
if abs(cleta) >= region[0] and abs(cleta) <= region[1]:
continue
#authors
if self.allowed_authors:
if not self.allowed_authors.count(self.ch.el_author[i]):
continue
# Isolation
if self.ch.el_nucone40[i] > self.max_nucone40: continue
if self.ch.el_ptcone40[i] / p.Pt() > self.max_ptcone40rel: continue
if self.ch.el_Etcone20[i] / p.Pt() > self.max_etcone20rel: continue
#cleaning
if self.req_cleaning:
if (self.ch.el_OQ[i] & 1446) != 0: continue
# isEM ID
if self.req_medium_old:
if (self.ch.el_isEM[i] & egammaPID.ElectronMedium) != 0:
continue
if self.req_tight_old:
if (self.ch.el_isEM[i] & egammaPID.ElectronTight) != 0:
continue
if self.req_medium:
if (self.ch.el_medium[i] != 1): continue
if self.req_tight:
if (self.ch.el_tight[i] != 1): continue
# isEM ID PP
if self.recalculate_isEMplusplus:
patch = ElectronIDpatch(
self.ch.el_cl_E[i], self.ch.el_etas2[i],
self.ch.el_Ethad[i], self.ch.el_Ethad1[i],
self.ch.el_reta[i], self.ch.el_weta2[i], self.ch.el_f1[i],
self.ch.el_f3[i], self.ch.el_wstot[i],
self.ch.el_emaxs1[i], self.ch.el_Emax2[i],
self.ch.el_deltaeta1[i], self.ch.el_deltaeta2[i],
self.ch.el_trackqoverp[i], self.ch.el_trackd0_physics[i],
self.ch.el_TRTHighTOutliersRatio[i],
self.ch.el_nTRTHits[i], self.ch.el_nTRTOutliers[i],
self.ch.el_nSiHits[i], self.ch.el_nSCTOutliers[i],
self.ch.el_nPixelOutliers[i], self.ch.el_nPixHits[i],
self.ch.el_nBLHits[i], self.ch.el_nBLayerOutliers[i],
self.ch.el_expectHitInBLayer[i], self.ch.el_isEM[i])
self.el_loosePP_decision, self.el_mediumPP_decision, self.el_tightPP_decision = patch.evaluate(
)
#if self.el_loosePP_decision != self.ch.el_loosePP[i] or self.el_mediumPP_decision != self.ch.el_mediumPP[i] or self.el_tightPP_decision != self.ch.el_tightPP[i]:
#print "isEMpp: ", self.el_loosePP_decision, self.el_mediumPP_decision, self.el_tightPP_decision, "vs", self.ch.el_loosePP[i], self.ch.el_mediumPP[i], self.ch.el_tightPP[i]
else:
self.el_loosePP_decision = self.ch.el_loosePP[i]
self.el_mediumPP_decision = self.ch.el_mediumPP[i]
self.el_tightPP_decision = self.ch.el_tightPP[i]
if self.req_loosePP:
if (self.el_loosePP_decision != 1): continue
if self.req_mediumPP:
if (self.el_mediumPP_decision != 1): continue
if self.req_tightPP:
if (self.el_tightPP_decision != 1): continue
#print 'passed el sel'
self.add_particle(p)
#end of loop
self.sort_particles()
return self.get_particles()
def select(self):
self.clear_particles()
# require TTree to be loaded
if not self.ch:
print 'TauSelector. Warning! No input TTree'
return
# construct loose muons
loose_muons = []
if self.veto_loose_muon:
for imu in range( 0,self.ch.mu_staco_n):
if not self.ch.mu_staco_loose[imu]: continue
loose_muons.append( ParticleBase( _index = imu,
_pt = self.ch.mu_staco_pt[imu],
_eta = self.ch.mu_staco_eta[imu],
_phi = self.ch.mu_staco_phi[imu],
_m = self.ch.mu_staco_m[imu]
) )
# Loop over taus and select candidates
for i in range(0,self.ch.tau_n):
p = ParticleBase( _index = i,
_pt = self.ch.tau_pt[i],
_eta = self.ch.tau_eta[i],
_phi = self.ch.tau_phi[i],
_m = self.ch.tau_m[i] )
if p.Pt() < self.min_pt : continue
if abs(p.Eta()) > self.max_eta: continue
if self.allowed_authors and not self.ch.tau_author[i] in self.allowed_authors: continue
if self.allowed_tracks and not self.ch.tau_numTrack[i] in self.allowed_tracks: continue
if self.nonzero_tracks and not self.ch.tau_numTrack[i] > 0 : continue
if self.req_unit_charge and not abs( self.ch_tau_charge[i] )==1: continue
if self.req_truth and not self.ch.tau_trueTauAssoc_matched[i]: continue
if self.req_cut_l and not self.ch.tau_tauCutLoose[i]: continue
if self.req_cut_m and not self.ch.tau_tauCutMedium[i]: continue
if self.req_cut_t and not self.ch.tau_tauCutTight[i]: continue
if self.req_llh_l and not self.ch.tau_tauLlhLoose[i]: continue
if self.req_llh_m and not self.ch.tau_tauLlhMedium[i]: continue
if self.req_llh_t and not self.ch.tau_tauLlhTight[i]: continue
if self.req_ecut_l and self.ch.tau_electronVetoLoose[i]: continue
if self.req_ecut_m and self.ch.tau_electronVetoMedium[i]: continue
if self.req_ecut_t and self.ch.tau_electronVetoTight[i]: continue
if self.req_ebdt_l and self.ch.tau_EleBDTLoose[i]: continue
if self.req_ebdt_m and self.ch.tau_EleBDTMedium[i]: continue
if self.req_ebdt_t and self.ch.tau_EleBDTTight[i]: continue
if self.min_bdt_ele_score and self.ch.tau_BDTEleScore[i] < self.min_bdt_ele_score: continue
if self.req_muon_veto and self.ch.tau_muonVeto[i]: continue
if self.min_bdt_jet_score and self.ch.tau_BDTJetScore[i] < self.min_bdt_jet_score: continue
if self.veto_loose_muon:
veto_tau = False
for muon in loose_muons:
if p.DeltaR(muon) < 0.2:
veto_tau = True
break
if veto_tau: continue
#added/modified to adapt the tau id patch
if self.recalculate_tauID:
# BDT is recalculated
patch = TauIDpatch(self.year)
pt = self.ch.tau_pt[i]
tracks = self.ch.tau_numTrack[i]
bdtscore = self.ch.tau_BDTJetScore[i]
if self.year == 2012:
#print 'recalculating year 2012 pT= %f MeV, Ntrk = %d, bdt = %f'% (pt, tracks, bdtscore)
self.decision_tau_JetBDTSigLoose, \
self.decision_tau_JetBDTSigMedium, \
self.decision_tau_JetBDTSigTight, \
= patch.passes_2012(pt, tracks, bdtscore)
#print self.ch.tau_JetBDTSigLoose[i], self.ch.tau_JetBDTSigMedium[i], self.ch.tau_JetBDTSigTight[i], \
#' vs ', self.decision_tau_JetBDTSigLoose, self.decision_tau_JetBDTSigMedium, self.decision_tau_JetBDTSigTight
elif self.year == 2011:
print "2011 is under contruction"
continue
else:
raise ValueError("TauSelector: No tauid defined for year %d" % year)
else:
self.decision_tau_JetBDTSigLoose = self.ch.tau_JetBDTSigLoose[i]
self.decision_tau_JetBDTSigMedium = self.ch.tau_JetBDTSigMedium[i]
self.decision_tau_JetBDTSigTight = self.ch.tau_JetBDTSigTight[i]
##
if self.req_bdt_l and not self.decision_tau_JetBDTSigLoose: continue
if self.req_bdt_m and not self.decision_tau_JetBDTSigMedium: continue
if self.req_bdt_t and not self.decision_tau_JetBDTSigTight: continue
self.add_particle(p)
#end of loop
self.sort_particles()
return self.get_particles()
def select(self):
self.tag_index[0] = -1
self.probe_index[0] = -1
self.vis_mass[0] = -1.
# apply trigger if requested
if self.trig_selector:
if not self.trig_selector.select():
#print 'Failed Trigger'
return False
#else:
# print 'Passed Trigger'
# Select Particles
taus = self.tau_selector.select()
muons = self.muon_selector.select()
eles = self.ele_selector.select()
# Remove Overlap
remove_overlap( muons, eles, 0.2 )
remove_overlap( muons, taus, 0.4 )
remove_overlap( eles, taus, 0.4 )
n_eles = len(eles)
n_muons = len(muons)
n_taus = len(taus)
# Require probe tau candidate
if n_taus == 0: return False
# Require tag lepton candidate
if self.channel == 1:
if n_eles == 0: return False
elif self.channel == 2:
if n_muons == 0: return False
# Choose tag
tag = None
if self.channel == 1: tag = eles[0]
elif self.channel == 2: tag = muons[0]
if not tag: return False
self.tag_index[0] = tag.index
# Choose probe
probe = taus[0]
self.probe_index[0] = probe.index
# Dilepton veto
if self.req_dilepton_veto:
if n_eles + n_muons > 1: return False
# Define MET (problematic, since no corrections are applied)
met_x = (self.ch.MET_LocHadTopo_etx
+ self.ch.MET_MuonBoy_etx
- self.ch.MET_RefMuon_Track_etx)
met_y = (self.ch.MET_LocHadTopo_ety
+ self.ch.MET_MuonBoy_ety
- self.ch.MET_RefMuon_Track_ety)
met_E = sqrt( met_x*met_x + met_y*met_y )
met = ParticleBase( 0, _px = met_x, _py = met_y, _pz = 0., _E = met_E )
# W suppression
sum_cos_dphi = cos(probe.DeltaPhi(met)) + cos(tag.DeltaPhi(met))
if sum_cos_dphi < self.min_sum_cos_dphi: return False
trans_mass = sqrt(2.*tag.Pt()*met.Pt()*(1. - cos(tag.DeltaPhi(met))))
if trans_mass > self.max_trans_mass: return False
# Lepton Isolation
if self.channel == 1:
if self.ch.el_nucone40[tag.index] > self.tag_max_nucone40: return False
if self.ch.el_etcone20[tag.index]/probe.Pt() > self.tag_max_etcone20onpt: return False
if self.channel == 2:
if self.ch.mu_staco_nucone40[tag.index] > self.tag_max_nucone40: return False
if self.ch.mu_staco_etcone20[tag.index]/probe.Pt() > self.tag_max_etcone20onpt: return False
# opposite sign / not same sign
probe_charge = self.ch.tau_charge[probe.index]
tag_charge = 0.
if self.channel == 1: tag_charge = self.ch.el_charge[tag.index]
elif self.channel == 2: tag_charge = self.ch.mu_staco_charge[tag.index]
if self.req_os and (probe_charge * tag_charge) >= 0: return False
if self.req_not_ss and (probe_charge * tag_charge) > 0: return False
mvis=(tag+probe).M()
#mass window cut
if len(self.vis_mass_window) == 2 and not min(self.vis_mass_window) < mvis < max(self.vis_mass_window) : return False
# write out visible mass for cross checking skim
self.vis_mass[0] = mvis
if self.tree: self.tree.Fill()
return True
def select(self):
self.clear_particles()
# require TTree to be loaded
if not self.ch:
print 'Warning, no input TTree'
return
# print 'mu_staco_n: ', self.ch.mu_staco_n
# Loop over mu_stacos and select candidates
for i in range(0, self.ch.mu_staco_n):
p = ParticleBase(_index=i,
_pt=self.ch.mu_staco_pt[i],
_eta=self.ch.mu_staco_eta[i],
_phi=self.ch.mu_staco_phi[i],
_m=self.ch.mu_staco_m[i])
if p.Pt() < self.min_pt: continue
if abs(p.Eta()) > self.max_eta: continue
if self.req_tight:
if not self.ch.mu_staco_tight[i]: continue
if self.req_combined:
if not self.ch.mu_staco_isCombinedMuon[i]: continue
if self.ch.mu_staco_z0_exPV[i] >= self.max_z0: continue
if self.ch.mu_staco_nBLHits[i] < self.min_BLHits: continue
if (self.ch.mu_staco_nPixHits[i] +
self.ch.mu_staco_nPixelDeadSensors[i] < self.min_PixHits):
continue
if (self.ch.mu_staco_nSCTHits[i] +
self.ch.mu_staco_nSCTDeadSensors[i] < self.min_SCTHits):
continue
if self.ch.mu_staco_nSCTHoles[i] > self.max_SCTHoles: continue
# Isolation
if self.ch.mu_staco_nucone40[i] > self.max_nucone40: continue
if self.ch.mu_staco_ptcone40[i] / p.Pt() > self.max_ptcone40rel:
continue
if self.ch.mu_staco_etcone20[i] / p.Pt() > self.max_etcone20rel:
continue
# TRT cleaning
if self.req_trt_cleaning:
abs_eta = abs(p.Eta())
n_Hits_TRT = self.ch.mu_staco_nTRTHits[i]
n_Hits_TRT_Outliers = self.ch.mu_staco_nTRTOutliers[i]
n_Hits_TRT_and_Outliers = n_Hits_TRT_Outliers + n_Hits_TRT
if abs_eta < 1.9:
if not (n_Hits_TRT_and_Outliers > 5
and float(n_Hits_TRT_Outliers) /
float(n_Hits_TRT_and_Outliers) < 0.9):
continue
elif abs_eta >= 1.9 and n_Hits_TRT_and_Outliers > 5 and float(
n_Hits_TRT_Outliers) / float(
n_Hits_TRT_and_Outliers) > 0.9:
continue
self.add_particle(p)
self.sort_particles()
return self.get_particles()
