def __init__(
self,
inputCollections = [
[lambda event: Collection(event, "Electron"),["pt"]]
],
saveAs = None,
compareTo = None
):
self.inputCollections = inputCollections
self.saveAs = saveAs
self.compareTo = compareTo
def __init__(self,
inputCollection=lambda event: Collection(event, "Muon"),
outputName="vetoMuons",
muonMinPt=10.,
muonMaxEta=2.4,
globalOptions={"isData": False}):
self.globalOptions = globalOptions
self.inputCollection = inputCollection
self.outputName = outputName
self.muonMinPt = muonMinPt
self.muonMaxEta = muonMaxEta
def __init__(
self,
inputCollection=lambda event: Collection(event, "Electron"),
outputName="vetoElectrons",
electronMinPt=10.,
electronMaxEta=2.4,
):
self.inputCollection = inputCollection
self.outputName = outputName
self.electronMinPt = electronMinPt
self.electronMaxEta = electronMaxEta
def correctJetMET_Data(self, event):
"""Process data event."""
###print ">>> %8s "%event.event + '-'*80
# NOMINAL VALUES
jets_pt_nom = [ ]
if self.corrMET:
met = Object(event, self.metBranchName)
met_px_nom, met_py_nom = met.pt*cos(met.phi), met.pt*sin(met.phi)
# APPLY JEC per jet
jets = Collection(event, self.jetBranchName )
rho = getattr(event, self.rhoBranchName)
for jet in jets:
# RAW VALUES
jet_pt0 = jet.pt
if hasattr(jet,'rawFactor'):
jet_pt_raw = jet_pt0 * (1 - jet.rawFactor)
else:
jet_pt_raw = -1.0 * jet_pt0 # if factor not present factor will be saved as -1
# CALIBRATE - apply JES corrections
if self.redoJEC:
jet_pt_nom, jet_mass_nom = self.jetReCalibrator.correct(jet,rho)
jet.pt = jet_pt_nom
jet.mass = jet_mass_nom
else:
jet_pt_nom = jet.pt
jet_mass_nom = jet.mass
jets_pt_nom.append(jet_pt_nom)
###print "%10.4f %10.4f %10.5f %10.5f"%(jet_pt_raw,jet_pt_nom,jet.eta,jet.rawFactor)
###print "%10.4f %8.4f %8.4f %10.6f %10.6f"%(jet_pt_raw, jet_pt0, jet_pt_nom, jet.rawFactor, jet_pt_nom/jet_pt_raw-1.)
#### UPDATE JET in event
###if self.updateEvent:
### getattr(event,self.jetBranchName+'_pt')[jet._index] = jet_pt_nom
# PROPAGATE JES corrections to MET
if self.corrMET and jet_pt_nom > self.unclEnThreshold:
jet_cosPhi = cos(jet.phi)
jet_sinPhi = sin(jet.phi)
met_px_nom = met_px_nom - (jet_pt_nom - jet_pt0)*jet_cosPhi
met_py_nom = met_py_nom - (jet_pt_nom - jet_pt0)*jet_sinPhi
# PREPARE MET for return
if self.corrMET:
met_nom = TLorentzVector(met_px_nom,met_py_nom,0,sqrt(met_px_nom**2+met_py_nom**2))
###if self.updateEvent:
### setattr(event,self.metBranchName+'_pt', met_vars['nom'].Pt())
### setattr(event,self.metBranchName+'_phi', met_vars['nom'].Phi())
return jets_pt_nom, met_nom
return jets_pt_nom
def __init__(
self,
inputCollection = lambda event: Collection(event, "Muon"),
outputName = "vetoMuons",
muonMinPt = 10.,
muonMaxEta = 2.4,
):
self.inputCollection = inputCollection
self.outputName = outputName
self.muonMinPt = muonMinPt
self.muonMaxEta = muonMaxEta
def analyze(self, event):
"""process event, return True (go to next module) or False (fail, go to next event)"""
jets = Collection(event, self.jetBranchName )
jets_puId17 = []
for jet in jets:
jets_puId17.append(JetPuId17(jet.pt, jet.eta, jet.puIdDisc))
self.out.fillBranch("%s_puId17" % self.jetBranchName, jets_puId17)
return True
def prepareEvent(self, event):
logging.debug('processing event %d' % event.event)
# # ht selection
event.ak4jets = []
for j in event._allJets:
if not (j.pt > 25 and abs(j.eta) < 2.4 and (j.jetId & 2)):
continue
event.ak4jets.append(j)
event.ht = sum([j.pt for j in event.ak4jets])
if event.ht < 1000.:
return False
## selection on AK8 jets
event.fatjets = []
for fj in event._allFatJets:
if not (fj.pt > 200 and abs(fj.eta) < 2.4 and (fj.jetId & 2)):
continue
event.fatjets.append(fj)
if len(event.fatjets) < 2:
return False
## selection on SV
event._allSV = Collection(event, "SV")
event.secondary_vertices = []
for sv in event._allSV:
# if sv.ntracks > 2 and abs(sv.dxy) < 3. and sv.dlenSig > 4:
# if sv.dlenSig > 4:
if True:
event.secondary_vertices.append(sv)
if len(event.secondary_vertices) < 2:
return False
event.secondary_vertices = sorted(event.secondary_vertices,
key=lambda x: x.pt,
reverse=True) # sort by pt
# event.secondary_vertices = sorted(event.secondary_vertices, key=lambda x : x.dxySig, reverse=True) # sort by dxysig
# selection on the probe jet (sub-leading in pT)
probe_fj = event.fatjets[1]
if not (probe_fj.pt > 200 and probe_fj.msoftdrop > 50
and probe_fj.msoftdrop < 200):
return False
# require at least 1 SV matched to each subjet
self.matchSVToSubjets(event, probe_fj)
if len(probe_fj.subjets[0].sv_list) == 0 or len(
probe_fj.subjets[1].sv_list) == 0:
return False
# match SV also to the leading jet
self.matchSVToSubjets(event, event.fatjets[0])
## return True if passes selection
return True
def analyze(self, event):
#get +/- gen weight as in countHistogramModule
binary_gen_weight = self.get_binary_event_weight(event)
#cutflow all events
self.fill_cutflow(1, binary_gen_weight)
###
##HLT
###
HLT_select = False
for trigger in self._triggers:
if event[trigger]:
HLT_select = 1
break
if not HLT_select: return False
#cutflow after hlt
self.fill_cutflow(2, binary_gen_weight)
###
##Objects
###
electrons = sorted(filter(lambda x: self.eleSel(x),
Collection(event, "Electron")),
key=lambda x: x.pt)
bJets = sorted(filter(lambda x: self.bjetSel(x, "nom"),
Collection(event, "Jet")),
key=lambda x: x.pt)
###
##Electrons
###
if not self.selectDiEle(electrons): return False
self.fill_cutflow(3, binary_gen_weight)
###
##Jets
###
if not len(bJets) == 1: return False
self.fill_cutflow(4, binary_gen_weight)
return True
def analyze(self, event):
"""process event, return True (go to next module) or False (fail, go to next event)"""
cleanjets = Collection(event, "CleanJet")
# latino's
# loose
bWP_v1 = {'2016': 0.1522, '2017': 0.1522, '2018': 0.1241}
# alberto's
# https://github.com/zucchett/NanoSkim/blob/master/Skimmer/samesign.py#L118-L135
# medium
bWP_v2 = {'2016': 0.6321, '2017': 0.4941, '2018': 0.4184}
bJet20 = filter(self.jetSel, cleanjets)
bJet30 = filter(lambda x: x.pt > 30 and abs(x.eta) < 2.5, cleanjets)
nbjet_v1 = 0
btagSF_v1 = 1.
bReqSF_v1 = 1.
nbjet_v2 = 0
btagSF_v2 = 1.
bReqSF_v2 = 1.
# v1
for ijet in bJet20:
jetIdx = ijet.jetIdx
if jetIdx < 0: continue
if event.Jet_btagDeepB[jetIdx] > bWP_v1[self.year]: nbjet_v1 += 1
btagSF_v1 = sum(
map(lambda y: ROOT.TMath.Log(event.Jet_btagSF_shape[y.jetIdx]),
bJet20)) if self.isMC else 1.
# v2
for ijet in bJet30:
jetIdx = ijet.jetIdx
if jetIdx < 0: continue
if event.Jet_btagDeepB[jetIdx] >= bWP_v2[self.year]: nbjet_v2 += 1
btagSF_v2 = sum(
map(lambda y: ROOT.TMath.Log(event.Jet_btagSF_shape[y.jetIdx]),
bJet30)) if self.isMC else 1.
self.out.fillBranch("bVeto_v1", 1 if nbjet_v1 == 0 else 0)
self.out.fillBranch("bVeto_v2", 1 if nbjet_v2 == 0 else 0)
self.out.fillBranch("bVetoSF_v1", ROOT.TMath.Exp(btagSF_v1))
self.out.fillBranch("bVetoSF_v2", ROOT.TMath.Exp(btagSF_v2))
# 2017 missing some
#https://github.com/latinos/PlotsConfigurations/blob/master/Configurations/WH_SS/Full2017nanov6/aliases.py#L146-L149
return True
def selectLeptons(self, event):
# do lepton selection
event.looseLeptons = [
] # used for jet lepton cleaning and lepton counting
electrons = Collection(event, "Electron")
for el in electrons:
el.etaSC = el.eta + el.deltaEtaSC
if el.pt > 7 and abs(el.eta) < 2.4 and abs(el.dxy) < 0.05 and abs(
el.dz) < 0.2 and el.pfRelIso03_all < 0.4:
if el.mvaFall17V2noIso_WP90:
event.looseLeptons.append(el)
muons = Collection(event, "Muon")
for mu in muons:
if mu.pt > 5 and abs(mu.eta) < 2.4 and abs(mu.dxy) < 0.5 and abs(
mu.dz) < 1.0 and mu.pfRelIso04_all < 0.4:
if mu.looseId:
event.looseLeptons.append(mu)
event.looseLeptons.sort(key=lambda x: x.pt, reverse=True)
def analyze(self, event):
"""process event, return True (go to next module) or False (fail, go to next event)"""
jets = Collection(event, self.jetColl)
for u, branchname in self.uncerts:
uworker = self.factorizedUncertainties[u]
jetUn = []
for j in jets:
uworker.setJetEta(j.eta)
uworker.setJetPt(j.pt)
jetUn.append(uworker.getUncertainty(True))
self.out.fillBranch(branchname, jetUn)
return True
def analyze(self, event):
parts = Collection(event, 'GenPart')
nparts = len(parts)
m1 = -1
m2 = -1
for p in parts:
if getattr(p, "pdgId") == self.p1: m1 = getattr(p,"mass")
if getattr(p, "pdgId") == self.p2: m2 = getattr(p,"mass")
self.wrappedOutputTree.fillBranch('SMSMassLSP', m1)
self.wrappedOutputTree.fillBranch('SMSMassNLSP', m2)
return True
def analyze(self, event):
genParticles = [x for x in Collection(event, "GenPart")]
for gen in genParticles:
#sTop
if abs(gen.pdgId) == 1000006:
self.wrappedOutputTree.fillBranch("GenSusyMStop", gen.mass)
#Neutralino
if gen.pdgId == 1000022:
self.wrappedOutputTree.fillBranch("GenSusyMNeutralino",
gen.mass)
return True
def analyze(self, event):
leps = [l for l in Collection(event, 'LepGood') ]
ret = [ 0 for l in leps ]
if len(leps) == 2:
for i,l1 in enumerate(leps):
l2 = leps[1-i]
if abs(l2.genPartFlav) not in (1,15): continue
if l2.mvaTTH < 0.9: continue
if deltaR(l1.eta, l1.phi, l2.eta, l2.phi) < 0.8: continue
ret[i] = 1
self.out.fillBranch("LepGood_otherLeptonSelection", ret)
return True
def analyze(self, event):
if self.prescaleFactor == 1:
self.wrappedOutputTree.fillBranch(self.label, self.prescaleFactor)
return True
toBePrescaled = True
if self.minLeptons > 0:
muons = filter(self.muonSel, Collection(event, 'Muon'))
electrons = filter(self.electronSel, Collection(event, 'Electron'))
leps = muons + electrons
if len(leps) < self.minLeptonsNoPrescale:
return False
if len(leps) >= self.minLeptons:
if self.requireSameSignPair:
if any([(l1.charge * l2.charge > 0)
for l1, l2 in itertools.combinations(leps, 2)]):
toBePrescaled = False
else:
toBePrescaled = False
if self.minJets > -1: #was 0, changed to -1: if 0 cannot clean jets and keep them all
jets = filter(self.jetSel, Collection(event, 'Jet'))
if len(jets) >= self.minJets:
toBePrescaled = False
if self.minMET > 0:
if event.MET_pt > self.minMET:
toBePrescaled = False
if not toBePrescaled:
self.wrappedOutputTree.fillBranch(self.label, 1)
return True
elif self.prescaleFactor == 0:
return False
self.events += 1
evno = self.events
if self.useEventNumber: # use run and LS number multiplied by some prime numbers
evno = event.event * 223 + event.luminosityBlock * 997
if (evno % self.prescaleFactor == 1):
self.wrappedOutputTree.fillBranch(self.label, self.prescaleFactor)
return True
else:
return False
def analyze(self, event):
"""process event, return True (go to next module) or False (fail, go to next event)"""
self.CheckisData(event)
electrons = Collection(event, "Electron")
muons = Collection(event, "Muon")
isotracks = Collection(event, "IsoTrack")
jets = Collection(event, "Jet")
met = Object(event, "MET")
flags = Object(event, "Flag")
stop0l = Object(event, "Stop0l")
## Baseline Selection
PassJetID = self.PassJetID(jets)
PassEventFilter = self.PassEventFilter(flags) and PassJetID
PassLeptonVeto = self.PassLeptonVeto(electrons, muons, isotracks)
PassNjets = self.PassNjets(jets)
PassMET = met.pt >= 250
PassHT = stop0l.HT >= 300
PassdPhiLowDM = self.PassdPhi(jets, [0.5, 0.15, 0.15])
PassdPhiHighDM = self.PassdPhi(jets, [0.5, 0.5, 0.5, 0.5])
PassBaseline = PassEventFilter and PassLeptonVeto and PassNjets and PassMET and PassHT and PassdPhiLowDM
PasshighDM = PassBaseline and stop0l.nJets >= 5 and PassdPhiHighDM and stop0l.nbtags >= 1
PasslowDM = PassBaseline and stop0l.nTop == 0 and stop0l.nW == 0 and stop0l.nResolved == 0 and \
stop0l.Mtb < 175 and stop0l.ISRJetPt > 200 and stop0l.METSig > 10
### Store output
self.out.fillBranch("Pass_JetID", PassJetID)
self.out.fillBranch("Pass_EventFilter", PassEventFilter)
self.out.fillBranch("Pass_LeptonVeto", PassLeptonVeto)
self.out.fillBranch("Pass_NJets20", PassNjets)
self.out.fillBranch("Pass_MET", PassMET)
self.out.fillBranch("Pass_HT", PassHT)
self.out.fillBranch("Pass_dPhiMET", PassdPhiLowDM)
self.out.fillBranch("Pass_dPhiMETLowDM", PassdPhiLowDM)
self.out.fillBranch("Pass_dPhiMETHighDM", PassdPhiHighDM)
self.out.fillBranch("Pass_Baseline", PassBaseline)
self.out.fillBranch("Pass_highDM", PasshighDM)
self.out.fillBranch("Pass_lowDM", PasslowDM)
return True
def analyze(self, event):
"""process event, return True (go to next module) or False (fail, go to next event)"""
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)
for typ in self.CollBr:
for bname in self.CollBr[typ]:
temp_b = bname.replace(self.jetColl + '_', '')
temp_v = [jet_coll[iJet][temp_b] for iJet in order]
self.out.fillBranch(bname, temp_v)
return True
def analyze(self, event):
"""process event, return True (go to next module) or False (fail, go to next event)"""
# Order in pt the collection merging muons and electrons
# lepMerger must be already called
Lepton = Collection(event, "Lepton")
self.Lepton_4vecId = []
for iLep in range(3):
if len(Lepton) > iLep:
self.Lepton_4vecId.append(
(ROOT.TLorentzVector(), Lepton[iLep].pdgId))
self.Lepton_4vecId[-1][0].SetPtEtaPhiM(Lepton[iLep].pt,
Lepton[iLep].eta,
Lepton[iLep].phi, 0)
self.MET = ROOT.TLorentzVector()
self.MET.SetPtEtaPhiM(event.PuppiMET_pt, 0, event.PuppiMET_phi, 0)
self.CleanJet_4vecId = []
Jet = Collection(event, "Jet")
for j in Collection(event, "CleanJet"):
self.CleanJet_4vecId.append(
(ROOT.TLorentzVector(), Jet[j.jetIdx].btagCMVA))
self.CleanJet_4vecId[-1][0].SetPtEtaPhiM(j.pt, j.eta, j.phi, 0)
self.l3_isOk = False if len(self.Lepton_4vecId) < 3 else True
self.WH3l_isOk = self._WH3l_isOk()
self.ZH3l_isOk = self._ZH3l_setXLepton()
self.ZH3l_CleanJet_4vecId = [
j for j in self.CleanJet_4vecId
if j[0].Pt() > 30 and abs(j[0].Eta()) < 4.7
]
for nameBranchKey in self.newbranches.keys():
self.out.fillBranch(nameBranchKey,
getattr(self, nameBranchKey)())
return True
def analyze(self, event):
"""process event, return True (go to next module) or False (fail, go to next event)"""
Jets = Collection(event, 'Jet')
CleanJets = Collection(event, 'CleanJet')
nCleanJets = CleanJets._len
nbtagged = 0
for iJet in range(nCleanJets):
if (CleanJets[iJet].pt > 20. and ROOT.TMath.Abs(CleanJets[iJet].eta) < 2.5 and Jets[CleanJets[iJet].jetIdx].btagDeepB > self.bVetoCut):
nbtagged += 1
else:
continue
if 'TTTo2L2Nu' in str(self.inputFile):
MCweight = (event.topGenPt * event.antitopGenPt > 0.) * (ROOT.TMath.Sqrt(ROOT.TMath.Exp(-1.43717e-02 - 1.18358e-04*event.topGenPt - 1.70651e-07*event.topGenPt*event.topGenPt + 4.47969/(event.topGenPt+28.7)) * ROOT.TMath.Exp(-1.43717e-02 - 1.18358e-04*event.antitopGenPt - 1.70651e-07*event.antitopGenPt*event.antitopGenPt + 4.47969/(event.antitopGenPt+28.7)))) + (event.topGenPt * event.antitopGenPt <= 0.)
elif '_WWTo2L2Nu_' in str(self.inputFile):
MCweight = event.nllW
elif '_M-50' in str(self.inputFile): #DY high mass
MCweight = (((0.623108 + 0.0722934*event.gen_ptll - 0.00364918*event.gen_ptll*event.gen_ptll + 6.97227e-05*event.gen_ptll*event.gen_ptll*event.gen_ptll - 4.52903e-07*event.gen_ptll*event.gen_ptll*event.gen_ptll*event.gen_ptll)*(event.gen_ptll<45)*(event.gen_ptll>0) + 1*(event.gen_ptll>=45))*(ROOT.TMath.Abs(event.gen_mll-90)<3) + (ROOT.TMath.Abs(event.gen_mll-90)>3))
elif '_M-10to50' in str(self.inputFile): #DY low mass
MCweight = ((0.632927+0.0456956*event.gen_ptll-0.00154485*event.gen_ptll*event.gen_ptll+2.64397e-05*event.gen_ptll*event.gen_ptll*event.gen_ptll-2.19374e-07*event.gen_ptll*event.gen_ptll*event.gen_ptll*event.gen_ptll+6.99751e-10*event.gen_ptll*event.gen_ptll*event.gen_ptll*event.gen_ptll*event.gen_ptll)*(event.gen_ptll>0)*(event.gen_ptll<100)+(1.41713-0.00165342*event.gen_ptll)*(event.gen_ptll>=100)*(event.gen_ptll<300)+1*(event.gen_ptll>=300))
elif '50_HT' in str(self.inputFile): #HT binned samples
MCweight = ((0.632927+0.0456956*event.gen_ptll-0.00154485*event.gen_ptll*event.gen_ptll+2.64397e-05*event.gen_ptll*event.gen_ptll*event.gen_ptll-2.19374e-07*event.gen_ptll*event.gen_ptll*event.gen_ptll*event.gen_ptll+6.99751e-10*event.gen_ptll*event.gen_ptll*event.gen_ptll*event.gen_ptll*event.gen_ptll)*(event.gen_ptll>0)*(event.gen_ptll<100)+(1.41713-0.00165342*event.gen_ptll)*(event.gen_ptll>=100)*(event.gen_ptll<300)+1*(event.gen_ptll>=300))
elif (('GluGluWWTo2' in str(self.inputFile)) or ('GluGluToWW' in str(self.inputFile))):
MCweight = 1.53/1.4
elif (('ZZTo2L2Nu' in str(self.inputFile)) or ('ZZTo2L2Q' in str(self.inputFile)) or ('ZZTo4L' in str(self.inputFile)) or ('WZTo2L2Q' in str(self.inputFile))):
MCweight = 1.11
else:
MCweight = 1.0
self.out.fillBranch('nbtaggedJets',nbtagged)
self.out.fillBranch('metpt',eval(self.metpt))
self.out.fillBranch('metsig',eval(self.metsig))
self.out.fillBranch('lep1pt',eval(self.lep1pt))
self.out.fillBranch('lep2pt',eval(self.lep2pt))
self.out.fillBranch('specialMCWeigths',MCweight)
return True
def analyze(self, event):
"""process event, return True (go to next module) or False (fail, go to next event)"""
## Getting objects
jets = Collection(event, "Jet")
electrons = Collection(event, "Electron")
muons = Collection(event, "Muon")
met = Object(event, self.metBranchName)
genpart = Collection(event, "GenPart")
## Selecting objects
self.Electron_Stop0l = map(self.SelEle, electrons)
self.Muon_Stop0l = map(self.SelMuon, muons)
## Jet variables
MtEleMET, MtMuonMET = self.SelMtlepMET(electrons, muons, met)
### Store output
self.out.fillBranch("Stop0l_MtEleMET", MtEleMET)
self.out.fillBranch("Stop0l_MtMuonMET", MtMuonMET)
self.out.fillBranch("Stop0l_nElectron", sum(self.Electron_Stop0l))
self.out.fillBranch("Stop0l_nMuon", sum(self.Muon_Stop0l))
return True
def analyze(self, event):
"""process event, return True (go to next module) or False (fail, go to next event)"""
Jets = Collection(event, 'Jet')
CleanJets = Collection(event, 'CleanJet')
nCleanJets = CleanJets._len
nbtagged = 0
for iJet in range(nCleanJets):
if (CleanJets[iJet].pt > 20. and ROOT.TMath.Abs(CleanJets[iJet].eta) < 2.5 and Jets[CleanJets[iJet].jetIdx].btagDeepB > self.bVetoCut):
nbtagged += 1
else:
continue
if 'TTTo2L2Nu' in str(self.inputFile):
MCweight = (event.topGenPt * event.antitopGenPt > 0.) * (ROOT.TMath.Sqrt(ROOT.TMath.Exp(-0.158631 + 2.00214e-04*event.topGenPt - 3.09496e-07*event.topGenPt*event.topGenPt + 34.93/(event.topGenPt+135.633)) * ROOT.TMath.Exp(-0.158631 + 2.00214e-04*event.antitopGenPt - 3.09496e-07*event.antitopGenPt*event.antitopGenPt + 34.93/(event.antitopGenPt+135.633)))) + (event.topGenPt * event.antitopGenPt <= 0.)
elif '_WWTo2L2Nu_' in str(self.inputFile):
MCweight = event.nllW
elif '_M-50' in str(self.inputFile): #DY high mass
MCweight = (0.876979+event.gen_ptll*(4.11598e-03)-(2.35520e-05)*event.gen_ptll*event.gen_ptll)*(1.10211 * (0.958512 - 0.131835*ROOT.TMath.Erf((event.gen_ptll-14.1972)/10.1525)))*(event.gen_ptll<140)+0.891188*(event.gen_ptll>=140)
elif '_M-10to50' in str(self.inputFile): #DY low mass
MCweight = (8.61313e-01+event.gen_ptll*4.46807e-03-1.52324e-05*event.gen_ptll*event.gen_ptll)*(1.08683 * (0.95 - 0.0657370*ROOT.TMath.Erf((event.gen_ptll-11.)/5.51582)))*(event.gen_ptll<140)+1.141996*(event.gen_ptll>=140)
elif '50_HT' in str(self.inputFile): #DY low mass
MCweight = (8.61313e-01+event.gen_ptll*4.46807e-03-1.52324e-05*event.gen_ptll*event.gen_ptll)*(1.08683 * (0.95 - 0.0657370*ROOT.TMath.Erf((event.gen_ptll-11.)/5.51582)))*(event.gen_ptll<140)+1.141996*(event.gen_ptll>=140)
elif (('GluGluWWTo2' in str(self.inputFile)) or ('GluGluToWW' in str(self.inputFile))):
MCweight = 1.53/1.4
elif (('ZZTo2L2Nu' in str(self.inputFile)) or ('ZZTo2L2Q' in str(self.inputFile)) or ('ZZTo4L' in str(self.inputFile)) or ('WZTo2L2Q' in str(self.inputFile))):
MCweight = 1.11
else:
MCweight = 1.0
self.out.fillBranch('nbtaggedJets',nbtagged)
self.out.fillBranch('metpt',eval(self.metpt))
self.out.fillBranch('metsig',eval(self.metsig))
self.out.fillBranch('lep1pt',eval(self.lep1pt))
self.out.fillBranch('lep2pt',eval(self.lep2pt))
self.out.fillBranch('specialMCWeigths',MCweight)
return True
def matchgenvistau(event, tau, dRmin=0.5):
"""Help function to match tau object to gen vis tau."""
# TO CHECK: taumatch.genPartIdxMother==tau.genPartIdx ?
taumatch = None
for genvistau in Collection(event, 'GenVisTau'):
dR = genvistau.DeltaR(tau)
if dR < dRmin:
dRmin = dR
taumatch = genvistau
if taumatch:
return taumatch.pt, taumatch.eta, taumatch.phi, taumatch.status
else:
return -1, -9, -9, -1
def analyze(self, event):
"""process event, return True (go to next module) or False (fail, go to next event)"""
electrons = sorted(filter(lambda x: self.eleSel(x,53), Collection(event, "Electron")), key=lambda x: x.pt)
muons = sorted(filter(lambda x: self.muSel(x,53), Collection(event, "Muon")), key=lambda x: x.pt_corrected)
electronsLowPt = sorted(filter(lambda x: self.eleSel(x,24), Collection(event, "Electron")), key=lambda x: x.pt)
muonsLowPt = sorted(filter(lambda x: self.muSel(x,24), Collection(event, "Muon")), key=lambda x: x.pt_corrected)
isDiMu = self.selectDiMu(electrons, muons)
isDiEle = self.selectDiEle(electrons, muons)
isEleMu = self.selectEleMu(electrons, muons)
nLowPtLep = len(electronsLowPt)+len(muonsLowPt)
self.out.fillBranch("IncMumu", isDiMu)
self.out.fillBranch("IncEe", isDiEle)
self.out.fillBranch("IncEmu", isEleMu)
self.out.fillBranch("IncMumuLowPt", isDiMu and nLowPtLep<3)
self.out.fillBranch("IncEeLowPt", isDiEle and nLowPtLep<3)
self.out.fillBranch("IncEmuLowPt", isEleMu and nLowPtLep<3)
return (isDiMu or isDiEle or isEleMu)
def triggerMatching(self, event, muonVec, filterBit):
trigObject = Collection(event, "TrigObj")
if filterBit == 2:
for obj in trigObject:
if obj.id == 13:
matched = [
5e-2 > np.sqrt((obj.eta - muon.fourVec.Eta())**2 +
(obj.phi - muon.fourVec.Phi())**2)
for muon in muonVec
]
return True in matched
def analyze(self, event):
"""process event, return True (go to next module) or False (fail, go to next event)"""
genParticles = Collection(event, "GenPart")
genDressedLeptons = Collection(event,"GenDressedLepton")
# reobtain the indices of the good muons and the neutrino
bareMuonIdx = event.GenPart_bareMuonIdx
NeutrinoIdx = event.GenPart_NeutrinoIdx
preFSRMuonIdx = event.GenPart_preFSRMuonIdx
dressMuonIdx = event.GenDressedLepton_dressMuonIdx
if bareMuonIdx >= 0 and NeutrinoIdx >= 0:
CStheta_bare, CSphi_bare = getCSangles(genParticles[bareMuonIdx], genParticles[NeutrinoIdx])
else:
CStheta_bare, CSphi_bare = -99., -99.
if preFSRMuonIdx >= 0 and NeutrinoIdx >= 0:
CStheta_preFSR, CSphi_preFSR = getCSangles(genParticles[preFSRMuonIdx], genParticles[NeutrinoIdx])
else:
CStheta_preFSR, CSphi_preFSR = -99., -99.
if dressMuonIdx >= 0 and NeutrinoIdx >= 0:
CStheta_dress, CSphi_dress = getCSangles(genDressedLeptons[dressMuonIdx], genParticles[NeutrinoIdx])
else:
CStheta_dress, CSphi_dress = -99., -99.
self.out.fillBranch("CStheta_bare",CStheta_bare)
self.out.fillBranch("CSphi_bare",CSphi_bare)
self.out.fillBranch("CStheta_preFSR",CStheta_preFSR)
self.out.fillBranch("CSphi_preFSR",CSphi_preFSR)
self.out.fillBranch("CStheta_dress",CStheta_dress)
self.out.fillBranch("CSphi_dress",CSphi_dress)
return True
def getEmbeddingSelectionTriggerSF(self, event):
"""Get SF for embedding trigger selection efficiency. we use the two gentaus in the event
Since we know from the embedding, that there are always two of those in the event, this can be done
"""
parameters = {}
genparticles = Collection(event, 'GenPart')
i = 1
for genparticle in genparticles:
if abs(genparticle.pdgId) == 15:
parameters["gt{}_pt".format(i)] = genparticle.pt
parameters["gt{}_eta".format(i)] = abs(genparticle.eta)
i += 1
return self.sftool_seltrg.getSF(parameters)
def analyze(self, event):
"""process event, return True (go to next module) or False (fail, go to next event)"""
## Getting objects
electrons = Collection(event, "Electron")
muons = Collection(event, "Muon")
isotracks = Collection(event, "IsoTrack")
jets = Collection(event, "Jet")
isvs = Collection(event, "SB")
photons = Collection(event, "Photon")
met = Object(event, self.metBranchName)
flags = Object(event, "Flag")
## Selecting objects
self.Electron_Stop0l = map(self.SelEle, electrons)
self.Muon_Stop0l = map(self.SelMuon, muons)
self.IsoTrack_Stop0l = map(lambda x: self.SelIsotrack(x, met),
isotracks)
self.Jet_Stop0l = map(self.SelJets, jets)
local_BJet_Stop0l = map(self.SelBtagJets, jets)
self.BJet_Stop0l = [
a and b for a, b in zip(self.Jet_Stop0l, local_BJet_Stop0l)
]
self.SB_Stop0l = map(self.SelSoftb, isvs)
self.Photon_Stop0l = map(self.SelPhotons, photons)
## Jet variables
jet_phi = np.asarray([jet.phi for jet in jets])
Jet_dPhi = jet_phi - met.phi
np.subtract(Jet_dPhi,
2 * math.pi,
out=Jet_dPhi,
where=(Jet_dPhi >= math.pi))
np.add(Jet_dPhi,
2 * math.pi,
out=Jet_dPhi,
where=(Jet_dPhi < -1 * math.pi))
np.fabs(Jet_dPhi, out=Jet_dPhi)
## TODO: Need to improve speed
HT = self.CalHT(jets)
Mtb, Ptb = self.CalMTbPTb(jets, met)
### Store output
self.out.fillBranch("Electron_Stop0l", self.Electron_Stop0l)
self.out.fillBranch("Muon_Stop0l", self.Muon_Stop0l)
self.out.fillBranch("IsoTrack_Stop0l", self.IsoTrack_Stop0l)
self.out.fillBranch("Jet_btagStop0l", self.BJet_Stop0l)
self.out.fillBranch("Jet_Stop0l", self.Jet_Stop0l)
self.out.fillBranch("SB_Stop0l", self.SB_Stop0l)
self.out.fillBranch("Photon_Stop0l", self.Photon_Stop0l)
self.out.fillBranch("Jet_dPhiMET", Jet_dPhi)
self.out.fillBranch("Stop0l_HT", HT)
self.out.fillBranch("Stop0l_Mtb", Mtb)
self.out.fillBranch("Stop0l_Ptb", Ptb)
self.out.fillBranch("Stop0l_nJets", sum(self.Jet_Stop0l))
self.out.fillBranch("Stop0l_nbtags", sum(self.BJet_Stop0l))
self.out.fillBranch("Stop0l_nSoftb", sum(self.SB_Stop0l))
self.out.fillBranch("Stop0l_METSig",
met.pt / math.sqrt(HT) if HT > 0 else 0)
return True
def analyze(self, event):
"""process event, return True (go to next module) or False (fail, go to next event)"""
# muon selection
event._allMuons = Collection(event, "Muon")
event.muons = [mu for mu in event._allMuons if mu.pt > 55 and abs(mu.eta) < 2.4 and abs(
mu.dxy) < 0.2 and abs(mu.dz) < 0.5 and mu.tightId and mu.miniPFRelIso_all < 0.10]
if len(event.muons) != 1:
return False
self.selectLeptons(event)
self.correctJetsAndMET(event)
# met selection
if event.met.pt < 50.0:
return False
# leptonic W pt cut
event.mu = event.muons[0]
event.leptonicW = polarP4(event.mu) + event.met.p4()
if event.leptonicW.Pt() < 100.0:
return False
# at least one b-jet, in the same hemisphere of the muon
event.bjets = [j for j in event.ak4jets if j.btagDeepB > self.DeepCSV_WP_M and
abs(deltaPhi(j, event.mu)) < 2]
if len(event.bjets) == 0:
return False
# require fatjet away from the muon
probe_jets = [fj for fj in event.fatjets if abs(deltaPhi(fj, event.mu)) > 2]
if len(probe_jets) == 0:
return False
probe_jets = probe_jets[:1]
self.loadGenHistory(event, probe_jets)
self.evalTagger(event, probe_jets)
self.evalMassRegression(event, probe_jets)
# fill output branches
self.fillBaseEventInfo(event)
self.fillFatJetInfo(event, probe_jets)
# fill
self.out.fillBranch("passMuTrig", passTrigger(event, ['HLT_Mu50', 'HLT_TkMu50']))
self.out.fillBranch("muon_pt", event.mu.pt)
self.out.fillBranch("muon_eta", event.mu.eta)
self.out.fillBranch("muon_miniIso", event.mu.miniPFRelIso_all)
self.out.fillBranch("leptonicW_pt", event.leptonicW.Pt())
return True
def analyze(self, event):
"""process event, return True (go to next module) or False (fail, go to next event)"""
jets = sorted(filter(lambda x: self.alljetSel(x, 'nom'),
Collection(event, "Jet")),
key=lambda x: x.pt)
jetPt = [20., 30., 50., 70., 100., 140., 200., 300., 600., 1000.]
self.Pass.clear()
Dummy1 = ROOT.std.vector('int')()
Dummy1.resize(10, 0)
self.Pass.resize(3, Dummy1)
self.Total.clear()
Dummy2 = ROOT.std.vector('int')()
Dummy2.resize(10, 0)
self.Total.resize(3, Dummy2)
if self.isMC:
for j in jets:
# select flavor
flavour = 2
if j.genJetIdx >= 0:
if j.hadronFlavour == 5:
flavour = 0
elif j.hadronFlavour == 4:
flavour = 1
if self.select_btag(j):
self.bTagEffTH2F.Fill(flavour, j.pt)
self.TotalTH2F.Fill(flavour, j.pt)
if self.isMC:
for j in jets:
bin = 9
for k in reversed(jetPt):
if j.pt > k:
break
bin -= 1
if bin >= 0:
flavor = 2
if j.genJetIdx >= 0:
if j.hadronFlavour == 5:
flavor = 0
elif j.hadronFlavour == 4:
flavor = 1
if self.select_btag(j):
self.Pass[flavor][bin] += 1
self.Total[flavor][bin] += 1
else:
pass
self.out._tree.Fill()
return True
def analyze(self, event):
coll = Collection(event, self.CollTC)
nColl = len(coll)
if self.doMET:
met = Object(event, self.METobj)
met_px = met['pt'] * math.cos(met['phi'])
met_py = met['pt'] * math.sin(met['phi'])
# Create new pt
new_pt = []
for iObj in range(nColl):
if self.isUp:
tmp_pt = coll[iObj]['pt'] + coll[iObj][
self.CorrSrc] * coll[iObj]['pt']
else:
tmp_pt = coll[iObj]['pt'] - coll[iObj][
self.CorrSrc] * coll[iObj]['pt']
new_pt.append(tmp_pt)
# MET
if self.doMET and tmp_pt > self.minJetEn:
pt_diff = tmp_pt - coll[iObj]['pt']
met_px -= pt_diff * (math.cos(coll[iObj]['pt']))
met_py -= pt_diff * (math.sin(coll[iObj]['pt']))
if self.doMET:
new_MET_pt = math.sqrt(met_px**2 + met_py**2)
new_MET_phi = math.atan2(met_px, met_py)
# Reorder
order = []
for idx1, pt1 in enumerate(new_pt):
pt_idx = 0
for idx2, pt2 in enumerate(new_pt):
if pt1 < pt2 or (pt1 == pt2 and idx1 > idx2): pt_idx += 1
order.append(pt_idx)
# Fill branches
for typ in self.CollBr:
for bname in self.CollBr[typ]:
if '_pt' in bname:
temp_v = [new_pt[idx] for idx in order]
self.out.fillBranch(bname, temp_v)
else:
temp_b = bname.replace(self.CollTC + '_', '')
temp_v = [coll[idx][temp_b] for idx in order]
self.out.fillBranch(bname, temp_v)
if self.doMET:
self.out.fillBranch(self.METobj + '_pt', new_MET_pt)
self.out.fillBranch(self.METobj + '_phi', new_MET_phi)
return True
