def makeOddEvenEvaluator(isOdd, oddPath, evenPath, mvaType="TMVA"):
model_odd = op.mvaEvaluator(oddPath , mvaType=mvaType)
model_even = op.mvaEvaluator(evenPath, mvaType=mvaType)
methName = model_even.evaluate._name
assert model_odd.evaluate._name == methName
switchModelEval = op.switch(isOdd, model_odd.evaluate._objStb, model_even.evaluate._objStb)
return op.MVAEvaluator(getattr(switchModelEval, methName))
def comp_cosThetaSbetBeamAndHiggs(self, genColl):
genh = op.select(
genColl,
lambda g: op.AND(g.pdgId == 25, g.statusFlags & (0x1 << 13)))
HH_p4 = genh[0].p4 + genh[1].p4
cm = HH_p4.BoostToCM()
boosted_h1 = op.extMethod("ROOT::Math::VectorUtil::boost",
returnType=genh[0].p4._typeName)(genh[0].p4,
cm)
boosted_h2 = op.extMethod("ROOT::Math::VectorUtil::boost",
returnType=genh[1].p4._typeName)(genh[1].p4,
cm)
mHH = op.switch(
op.rng_len(genh) == 2, op.invariant_mass(genh[0].p4, genh[1].p4),
op.c_float(-9999))
cosTheta1 = op.switch(
op.rng_len(genh) == 2, op.abs(boosted_h1.Pz() / boosted_h1.P()),
op.c_float(-9999))
cosTheta2 = op.switch(
op.rng_len(genh) == 2, op.abs(boosted_h1.Pz() / boosted_h2.P()),
op.c_float(-9999))
return [mHH, cosTheta1, cosTheta2]
def evaluateJPA_Hbb1Wj(lepton, muons, electrons, fatJets, jets, bJetsL, bJetsM, met, model, HLL):
#invars = [op.c_float(0.)]*14
invars = [op.switch(fatJets[0].subJet1.btagDeepB > fatJets[0].subJet2.btagDeepB, # dEta_bjet1_lep
op.abs(lepton.eta-fatJets[0].subJet1.eta),
op.abs(lepton.eta-fatJets[0].subJet2.eta)),
bJetCorrPT(jets[0]), # wjet1_ptReg
jets[0].btagDeepB, # wjet1_btagCSV
jets[0].qgl, # wjet1_qgDiscr
op.deltaR(lepton.p4, jets[0].p4), # dR_wjet1_lep
(fatJets[0].subJet1.p4 + fatJets[0].subJet2.p4).Pt(), # Hbb_Pt
op.rng_len(bJetsM) # nBJetMedium
]
return model(*invars, defineOnFirstUse=False)[0]
def findJPACategoryBoosted (self, selObj, lepton, muons, electrons, fatJets, jets, bJetsL, bJetsM, met, modelPathDict, event, HLL, nodeList, plot_yield=False):
JPAfuncDict = {'f1':evaluateJPA_Hbb2Wj,
'f2':evaluateJPA_Hbb1Wj}
JPAMaxScoreList = []
bestCombo_per_cat = []
combo2 = op.combine(jets, N=2, pred=lambda j1,j2 : j1.pt > j2.pt, samePred=lambda j1,j2 : j1.idx != j2.idx)
fakeCombo2 = op.combine(jets, N=2, pred=lambda j1,j2 : j1.pt >= j2.pt, samePred=None)
funckeys = [k for k in JPAfuncDict.keys()]
for idx, func in enumerate(funckeys):
node = nodeList[idx]
modelpaths = modelPathDict.get(node)
model = makeOddEvenEvaluator(event%2, modelpaths[1], modelpaths[0], mvaType="TMVA")
lambdaFunc = lambda jetCombo : JPAfuncDict[func](lepton, muons, electrons, fatJets, jetCombo, bJetsL, bJetsM, met, model, HLL)
if idx == 0:
best = op.rng_max_element_by(combo2, lambdaFunc)
maxScore = op.switch(best.idx != -1, best.idx.op.this.result.second, op.c_float(-1.))
else:
best = op.rng_max_element_by(fakeCombo2, lambdaFunc)
#best = op.rng_max_element_by(combo2, lambdaFunc)
maxScore = best.idx.op.this.result.second
#maxScore = op.switch(best.idx != -1, best.idx.op.this.result.second, op.c_float(-1.))
JPAMaxScoreList.append(op.pow((1.0 + op.sqrt((1 - maxScore)/(1 + maxScore))), -1))
#JPAMaxScoreList.append(maxScore)
bestCombo_per_cat.append(best)
evtCat = makeOddEvenEvaluator(event%2, modelPathDict.get('evCat')[1], modelPathDict.get('evCat')[0], mvaType="TMVA")
JPAL2outList = evtCat(*JPAMaxScoreList)
maxIdx = op.rng_max_element_index(JPAL2outList)
newSelObj = copy(selObj)
selObjJPAjetsIdxDict = {}
for i, node in enumerate(nodeList):
outSelObj = copy(newSelObj)
outSelObj.selName += '%s'%node
outSelObj.yieldTitle += " in %s node"%node
outSelObj.refine(cut = [maxIdx == op.c_int(i)])
#if plot_yield:
# outSelObj.makeYield(self.yieldPlots)
if i < 2:
selObjJPAjetsIdxDict[node] = [outSelObj, bestCombo_per_cat[i]]
else:
selObjJPAjetsIdxDict[node] = [outSelObj, None]
return JPAMaxScoreList, JPAL2outList, selObjJPAjetsIdxDict
def returnFatjetMVAInputs(self, fatjets):
return {
('fatjet_E', 'Fatjet E [GeV]', (50, 0., 500.)):
op.switch(op.rng_len(fatjets) > 0, fatjets[0].p4.E(), op.c_float(0.)),
('fatjet_Px', 'Fatjet P_x [GeV]', (40, -200., 200.)):
op.switch(op.rng_len(fatjets) > 0, fatjets[0].p4.Px(), op.c_float(0.)),
('fatjet_Py', 'Fatjet P_y [GeV]', (40, -200., 200.)):
op.switch(op.rng_len(fatjets) > 0, fatjets[0].p4.Py(), op.c_float(0.)),
('fatjet_Pz', 'Fatjet P_z [GeV]', (40, -200., 200.)):
op.switch(op.rng_len(fatjets) > 0, fatjets[0].p4.Pz(), op.c_float(0.)),
('fatjet_tau1', 'Fatjet #tau_1', (50, 0., 1.)):
op.switch(op.rng_len(fatjets) > 0, fatjets[0].tau1, op.c_float(0.)),
('fatjet_tau2', 'Fatjet #tau_2', (50, 0., 1.)):
op.switch(op.rng_len(fatjets) > 0, fatjets[0].tau2, op.c_float(0.)),
('fatjet_tau3', 'Fatjet #tau_3', (50, 0., 1.)):
op.switch(op.rng_len(fatjets) > 0, fatjets[0].tau3, op.c_float(0.)),
('fatjet_tau4', 'Fatjet #tau_4', (50, 0., 1.)):
op.switch(op.rng_len(fatjets) > 0, fatjets[0].tau4, op.c_float(0.)),
('fatjet_softdrop', 'Fatjet softdrop mass [GeV]', (50, 0., 1000.)):
op.switch(
op.rng_len(fatjets) > 0, fatjets[0].msoftdrop, op.c_float(0.))
}
def plotRecoForGen(sel, gen, reco, lambda_match, name):
n_reco = [
op.select(
reco, lambda r: op.switch(
op.rng_len(gen) > i, lambda_match(gen[i], r), op.c_bool(False))
) for i in range(10)
]
plots = SummedPlot("n_reco_{}_per_gen".format(name), [
Plot.make1D("n_reco_{}_per_gen_{}".format(name, i),
op.rng_len(nre),
sel,
EquidistantBinning(10, 0, 10),
xTitle="N reco {} for gen {}".format(name, i))
for i, nre in enumerate(n_reco)
],
xTitle="N reco {} for each gen".format(name))
return plots
def returnLeptonsMVAInputs(self,l1,l2,channel):
if channel == "ElEl":
cone_l1 = self.getElectronConeP4(l1)
cone_l2 = self.getElectronConeP4(l2)
elif channel == "MuMu":
cone_l1 = self.getMuonConeP4(l1)
cone_l2 = self.getMuonConeP4(l2)
elif channel == "ElMu":
cone_l1 = self.getElectronConeP4(l1)
cone_l2 = self.getMuonConeP4(l2)
else:
raise RuntimeError("Wrong channel")
return {('l1_E', 'Lead lepton E [GeV]', (50,0.,500.)) : op.switch(cone_l1.Pt() >= cone_l2.Pt() , cone_l1.E(), cone_l2.E()),
('l1_Px', 'Lead lepton P_x [GeV]', (40,-200.,200.)) : op.switch(cone_l1.Pt() >= cone_l2.Pt() , cone_l1.Px(), cone_l2.Px()),
('l1_Py', 'Lead lepton P_y [GeV]', (40,-200.,200.)) : op.switch(cone_l1.Pt() >= cone_l2.Pt() , cone_l1.Py(), cone_l2.Py()),
('l1_Pz', 'Lead lepton P_z [GeV]', (40,-200.,200.)) : op.switch(cone_l1.Pt() >= cone_l2.Pt() , cone_l1.Pz(), cone_l2.Pz()),
('l1_pdgId', 'Lead lepton pdg ID', (45,-22.,22.) ) : op.switch(cone_l1.Pt() >= cone_l2.Pt() , l1.pdgId, l2.pdgId),
('l1_charge', 'Lead lepton charge', (2,0.,2.) ) : op.switch(cone_l1.Pt() >= cone_l2.Pt() , l1.charge, l2.charge),
('l2_E', 'Sublead lepton E [GeV]', (50,0.,500.)) : op.switch(cone_l1.Pt() >= cone_l2.Pt() , cone_l2.E(), cone_l1.E()),
('l2_Px', 'Sublead lepton P_x [GeV]', (40,-200.,200.)) : op.switch(cone_l1.Pt() >= cone_l2.Pt() , cone_l2.Px(), cone_l1.Px()),
('l2_Py', 'Sublead lepton P_y [GeV]', (40,-200.,200.)) : op.switch(cone_l1.Pt() >= cone_l2.Pt() , cone_l2.Py(), cone_l1.Py()),
('l2_Pz', 'Sublead lepton P_z [GeV]', (40,-200.,200.)) : op.switch(cone_l1.Pt() >= cone_l2.Pt() , cone_l2.Pz(), cone_l1.Pz()),
('l2_pdgId', 'Sublead lepton pdg ID', (45,-22.,22.) ) : op.switch(cone_l1.Pt() >= cone_l2.Pt() , l2.pdgId, l1.pdgId),
('l2_charge', 'Sublead lepton charge', (2,0.,2.) ) : op.switch(cone_l1.Pt() >= cone_l2.Pt() , l2.charge, l1.charge)}
def definePlots(self, t, noSel, sample=None, sampleCfg=None):
noSel = super(PlotterNanoHHtobbWWDL,self).prepareObjects(t, noSel, sample, sampleCfg, 'DL')
#----- Machine Learning Model -----#
path_model = os.path.join(os.path.abspath(os.path.dirname(__file__)),'MachineLearning','model.pb')
if not os.path.exists(path_model):
raise RuntimeError('Could not find model file %s'%path_model)
try:
LBN = op.mvaEvaluator(path_model,mvaType='Tensorflow',otherArgs=(["input_1", "input_2"], "model/output/Softmax"))
except:
raise RuntimeError('Could not load model %s'%path_model)
#---- Parameters -----#
plots = []
cutFlowPlots = []
era = sampleCfg['era']
self.sample = sample
self.sampleCfg = sampleCfg
self.era = era
self.yieldPlots = makeYieldPlots(self.args.Synchronization)
#----- Ratio reweighting variables (before lepton and jet selection) -----#
if self.args.BtagReweightingOff or self.args.BtagReweightingOn:
plots.append(objectsNumberPlot(channel="NoChannel",suffix='NoSelection',sel=noSel,objCont=self.ak4Jets,objName='Ak4Jets',Nmax=15,xTitle='N(Ak4 jets)'))
plots.append(CutFlowReport("BtagReweightingCutFlowReport",noSel))
return plots
#----- Stitching study -----#
if self.args.DYStitchingPlots or self.args.WJetsStitchingPlots:
if self.args.DYStitchingPlots and sampleCfg['group'] != 'DY':
raise RuntimeError("Stitching is only done on DY MC samples")
if self.args.WJetsStitchingPlots and sampleCfg['group'] != 'Wjets':
raise RuntimeError("Stitching is only done on WJets MC samples")
plots.extend(makeLHEPlots(noSel,t.LHE))
plots.append(objectsNumberPlot(channel="NoChannel",suffix='NoSelection',sel=noSel,objCont=self.ak4Jets,objName='Ak4Jets',Nmax=15,xTitle='N(Ak4 jets)'))
plots.append(CutFlowReport("DYStitchingCutFlowReport",noSel))
return plots
#----- Dileptons -----#
selObjectDict = makeDoubleLeptonSelection(self,noSel,plot_yield=True)
# selObjectDict : keys -> level (str)
# values -> [ElEl,MuMu,ElMu] x Selection object
# Select the jets selections that will be done depending on user input #
jet_level = ["Ak4","Ak8","Resolved0Btag","Resolved1Btag","Resolved2Btag","Boosted"]
jetplot_level = [arg for (arg,boolean) in self.args.__dict__.items() if arg in jet_level and boolean]
if len(jetplot_level) == 0:
jetplot_level = jet_level # If nothing said, will do all
jetsel_level = copy(jetplot_level) # A plot level might need a previous selection that needs to be defined but not necessarily plotted
if "Resolved0Btag" in jetsel_level or "Resolved1Btag" in jetsel_level or "Resolved2Btag" in jetsel_level:
jetsel_level.append("Ak4") # Resolved needs the Ak4 selection
if "Boosted" in jetsel_level:
jetsel_level.append("Ak8") # Boosted needs the Ak8 selection
# Loop over lepton selection and start plotting #
for selectionType, selectionList in selObjectDict.items():
print ("... Processing %s lepton type"%selectionType)
#----- Select correct dilepton -----#
if selectionType == "Preselected":
OSElElDilepton = self.OSElElDileptonPreSel
OSMuMuDilepton = self.OSMuMuDileptonPreSel
OSElMuDilepton = self.OSElMuDileptonPreSel
elif selectionType == "Fakeable":
OSElElDilepton = self.ElElDileptonFakeSel
OSMuMuDilepton = self.MuMuDileptonFakeSel
OSElMuDilepton = self.ElMuDileptonFakeSel
elif selectionType == "Tight":
OSElElDilepton = switch_on_index([0],op.rng_len(self.ElElDileptonTightSel)>=1,self.ElElDileptonTightSel,self.ElElDileptonFakeExtrapolationSel)
OSMuMuDilepton = switch_on_index([0],op.rng_len(self.MuMuDileptonTightSel)>=1,self.MuMuDileptonTightSel,self.MuMuDileptonFakeExtrapolationSel)
OSElMuDilepton = switch_on_index([0],op.rng_len(self.ElMuDileptonTightSel)>=1,self.ElMuDileptonTightSel,self.ElMuDileptonFakeExtrapolationSel)
elif selectionType == "FakeExtrapolation":
OSElElDilepton = self.ElElDileptonFakeExtrapolationSel
OSMuMuDilepton = self.MuMuDileptonFakeExtrapolationSel
OSElMuDilepton = self.ElMuDileptonFakeExtrapolationSel
#----- Separate selections ------#
ElElSelObjectDilepton = selectionList[0]
MuMuSelObjectDilepton = selectionList[1]
ElMuSelObjectDilepton = selectionList[2]
#----- Channel and trigger plots -----#
if not self.args.OnlyYield:
ChannelDictList = []
ChannelDictList.append({'channel':'ElEl','sel':ElElSelObjectDilepton.sel,'suffix':ElElSelObjectDilepton.selName})
ChannelDictList.append({'channel':'MuMu','sel':MuMuSelObjectDilepton.sel,'suffix':MuMuSelObjectDilepton.selName})
ChannelDictList.append({'channel':'ElMu','sel':ElMuSelObjectDilepton.sel,'suffix':ElMuSelObjectDilepton.selName})
for channelDict in ChannelDictList:
#----- Trigger plots -----#
plots.extend(doubleLeptonTriggerPlots(**channelDict,triggerDict=self.triggersPerPrimaryDataset))
#----- Dilepton plots -----#
#plots.extend(doubleLeptonChannelPlot(**channelDict,DilepElEl=OSElElDilepton,DilepMuMu=OSMuMuDilepton,DilepElMu=OSElMuDilepton))
LeptonKeys = ['channel','sel','dilepton','suffix','is_MC']
JetKeys = ['channel','sel','leadjet','subleadjet','lead_is_b','sublead_is_b','suffix','is_MC']
commonItems = ['channel','sel','suffix']
#----- Ak4 jets selection -----#
if "Ak4" in jetsel_level:
print ("...... Processing Ak4 jet selection")
ElElSelObjectDileptonAk4Jets = makeAtLeastTwoAk4JetSelection(self,ElElSelObjectDilepton,copy_sel=True,plot_yield=True)
MuMuSelObjectDileptonAk4Jets = makeAtLeastTwoAk4JetSelection(self,MuMuSelObjectDilepton,copy_sel=True,plot_yield=True)
ElMuSelObjectDileptonAk4Jets = makeAtLeastTwoAk4JetSelection(self,ElMuSelObjectDilepton,copy_sel=True,plot_yield=True)
# Jet and lepton plots #
ChannelDictList = []
if "Ak4" in jetplot_level:
# Cut flow report #
cutFlowPlots.append(CutFlowReport(ElElSelObjectDileptonAk4Jets.selName,ElElSelObjectDileptonAk4Jets.sel))
cutFlowPlots.append(CutFlowReport(MuMuSelObjectDileptonAk4Jets.selName,MuMuSelObjectDileptonAk4Jets.sel))
cutFlowPlots.append(CutFlowReport(ElMuSelObjectDileptonAk4Jets.selName,ElMuSelObjectDileptonAk4Jets.sel))
if not self.args.OnlyYield:
ChannelDictList.append({'channel':'ElEl','sel':ElElSelObjectDileptonAk4Jets.sel,'dilepton':OSElElDilepton[0],'leadjet':self.ak4Jets[0],'subleadjet':self.ak4Jets[1],'lead_is_b':False,'sublead_is_b':False,'suffix':ElElSelObjectDileptonAk4Jets.selName,'is_MC':self.is_MC})
ChannelDictList.append({'channel':'MuMu','sel':MuMuSelObjectDileptonAk4Jets.sel,'dilepton':OSMuMuDilepton[0],'leadjet':self.ak4Jets[0],'subleadjet':self.ak4Jets[1],'lead_is_b':False,'sublead_is_b':False,'suffix':MuMuSelObjectDileptonAk4Jets.selName,'is_MC':self.is_MC})
ChannelDictList.append({'channel':'ElMu','sel':ElMuSelObjectDileptonAk4Jets.sel,'dilepton':OSElMuDilepton[0],'leadjet':self.ak4Jets[0],'subleadjet':self.ak4Jets[1],'lead_is_b':False,'sublead_is_b':False,'suffix':ElMuSelObjectDileptonAk4Jets.selName,'is_MC':self.is_MC})
JetsN = {'objName':'Ak4Jets','objCont':self.ak4Jets,'Nmax':15,'xTitle':'N(Ak4 jets)'}
for channelDict in ChannelDictList:
# Dilepton #
plots.extend(makeDileptonPlots(**{k:channelDict[k] for k in LeptonKeys}))
# Number of jets #
plots.append(objectsNumberPlot(**{k:channelDict[k] for k in commonItems},**JetsN))
# Ak4 Jets #
plots.extend(makeTwoAk4JetsPlots(**{k:channelDict[k] for k in JetKeys}))
# MET #
plots.extend(makeMETPlots(**{k:channelDict[k] for k in commonItems}, met=self.corrMET))
##### Ak8 jets selection #####
if "Ak8" in jetsel_level:
print ("...... Processing Ak8 jet selection")
ElElSelObjectDileptonAk8Jets = makeAtLeastOneAk8JetSelection(self,ElElSelObjectDilepton,copy_sel=True,plot_yield=True)
MuMuSelObjectDileptonAk8Jets = makeAtLeastOneAk8JetSelection(self,MuMuSelObjectDilepton,copy_sel=True,plot_yield=True)
ElMuSelObjectDileptonAk8Jets = makeAtLeastOneAk8JetSelection(self,ElMuSelObjectDilepton,copy_sel=True,plot_yield=True)
# Fatjets plots #
ChannelDictList = []
if "Ak8" in jetplot_level:
# Cut flow report #
cutFlowPlots.append(CutFlowReport(ElElSelObjectDileptonAk8Jets.selName,ElElSelObjectDileptonAk8Jets.sel))
cutFlowPlots.append(CutFlowReport(MuMuSelObjectDileptonAk8Jets.selName,MuMuSelObjectDileptonAk8Jets.sel))
cutFlowPlots.append(CutFlowReport(ElMuSelObjectDileptonAk8Jets.selName,ElMuSelObjectDileptonAk8Jets.sel))
if not self.args.OnlyYield:
ChannelDictList.append({'channel':'ElEl','sel':ElElSelObjectDileptonAk8Jets.sel,'dilepton':OSElElDilepton[0],'fatjet':self.ak8Jets[0],'suffix':ElElSelObjectDileptonAk8Jets.selName,'is_MC':self.is_MC})
ChannelDictList.append({'channel':'MuMu','sel':MuMuSelObjectDileptonAk8Jets.sel,'dilepton':OSMuMuDilepton[0],'fatjet':self.ak8Jets[0],'suffix':MuMuSelObjectDileptonAk8Jets.selName,'is_MC':self.is_MC})
ChannelDictList.append({'channel':'ElMu','sel':ElMuSelObjectDileptonAk8Jets.sel,'dilepton':OSElMuDilepton[0],'fatjet':self.ak8Jets[0],'suffix':ElMuSelObjectDileptonAk8Jets.selName,'is_MC':self.is_MC})
FatJetKeys = ['channel','sel','fatjet','suffix']
FatJetsN = {'objName':'Ak8Jets','objCont':self.ak8Jets,'Nmax':5,'xTitle':'N(Ak8 jets)'}
for channelDict in ChannelDictList:
# Dilepton #
plots.extend(makeDileptonPlots(**{k:channelDict[k] for k in LeptonKeys}))
# Number of jets #
plots.append(objectsNumberPlot(**{k:channelDict[k] for k in commonItems},**FatJetsN))
# Ak8 Jets #
plots.extend(makeDoubleLeptonAk8JetsPlots(**{k:channelDict[k] for k in FatJetKeys}))
# MET #
plots.extend(makeMETPlots(**{k:channelDict[k] for k in commonItems}, met=self.corrMET))
#----- Resolved selection -----#
if any(item in ["Resolved0Btag","Resolved1Btag","Resolved2Btag"] for item in jetsel_level): # If any of resolved category is asked
#----- select the jets -----#
aka4JetsByBtagScore = op.sort(self.ak4Jets, lambda jet : -jet.btagDeepFlavB)
container0b2j = [ t.Jet[self.ak4LightJetsByBtagScore[i].idx] for i in range(2) ]
container1b1j = [ t.Jet[op.switch(op.rng_len(self.ak4BJets) == 1, self.ak4BJets[0].idx, aka4JetsByBtagScore[0].idx)] ,
t.Jet[op.switch(op.rng_len(self.ak4BJets) == 1, self.ak4LightJetsByBtagScore[0].idx, aka4JetsByBtagScore[1].idx)]]
container2b0j = [ t.Jet[op.switch(op.rng_len(self.ak4BJets) >= 2, self.ak4BJets[i].idx, aka4JetsByBtagScore[i].idx)] for i in range(2) ]
ChannelDictList = []
#----- Resolved selection : 0 Btag -----#
if "Resolved0Btag" in jetsel_level:
print ("...... Processing Resolved jet (0 btag) selection")
ElElSelObjectDileptonAk4JetsExclusiveResolvedNoBtag = makeExclusiveResolvedNoBtagSelection(self,ElElSelObjectDileptonAk4Jets,copy_sel=True,plot_yield=True)
MuMuSelObjectDileptonAk4JetsExclusiveResolvedNoBtag = makeExclusiveResolvedNoBtagSelection(self,MuMuSelObjectDileptonAk4Jets,copy_sel=True,plot_yield=True)
ElMuSelObjectDileptonAk4JetsExclusiveResolvedNoBtag = makeExclusiveResolvedNoBtagSelection(self,ElMuSelObjectDileptonAk4Jets,copy_sel=True,plot_yield=True)
if "Resolved0Btag" in jetplot_level:
# Cut flow report #
cutFlowPlots.append(CutFlowReport(ElElSelObjectDileptonAk4JetsExclusiveResolvedNoBtag.selName,ElElSelObjectDileptonAk4JetsExclusiveResolvedNoBtag.sel))
cutFlowPlots.append(CutFlowReport(MuMuSelObjectDileptonAk4JetsExclusiveResolvedNoBtag.selName,MuMuSelObjectDileptonAk4JetsExclusiveResolvedNoBtag.sel))
cutFlowPlots.append(CutFlowReport(ElMuSelObjectDileptonAk4JetsExclusiveResolvedNoBtag.selName,ElMuSelObjectDileptonAk4JetsExclusiveResolvedNoBtag.sel))
if not self.args.OnlyYield:
ChannelDictList.append({'channel':'ElEl','sel':ElElSelObjectDileptonAk4JetsExclusiveResolvedNoBtag.sel,'dilepton':OSElElDilepton[0],'leadjet':container0b2j[0],'subleadjet':container0b2j[1],'lead_is_b':False,'sublead_is_b':False,'suffix':ElElSelObjectDileptonAk4JetsExclusiveResolvedNoBtag.selName,'is_MC':self.is_MC})
ChannelDictList.append({'channel':'MuMu','sel':MuMuSelObjectDileptonAk4JetsExclusiveResolvedNoBtag.sel,'dilepton':OSMuMuDilepton[0],'leadjet':container0b2j[0],'subleadjet':container0b2j[1],'lead_is_b':False,'sublead_is_b':False,'suffix':MuMuSelObjectDileptonAk4JetsExclusiveResolvedNoBtag.selName,'is_MC':self.is_MC})
ChannelDictList.append({'channel':'ElMu','sel':ElMuSelObjectDileptonAk4JetsExclusiveResolvedNoBtag.sel,'dilepton':OSElMuDilepton[0],'leadjet':container0b2j[0],'subleadjet':container0b2j[1],'lead_is_b':False,'sublead_is_b':False,'suffix':ElMuSelObjectDileptonAk4JetsExclusiveResolvedNoBtag.selName,'is_MC':self.is_MC})
#---- Resolved selection : 1 Btag -----#
if "Resolved1Btag" in jetsel_level:
print ("...... Processing Resolved jet (1 btag) selection")
ElElSelObjectDileptonAk4JetsExclusiveResolvedOneBtag = makeExclusiveResolvedOneBtagSelection(self,ElElSelObjectDileptonAk4Jets,copy_sel=True,plot_yield=True)
MuMuSelObjectDileptonAk4JetsExclusiveResolvedOneBtag = makeExclusiveResolvedOneBtagSelection(self,MuMuSelObjectDileptonAk4Jets,copy_sel=True,plot_yield=True)
ElMuSelObjectDileptonAk4JetsExclusiveResolvedOneBtag = makeExclusiveResolvedOneBtagSelection(self,ElMuSelObjectDileptonAk4Jets,copy_sel=True,plot_yield=True)
if "Resolved1Btag" in jetplot_level:
# Cut flow report #
cutFlowPlots.append(CutFlowReport(ElElSelObjectDileptonAk4JetsExclusiveResolvedOneBtag.selName,ElElSelObjectDileptonAk4JetsExclusiveResolvedOneBtag.sel))
cutFlowPlots.append(CutFlowReport(MuMuSelObjectDileptonAk4JetsExclusiveResolvedOneBtag.selName,MuMuSelObjectDileptonAk4JetsExclusiveResolvedOneBtag.sel))
cutFlowPlots.append(CutFlowReport(ElMuSelObjectDileptonAk4JetsExclusiveResolvedOneBtag.selName,ElMuSelObjectDileptonAk4JetsExclusiveResolvedOneBtag.sel))
if not self.args.OnlyYield:
ChannelDictList.append({'channel':'ElEl','sel':ElElSelObjectDileptonAk4JetsExclusiveResolvedOneBtag.sel,'dilepton':OSElElDilepton[0],'leadjet':container1b1j[0],'subleadjet':container1b1j[1],'lead_is_b':True,'sublead_is_b':False,'suffix':ElElSelObjectDileptonAk4JetsExclusiveResolvedOneBtag.selName,'is_MC':self.is_MC})
ChannelDictList.append({'channel':'MuMu','sel':MuMuSelObjectDileptonAk4JetsExclusiveResolvedOneBtag.sel,'dilepton':OSMuMuDilepton[0],'leadjet':container1b1j[0],'subleadjet':container1b1j[1],'lead_is_b':True,'sublead_is_b':False,'suffix':MuMuSelObjectDileptonAk4JetsExclusiveResolvedOneBtag.selName,'is_MC':self.is_MC})
ChannelDictList.append({'channel':'ElMu','sel':ElMuSelObjectDileptonAk4JetsExclusiveResolvedOneBtag.sel,'dilepton':OSElMuDilepton[0],'leadjet':container1b1j[0],'subleadjet':container1b1j[1],'lead_is_b':True,'sublead_is_b':False,'suffix':ElMuSelObjectDileptonAk4JetsExclusiveResolvedOneBtag.selName,'is_MC':self.is_MC})
#----- Resolved selection : 2 Btags -----#
if "Resolved2Btag" in jetsel_level:
print ("...... Processing Resolved jet (2 btags) selection")
ElElSelObjectDileptonAk4JetsExclusiveResolvedTwoBtags = makeExclusiveResolvedTwoBtagsSelection(self,ElElSelObjectDileptonAk4Jets,copy_sel=True,plot_yield=True)
MuMuSelObjectDileptonAk4JetsExclusiveResolvedTwoBtags = makeExclusiveResolvedTwoBtagsSelection(self,MuMuSelObjectDileptonAk4Jets,copy_sel=True,plot_yield=True)
ElMuSelObjectDileptonAk4JetsExclusiveResolvedTwoBtags = makeExclusiveResolvedTwoBtagsSelection(self,ElMuSelObjectDileptonAk4Jets,copy_sel=True,plot_yield=True)
if "Resolved2Btag" in jetplot_level:
# Cut flow report #
cutFlowPlots.append(CutFlowReport(ElElSelObjectDileptonAk4JetsExclusiveResolvedTwoBtags.selName,ElElSelObjectDileptonAk4JetsExclusiveResolvedTwoBtags.sel))
cutFlowPlots.append(CutFlowReport(MuMuSelObjectDileptonAk4JetsExclusiveResolvedTwoBtags.selName,MuMuSelObjectDileptonAk4JetsExclusiveResolvedTwoBtags.sel))
cutFlowPlots.append(CutFlowReport(ElMuSelObjectDileptonAk4JetsExclusiveResolvedTwoBtags.selName,ElMuSelObjectDileptonAk4JetsExclusiveResolvedTwoBtags.sel))
if not self.args.OnlyYield:
ChannelDictList.append({'channel':'ElEl','sel':ElElSelObjectDileptonAk4JetsExclusiveResolvedTwoBtags.sel,'dilepton':OSElElDilepton[0],'leadjet':container2b0j[0],'subleadjet':container2b0j[1],'lead_is_b':True,'sublead_is_b':True,'suffix':ElElSelObjectDileptonAk4JetsExclusiveResolvedTwoBtags.selName,'is_MC':self.is_MC})
ChannelDictList.append({'channel':'MuMu','sel':MuMuSelObjectDileptonAk4JetsExclusiveResolvedTwoBtags.sel,'dilepton':OSMuMuDilepton[0],'leadjet':container2b0j[0],'subleadjet':container2b0j[1],'lead_is_b':True,'sublead_is_b':True,'suffix':MuMuSelObjectDileptonAk4JetsExclusiveResolvedTwoBtags.selName,'is_MC':self.is_MC})
ChannelDictList.append({'channel':'ElMu','sel':ElMuSelObjectDileptonAk4JetsExclusiveResolvedTwoBtags.sel,'dilepton':OSElMuDilepton[0],'leadjet':container2b0j[0],'subleadjet':container2b0j[1],'lead_is_b':True,'sublead_is_b':True,'suffix':ElMuSelObjectDileptonAk4JetsExclusiveResolvedTwoBtags.selName,'is_MC':self.is_MC})
# Lepton + jet Plots #
ResolvedJetsN = {'objName':'Ak4BJets','objCont':self.ak4BJets,'Nmax':5,'xTitle':'N(Ak4 Bjets)'}
for channelDict in ChannelDictList:
# Dilepton #
plots.extend(makeDileptonPlots(**{k:channelDict[k] for k in LeptonKeys}))
# Number of jets #
plots.append(objectsNumberPlot(**{k:channelDict[k] for k in commonItems},**ResolvedJetsN))
plots.append(objectsNumberPlot(**{k:channelDict[k] for k in commonItems},**JetsN))
# Ak4 Jets #
plots.extend(makeTwoAk4JetsPlots(**{k:channelDict[k] for k in JetKeys}))
# MET #
plots.extend(makeMETPlots(**{k:channelDict[k] for k in commonItems}, met=self.corrMET))
#----- Boosted selection -----#
if "Boosted" in jetsel_level:
print ("...... Processing Boosted jet selection")
ElElSelObjectDileptonAk8JetsInclusiveBoosted = makeInclusiveBoostedSelection(self,ElElSelObjectDileptonAk8Jets,copy_sel=True,plot_yield=True)
MuMuSelObjectDileptonAk8JetsInclusiveBoosted = makeInclusiveBoostedSelection(self,MuMuSelObjectDileptonAk8Jets,copy_sel=True,plot_yield=True)
ElMuSelObjectDileptonAk8JetsInclusiveBoosted = makeInclusiveBoostedSelection(self,ElMuSelObjectDileptonAk8Jets,copy_sel=True,plot_yield=True)
# Lepton + jet Plots #
ChannelDictList = []
if "Boosted" in jetplot_level:
# Cut flow report #
cutFlowPlots.append(CutFlowReport(ElElSelObjectDileptonAk8JetsInclusiveBoosted.selName,ElElSelObjectDileptonAk8JetsInclusiveBoosted.sel))
cutFlowPlots.append(CutFlowReport(MuMuSelObjectDileptonAk8JetsInclusiveBoosted.selName,MuMuSelObjectDileptonAk8JetsInclusiveBoosted.sel))
cutFlowPlots.append(CutFlowReport(ElMuSelObjectDileptonAk8JetsInclusiveBoosted.selName,ElMuSelObjectDileptonAk8JetsInclusiveBoosted.sel))
if not self.args.OnlyYield:
ChannelDictList.append({'channel':'ElEl','sel':ElElSelObjectDileptonAk8JetsInclusiveBoosted.sel,'dilepton':OSElElDilepton[0],'fatjet':self.ak8BJets[0],'suffix':ElElSelObjectDileptonAk8JetsInclusiveBoosted.selName,'is_MC':self.is_MC})
ChannelDictList.append({'channel':'MuMu','sel':MuMuSelObjectDileptonAk8JetsInclusiveBoosted.sel,'dilepton':OSMuMuDilepton[0],'fatjet':self.ak8BJets[0],'suffix':MuMuSelObjectDileptonAk8JetsInclusiveBoosted.selName,'is_MC':self.is_MC})
ChannelDictList.append({'channel':'ElMu','sel':ElMuSelObjectDileptonAk8JetsInclusiveBoosted.sel,'dilepton':OSElMuDilepton[0],'fatjet':self.ak8BJets[0],'suffix':ElMuSelObjectDileptonAk8JetsInclusiveBoosted.selName,'is_MC':self.is_MC})
BoostedJetsN = {'objName':'Ak8BJets','objCont':self.ak8BJets,'Nmax':5,'xTitle':'N(Ak8 Bjets)'}
for channelDict in ChannelDictList:
# Dilepton #
plots.extend(makeDileptonPlots(**{k:channelDict[k] for k in LeptonKeys}))
# Number of jets #
plots.append(objectsNumberPlot(**{k:channelDict[k] for k in commonItems},**BoostedJetsN))
plots.append(objectsNumberPlot(**{k:channelDict[k] for k in commonItems},**FatJetsN))
# Ak8 Jets #
plots.extend(makeDoubleLeptonAk8JetsPlots(**{k:channelDict[k] for k in FatJetKeys}))
# MET #
plots.extend(makeMETPlots(**{k:channelDict[k] for k in commonItems}, met=self.corrMET))
#----- High-level combinations -----#
# NOTE : very time consuming
ChannelDictList = []
if not self.args.OnlyYield:
# Resolved No Btag #
if "Resolved0Btag" in jetplot_level:
ChannelDictList.append({'channel': 'ElEl','met': self.corrMET,'l1':OSElElDilepton[0][0],'l2':OSElElDilepton[0][1],'j1':container0b2j[0],'j2':container0b2j[1],'sel':ElElSelObjectDileptonAk4JetsExclusiveResolvedNoBtag.sel,'suffix':ElElSelObjectDileptonAk4JetsExclusiveResolvedNoBtag.selName})
ChannelDictList.append({'channel': 'MuMu','met': self.corrMET,'l1':OSMuMuDilepton[0][0],'l2':OSMuMuDilepton[0][1],'j1':container0b2j[0],'j2':container0b2j[1],'sel':MuMuSelObjectDileptonAk4JetsExclusiveResolvedNoBtag.sel,'suffix':MuMuSelObjectDileptonAk4JetsExclusiveResolvedNoBtag.selName})
ChannelDictList.append({'channel': 'ElMu','met': self.corrMET,'l1':OSElMuDilepton[0][0],'l2':OSElMuDilepton[0][1],'j1':container0b2j[0],'j2':container0b2j[1],'sel':ElMuSelObjectDileptonAk4JetsExclusiveResolvedNoBtag.sel,'suffix':ElMuSelObjectDileptonAk4JetsExclusiveResolvedNoBtag.selName})
# Resolved One Btag #
if "Resolved1Btag" in jetplot_level:
ChannelDictList.append({'channel': 'ElEl','met': self.corrMET,'l1':OSElElDilepton[0][0],'l2':OSElElDilepton[0][1],'j1':container1b1j[0],'j2':container1b1j[1],'sel':ElElSelObjectDileptonAk4JetsExclusiveResolvedOneBtag.sel,'suffix':ElElSelObjectDileptonAk4JetsExclusiveResolvedOneBtag.selName})
ChannelDictList.append({'channel': 'MuMu','met': self.corrMET,'l1':OSMuMuDilepton[0][0],'l2':OSMuMuDilepton[0][1],'j1':container1b1j[0],'j2':container1b1j[1],'sel':MuMuSelObjectDileptonAk4JetsExclusiveResolvedOneBtag.sel,'suffix':MuMuSelObjectDileptonAk4JetsExclusiveResolvedOneBtag.selName})
ChannelDictList.append({'channel': 'ElMu','met': self.corrMET,'l1':OSElMuDilepton[0][0],'l2':OSElMuDilepton[0][1],'j1':container1b1j[0],'j2':container1b1j[1],'sel':ElMuSelObjectDileptonAk4JetsExclusiveResolvedOneBtag.sel,'suffix':ElMuSelObjectDileptonAk4JetsExclusiveResolvedOneBtag.selName})
# Resolved Two Btags #
if "Resolved2Btag" in jetplot_level:
ChannelDictList.append({'channel': 'ElEl','met': self.corrMET,'l1':OSElElDilepton[0][0],'l2':OSElElDilepton[0][1],'j1':container2b0j[0],'j2':container2b0j[1],'sel':ElElSelObjectDileptonAk4JetsExclusiveResolvedTwoBtags.sel,'suffix':ElElSelObjectDileptonAk4JetsExclusiveResolvedTwoBtags.selName})
ChannelDictList.append({'channel': 'MuMu','met': self.corrMET,'l1':OSMuMuDilepton[0][0],'l2':OSMuMuDilepton[0][1],'j1':container2b0j[0],'j2':container2b0j[1],'sel':MuMuSelObjectDileptonAk4JetsExclusiveResolvedTwoBtags.sel,'suffix':MuMuSelObjectDileptonAk4JetsExclusiveResolvedTwoBtags.selName})
ChannelDictList.append({'channel': 'ElMu','met': self.corrMET,'l1':OSElMuDilepton[0][0],'l2':OSElMuDilepton[0][1],'j1':container2b0j[0],'j2':container2b0j[1],'sel':ElMuSelObjectDileptonAk4JetsExclusiveResolvedTwoBtags.sel,'suffix':ElMuSelObjectDileptonAk4JetsExclusiveResolvedTwoBtags.selName})
# Boosted #
if "Boosted" in jetplot_level:
ChannelDictList.append({'channel': 'ElEl','met': self.corrMET,'l1':OSElElDilepton[0][0],'l2':OSElElDilepton[0][1],'j1':self.ak8BJets[0].subJet1,'j2':self.ak8BJets[0].subJet2,'sel':ElElSelObjectDileptonAk8JetsInclusiveBoosted.sel,'suffix':ElElSelObjectDileptonAk8JetsInclusiveBoosted.selName})
ChannelDictList.append({'channel': 'MuMu','met': self.corrMET,'l1':OSMuMuDilepton[0][0],'l2':OSMuMuDilepton[0][1],'j1':self.ak8BJets[0].subJet1,'j2':self.ak8BJets[0].subJet2,'sel':MuMuSelObjectDileptonAk8JetsInclusiveBoosted.sel,'suffix':MuMuSelObjectDileptonAk8JetsInclusiveBoosted.selName})
ChannelDictList.append({'channel': 'ElMu','met': self.corrMET,'l1':OSElMuDilepton[0][0],'l2':OSElMuDilepton[0][1],'j1':self.ak8BJets[0].subJet1,'j2':self.ak8BJets[0].subJet2,'sel':ElMuSelObjectDileptonAk8JetsInclusiveBoosted.sel,'suffix':ElMuSelObjectDileptonAk8JetsInclusiveBoosted.selName})
for channelDict in ChannelDictList:
plots.extend(makeDoubleLeptonHighLevelQuantities(**channelDict,HLL=self.HLL))
#----- Machine Learning plots -----#
selObjectDictList = []
if not self.args.OnlyYield:
if "Ak4" in jetplot_level:
selObjectDictList.append({'channel':'ElEl','selObject':ElElSelObjectDileptonAk4Jets})
selObjectDictList.append({'channel':'MuMu','selObject':MuMuSelObjectDileptonAk4Jets})
selObjectDictList.append({'channel':'ElMu','selObject':ElMuSelObjectDileptonAk4Jets})
# if "Ak8" in jetplot_level:
# selObjectDictList.append({'channel':'ElEl','selObject':ElElSelObjectDileptonAk8Jets})
# selObjectDictList.append({'channel':'MuMu','selObject':MuMuSelObjectDileptonAk8Jets})
# selObjectDictList.append({'channel':'ElMu','selObject':ElMuSelObjectDileptonAk8Jets})
if "Resolved0Btag" in jetplot_level:
selObjectDictList.append({'channel':'ElEl','selObject':ElElSelObjectDileptonAk4JetsExclusiveResolvedNoBtag})
selObjectDictList.append({'channel':'MuMu','selObject':MuMuSelObjectDileptonAk4JetsExclusiveResolvedNoBtag})
selObjectDictList.append({'channel':'ElMu','selObject':ElMuSelObjectDileptonAk4JetsExclusiveResolvedNoBtag})
if "Resolved1Btag" in jetplot_level:
selObjectDictList.append({'channel':'ElEl','selObject':ElElSelObjectDileptonAk4JetsExclusiveResolvedOneBtag})
selObjectDictList.append({'channel':'MuMu','selObject':MuMuSelObjectDileptonAk4JetsExclusiveResolvedOneBtag})
selObjectDictList.append({'channel':'ElMu','selObject':ElMuSelObjectDileptonAk4JetsExclusiveResolvedOneBtag})
if "Resolved2Btag" in jetplot_level:
selObjectDictList.append({'channel':'ElEl','selObject':ElElSelObjectDileptonAk4JetsExclusiveResolvedTwoBtags})
selObjectDictList.append({'channel':'MuMu','selObject':MuMuSelObjectDileptonAk4JetsExclusiveResolvedTwoBtags})
selObjectDictList.append({'channel':'ElMu','selObject':ElMuSelObjectDileptonAk4JetsExclusiveResolvedTwoBtags})
# if "Boosted" in jetplot_level:
# selObjectDictList.append({'channel':'ElEl','selObject':ElElSelObjectDileptonAk8JetsInclusiveBoosted})
# selObjectDictList.append({'channel':'MuMu','selObject':MuMuSelObjectDileptonAk8JetsInclusiveBoosted})
# selObjectDictList.append({'channel':'ElMu','selObject':ElMuSelObjectDileptonAk8JetsInclusiveBoosted})
dileptons = {'ElEl':OSElElDilepton[0],'MuMu':OSMuMuDilepton[0],'ElMu':OSElMuDilepton[0]}
for selObjectDict in selObjectDictList:
dilepton = dileptons[selObjectDict['channel']]
plots.extend(makeDoubleLeptonMachineLearningPlots(channel=selObjectDict['channel'],l1=dilepton[0],l2=dilepton[1],jets=self.ak4Jets,sel=selObjectDict['selObject'].sel,suffix=selObjectDict['selObject'].selName,model=LBN))
#----- Add the Yield plots -----#
plots.extend(self.yieldPlots.returnPlots())
#plots.extend(cutFlowPlots)
#----- Return -----#
return plots
def switch_on_index(indexes, condition, contA, contB):
if contA._base != contB._base:
raise RuntimeError("The containers do not derive from the same base, this won't work")
base = contA._base
return [base[op.switch(condition, contA[index].idx, contB[index].idx)] for index in indexes]
def defineSkimSelection(self, t, noSel, sample=None, sampleCfg=None):
noSel = super(SkimmerNanoHHtobbWWSL,
self).prepareObjects(t,
noSel,
sample,
sampleCfg,
"SL",
forSkimmer=True)
# For the Skimmer, SF must not use defineOnFirstUse -> segmentation fault
era = sampleCfg['era']
# Initialize varsToKeep dict #
varsToKeep = dict()
#---------------------------------------------------------------------------------------#
# Selections #
#---------------------------------------------------------------------------------------#
# keep the exact same order of nodes as mentioned in respective JPA model xml files
ResolvedJPANodeList = [
'2b2Wj', '2b1Wj', '1b2Wj', '2b0Wj', '1b1Wj', '1b0Wj', '0b'
]
BoostedJPANodeList = ['Hbb2Wj', 'Hbb1Wj', 'Hbb0Wj']
# JPA Models
basepath = os.path.join(os.path.abspath(os.path.dirname(__file__)),
'MachineLearning', 'ml-models',
'JPA_Loose_ttH')
resolvedModelDict = getResolvedJpaModelDict(basepath,
ResolvedJPANodeList, era)
boostedModelDict = getBoostedJpaModelDict(basepath, BoostedJPANodeList,
era)
if not self.inclusive_sel:
#----- Check arguments -----#
jet_level = [
"Ak4", "Ak8", "Res2b2Wj", "Res2b1Wj", "Res2b0Wj", "Res1b2Wj",
"Res1b1Wj", "Res1b0Wj", "Res0b", "Hbb2Wj", "Hbb1Wj", "Hbb0Wj"
]
if [
boolean for (level, boolean) in self.args.__dict__.items()
if level in jet_level
].count(True) != 1:
raise RuntimeError(
"Only one of the jet arguments must be used, check --help")
if self.args.Channel not in ["El", "Mu"]:
raise RuntimeError("Channel must be either 'El' or 'Mu'")
#----- Lepton selection -----#
ElSelObj, MuSelObj = makeSingleLeptonSelection(
self, noSel, use_dd=False, fake_selection=self.args.FakeCR)
if self.args.Channel is None:
raise RuntimeError("You need to specify --Channel")
if self.args.Channel == "El":
selObj = ElSelObj
lep = self.electronsTightSel[0]
if self.args.Channel == "Mu":
selObj = MuSelObj
lep = self.muonsTightSel[0]
#----- Apply jet corrections -----#
ElSelObject.sel = self.beforeJetselection(ElSelObj.sel, 'El')
MuSelObject.sel = self.beforeJetselection(MuSelObj.sel, 'Mu')
#----- Jet selection -----#
if any([
self.args.__dict__[item] for item in [
"Ak4", "Res2b2Wj", "Res2b1Wj", "Res2b0Wj", "Res1b2Wj",
"Res1b1Wj", "Res1b0Wj", "Res0b"
]
]):
makeResolvedSelection(self, selObj)
if self.args.Channel == "El":
print('... Resolved :: El Channel')
L1out, L2out, selObjAndJetsPerJpaCatDict = findJPACategoryResolved(
self,
selObj,
lep,
self.muonsPreSel,
self.electronsPreSel,
self.ak4Jets,
self.ak4BJetsLoose,
self.ak4BJets,
self.corrMET,
resolvedModelDict,
t.event,
self.HLL,
ResolvedJPANodeList,
plot_yield=False)
if self.args.Channel == "Mu":
print('... Resolved :: Mu Channel')
L1out, L2out, selObjAndJetsPerJpaCatDict = findJPACategoryResolved(
self,
selObj,
lep,
self.muonsPreSel,
self.electronsPreSel,
self.ak4Jets,
self.ak4BJetsLoose,
self.ak4BJets,
self.corrMET,
resolvedModelDict,
t.event,
self.HLL,
ResolvedJPANodeList,
plot_yield=False)
if any([
self.args.__dict__[item]
for item in ["Ak8", "Hbb2Wj", "Hbb1Wj", "Hbb0Wj"]
]):
makeBoostedSelection(self, selObj)
if self.args.Channel == "El":
print('... Boosted :: El Channel')
L1out, L2out, selObjAndJetsPerJpaCatDict = findJPACategoryBoosted(
self,
selObj,
lep,
self.muonsPreSel,
self.electronsPreSel,
self.ak8BJets,
self.ak4JetsCleanedFromAk8b,
self.ak4BJetsLoose,
self.ak4BJets,
self.corrMET,
boostedModelDict,
t.event,
self.HLL,
BoostedJPANodeList,
plot_yield=False)
if self.args.Channel == "Mu":
print('... Boosted :: Mu Channel')
L1out, L2out, selObjAndJetsPerJpaCatDict = findJPACategoryBoosted(
self,
selObj,
lep,
self.muonsPreSel,
self.electronsPreSel,
self.ak8BJets,
self.ak4JetsCleanedFromAk8b,
self.ak4BJetsLoose,
self.ak4BJets,
self.corrMET,
boostedModelDict,
t.event,
self.HLL,
BoostedJPANodeList,
plot_yield=False)
if self.args.Res2b2Wj:
print("...... 2b2Wj")
selObj = selObjAndJetsPerJpaCatDict.get('2b2Wj')[0]
jpaJets = selObjAndJetsPerJpaCatDict.get('2b2Wj')[1]
jpaarg = "Res2b2Wj"
if self.args.Res2b1Wj:
print("...... 2b1Wj")
selObj = selObjAndJetsPerJpaCatDict.get('2b1Wj')[0]
jpaJets = selObjAndJetsPerJpaCatDict.get('2b1Wj')[1]
jpaarg = "Res2b1Wj"
if self.args.Res1b2Wj:
print("...... 1b2Wj")
selObj = selObjAndJetsPerJpaCatDict.get('1b2Wj')[0]
jpaJets = selObjAndJetsPerJpaCatDict.get('1b2Wj')[1]
jpaarg = "Res1b2Wj"
if self.args.Res2b0Wj:
print("...... 2b0Wj")
selObj = selObjAndJetsPerJpaCatDict.get('2b0Wj')[0]
jpaJets = selObjAndJetsPerJpaCatDict.get('2b0Wj')[1]
jpaarg = "Res2b0Wj"
if self.args.Res1b1Wj:
print("...... 1b1Wj")
selObj = selObjAndJetsPerJpaCatDict.get('1b1Wj')[0]
jpaJets = selObjAndJetsPerJpaCatDict.get('1b1Wj')[1]
jpaarg = "Res1b1Wj"
if self.args.Res1b0Wj:
print("...... 1b0Wj")
selObj = selObjAndJetsPerJpaCatDict.get('1b0Wj')[0]
jpaJets = selObjAndJetsPerJpaCatDict.get('1b0Wj')[1]
jpaarg = "Res1b0Wj"
if self.args.Res0b:
print("...... 0b")
selObj = selObjAndJetsPerJpaCatDict.get('0b')[0]
jpaJets = None
jpaarg = "Res0b"
#######################################
# Hbb2Wj : jet1 jet2 jet3 jet4
# Hbb1Wj : jet1 jet2 jet3 jet4=0
# Hbb0Wj : jet1 jet2 jet3=0 jet4=0
#######################################
if self.args.Hbb2Wj:
print("...... Hbb2Wj")
selObj = selObjAndJetsPerJpaCatDict.get('Hbb2Wj')[0]
jpaJets = selObjAndJetsPerJpaCatDict.get('Hbb2Wj')[1]
jpaarg = "Hbb2Wj"
if self.args.Hbb1Wj:
print("...... Hbb1Wj")
selObj = selObjAndJetsPerJpaCatDict.get('Hbb1Wj')[0]
jpaJets = selObjAndJetsPerJpaCatDict.get('Hbb1Wj')[1]
jpaarg = "Hbb1Wj"
if self.args.Hbb0Wj:
print("...... Hbb0Wj")
selObj = selObjAndJetsPerJpaCatDict.get('Hbb0Wj')[0]
jpaJets = None
jpaarg = "Hbb0Wj"
else:
noSel = self.beforeJetselection(noSel)
#---------------------------------------------------------------------------------------#
# Synchronization tree #
#---------------------------------------------------------------------------------------#
if self.args.Synchronization:
# Event variables #
varsToKeep["event"] = None # Already in tree
varsToKeep["run"] = None # Already in tree
varsToKeep["ls"] = t.luminosityBlock
varsToKeep["n_presel_mu"] = op.static_cast(
"UInt_t", op.rng_len(self.muonsPreSel))
varsToKeep["n_fakeablesel_mu"] = op.static_cast(
"UInt_t", op.rng_len(self.muonsFakeSel))
varsToKeep["n_mvasel_mu"] = op.static_cast(
"UInt_t", op.rng_len(self.muonsTightSel))
varsToKeep["n_presel_ele"] = op.static_cast(
"UInt_t", op.rng_len(self.electronsPreSel))
varsToKeep["n_fakeablesel_ele"] = op.static_cast(
"UInt_t", op.rng_len(self.electronsFakeSel))
varsToKeep["n_mvasel_ele"] = op.static_cast(
"UInt_t", op.rng_len(self.electronsTightSel))
varsToKeep["n_presel_ak4Jet"] = op.static_cast(
"UInt_t", op.rng_len(self.ak4Jets))
varsToKeep["n_presel_ak8Jet"] = op.static_cast(
"UInt_t", op.rng_len(self.ak8Jets))
varsToKeep["n_presel_ak8BJet"] = op.static_cast(
"UInt_t", op.rng_len(self.ak8BJets))
varsToKeep["n_loose_ak4BJet"] = op.static_cast(
"UInt_t", op.rng_len(self.ak4BJetsLoose))
varsToKeep["n_medium_ak4BJet"] = op.static_cast(
"UInt_t", op.rng_len(self.ak4BJets))
varsToKeep["n_ak4JetsCleanAk8b"] = op.static_cast(
"UInt_t", op.rng_len(self.ak4JetsCleanedFromAk8b))
varsToKeep["n_presel_ak4JetVBF"] = op.static_cast(
"UInt_t", op.rng_len(self.VBFJetsPreSel))
varsToKeep["is_SR"] = op.static_cast(
"UInt_t",
op.OR(
op.rng_len(self.electronsTightSel) == 1,
op.rng_len(self.muonsTightSel) == 1))
varsToKeep["is_e"] = op.c_float(
True) if self.args.Channel == 'El' else op.c_float(False)
varsToKeep["is_m"] = op.c_float(
False) if self.args.Channel == 'El' else op.c_float(True)
varsToKeep["is_resolved"] = op.switch(
op.AND(
op.rng_len(self.ak4Jets) >= 3,
op.rng_len(self.ak4BJets) >= 1,
op.rng_len(self.ak8BJets) == 0), op.c_bool(True),
op.c_bool(False))
varsToKeep["is_boosted"] = op.switch(
op.AND(
op.rng_len(self.ak8BJets) >= 1,
op.rng_len(self.ak4JetsCleanedFromAk8b) >= 1),
op.c_bool(True), op.c_bool(False))
varsToKeep["n_tau"] = op.static_cast("UInt_t",
op.rng_len(self.tauCleanSel))
varsToKeep['resolved_tag'] = op.static_cast(
"UInt_t",
op.AND(
op.rng_len(self.ak4Jets) >= 3,
op.rng_len(self.ak4BJets) >= 1,
op.rng_len(self.ak8BJets) == 0))
varsToKeep['boosted_tag'] = op.static_cast(
"UInt_t",
op.AND(
op.rng_len(self.ak8BJets) >= 1,
op.rng_len(self.ak4JetsCleanedFromAk8b) >= 1))
# Triggers #
'''
varsToKeep["triggers"] = self.triggers
varsToKeep["triggers_SingleElectron"] = op.OR(*self.triggersPerPrimaryDataset['SingleElectron'])
varsToKeep["triggers_SingleMuon"] = op.OR(*self.triggersPerPrimaryDataset['SingleMuon'])
varsToKeep["triggers_DoubleElectron"] = op.OR(*self.triggersPerPrimaryDataset['DoubleEGamma'])
varsToKeep["triggers_DoubleMuon"] = op.OR(*self.triggersPerPrimaryDataset['DoubleMuon'])
varsToKeep["triggers_MuonElectron"] = op.OR(*self.triggersPerPrimaryDataset['MuonEG'])
'''
# Muons #
for i in range(1, 3): # 2 leading muons
varsToKeep["mu{}_pt".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].pt, op.c_float(-9999., "float"))
varsToKeep["mu{}_eta".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].eta, op.c_float(-9999.))
varsToKeep["mu{}_phi".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].phi, op.c_float(-9999.))
varsToKeep["mu{}_E".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].p4.E(),
op.c_float(-9999., "float"))
varsToKeep["mu{}_charge".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].charge, op.c_int(-9999.))
varsToKeep["mu{}_conept".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muon_conept[self.muonsPreSel[i - 1].idx],
op.c_float(-9999.))
varsToKeep["mu{}_miniRelIso".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].miniPFRelIso_all,
op.c_float(-9999.))
varsToKeep["mu{}_PFRelIso04".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].pfRelIso04_all, op.c_float(-9999.))
varsToKeep["mu{}_jetNDauChargedMVASel".format(i)] = op.c_float(
-9999.)
varsToKeep["mu{}_jetPtRel".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].jetPtRelv2, op.c_float(-9999.))
varsToKeep["mu{}_jetRelIso".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].jetRelIso, op.c_float(-9999.))
varsToKeep["mu{}_jetDeepJet".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].jet.btagDeepFlavB,
op.c_float(-9999.))
varsToKeep["mu{}_sip3D".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].sip3d, op.c_float(-9999.))
varsToKeep["mu{}_dxy".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].dxy, op.c_float(-9999.))
varsToKeep["mu{}_dxyAbs".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
op.abs(self.muonsPreSel[i - 1].dxy), op.c_float(-9999.))
varsToKeep["mu{}_dz".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].dz, op.c_float(-9999.))
varsToKeep["mu{}_segmentCompatibility".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].segmentComp, op.c_float(-9999.))
varsToKeep["mu{}_leptonMVA".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].mvaTTH, op.c_float(-9999.))
varsToKeep["mu{}_mediumID".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].mediumId,
op.c_float(-9999., "Bool_t"))
varsToKeep["mu{}_dpt_div_pt".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].tunepRelPt,
op.c_float(-9999.)) # Not sure
varsToKeep["mu{}_isfakeablesel".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
op.switch(self.lambda_muonFakeSel(self.muonsPreSel[i - 1]),
op.c_int(1), op.c_int(0)), op.c_int(-9999))
varsToKeep["mu{}_ismvasel".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
op.switch(
op.AND(
self.lambda_muonTightSel(self.muonsPreSel[i - 1]),
self.lambda_muonFakeSel(self.muonsPreSel[i - 1])),
op.c_int(1), op.c_int(0)),
op.c_int(-9999)) # mvasel encompasses fakeablesel
varsToKeep["mu{}_isGenMatched".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
op.switch(self.lambda_is_matched(self.muonsPreSel[i - 1]),
op.c_int(1), op.c_int(0)), op.c_int(-9999))
varsToKeep["mu{}_genPartFlav".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].genPartFlav, op.c_int(-9999))
varsToKeep["mu{}_FR".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.lambda_FR_mu(self.muonsPreSel[i - 1]),
op.c_int(-9999))
varsToKeep["mu{}_FRcorr".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.lambda_FRcorr_mu(self.muonsPreSel[i - 1]),
op.c_int(-9999))
varsToKeep["mu{}_FF".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.lambda_FF_mu(self.muonsPreSel[i - 1]),
op.c_int(-9999))
varsToKeep["mu{}_looseSF".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
reduce(mul,
self.lambda_MuonLooseSF(self.muonsPreSel[i - 1])),
op.c_int(-9999))
varsToKeep["mu{}_tightSF".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
reduce(mul,
self.lambda_MuonTightSF(self.muonsPreSel[i - 1])),
op.c_int(-9999))
# Electrons #
for i in range(1, 3): # 2 leading electrons
varsToKeep["ele{}_pt".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].pt, op.c_float(-9999.))
varsToKeep["ele{}_eta".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].eta, op.c_float(-9999.))
varsToKeep["ele{}_phi".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].phi, op.c_float(-9999.))
varsToKeep["ele{}_E".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].p4.E(), op.c_float(-9999., ))
varsToKeep["ele{}_charge".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].charge, op.c_int(-9999.))
varsToKeep["ele{}_conept".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electron_conept[self.electronsPreSel[i - 1].idx],
op.c_float(-9999.))
varsToKeep["ele{}_miniRelIso".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].miniPFRelIso_all,
op.c_float(-9999.))
varsToKeep["ele{}_PFRelIso03".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].pfRelIso03_all,
op.c_float(-9999.)) # Iso03, Iso04 not in NanoAOD
varsToKeep["ele{}_jetNDauChargedMVASel".format(
i)] = op.c_float(-9999.)
varsToKeep["ele{}_jetPtRel".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].jetPtRelv2, op.c_float(-9999.))
varsToKeep["ele{}_jetRelIso".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].jetRelIso, op.c_float(-9999.))
varsToKeep["ele{}_jetDeepJet".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].jet.btagDeepFlavB,
op.c_float(-9999.))
varsToKeep["ele{}_sip3D".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].sip3d, op.c_float(-9999.))
varsToKeep["ele{}_dxy".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].dxy, op.c_float(-9999.))
varsToKeep["ele{}_dxyAbs".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
op.abs(self.electronsPreSel[i - 1].dxy),
op.c_float(-9999.))
varsToKeep["ele{}_dz".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].dz, op.c_float(-9999.))
varsToKeep["ele{}_ntMVAeleID".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].mvaFall17V2noIso,
op.c_float(-9999.))
varsToKeep["ele{}_leptonMVA".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].mvaTTH, op.c_float(-9999.))
varsToKeep["ele{}_passesConversionVeto".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].convVeto,
op.c_float(-9999., "Bool_t"))
varsToKeep["ele{}_nMissingHits".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].lostHits,
op.c_float(-9999., "UChar_t"))
varsToKeep["ele{}_sigmaEtaEta".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].sieie, op.c_float(-9999.))
varsToKeep["ele{}_HoE".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].hoe, op.c_float(-9999.))
varsToKeep["ele{}_OoEminusOoP".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].eInvMinusPInv,
op.c_float(-9999.))
varsToKeep["ele{}_isfakeablesel".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
op.switch(
self.lambda_electronFakeSel(self.electronsPreSel[i -
1]),
op.c_int(1), op.c_int(0)), op.c_int(-9999))
varsToKeep["ele{}_ismvasel".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
op.switch(
op.AND(
self.lambda_electronTightSel(
self.electronsPreSel[i - 1]),
self.lambda_electronFakeSel(
self.electronsPreSel[i - 1])), op.c_int(1),
op.c_int(0)),
op.c_int(-9999)) # mvasel encompasses fakeablesel
varsToKeep["ele{}_isGenMatched".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
op.switch(
self.lambda_is_matched(self.electronsPreSel[i - 1]),
op.c_int(1), op.c_int(0)), op.c_int(-9999))
varsToKeep["ele{}_genPartFlav".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].genPartFlav, op.c_int(-9999))
varsToKeep["ele{}_deltaEtaSC".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].deltaEtaSC, op.c_int(-9999))
varsToKeep["ele{}_FR".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.lambda_FR_el(self.electronsPreSel[i - 1]),
op.c_int(-9999))
varsToKeep["ele{}_FRcorr".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.lambda_FRcorr_el(self.electronsPreSel[i - 1]),
op.c_int(-9999))
varsToKeep["ele{}_FF".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.lambda_FF_el(self.electronsPreSel[i - 1]),
op.c_int(-9999))
varsToKeep["ele{}_looseSF".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
reduce(
mul,
self.lambda_ElectronLooseSF(self.electronsPreSel[i -
1])),
op.c_int(-9999))
varsToKeep["ele{}_tightSF".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
reduce(
mul,
self.lambda_ElectronTightSF(self.electronsPreSel[i -
1])),
op.c_int(-9999))
# AK4 Jets #
for i in range(1, 5): # 4 leading jets
varsToKeep["ak4Jet{}_pt".format(i)] = op.switch(
op.rng_len(self.ak4Jets) >= i, self.ak4Jets[i - 1].pt,
op.c_float(-9999.))
varsToKeep["ak4Jet{}_eta".format(i)] = op.switch(
op.rng_len(self.ak4Jets) >= i, self.ak4Jets[i - 1].eta,
op.c_float(-9999.))
varsToKeep["ak4Jet{}_phi".format(i)] = op.switch(
op.rng_len(self.ak4Jets) >= i, self.ak4Jets[i - 1].phi,
op.c_float(-9999.))
varsToKeep["ak4Jet{}_E".format(i)] = op.switch(
op.rng_len(self.ak4Jets) >= i, self.ak4Jets[i - 1].p4.E(),
op.c_float(-9999.))
varsToKeep["ak4Jet{}_CSV".format(i)] = op.switch(
op.rng_len(self.ak4Jets) >= i,
self.ak4Jets[i - 1].btagDeepFlavB, op.c_float(-9999.))
varsToKeep["ak4Jet{}_hadronFlavour".format(i)] = op.switch(
op.rng_len(self.ak4Jets) >= i,
self.ak4Jets[i - 1].hadronFlavour, op.c_float(-9999.))
varsToKeep["ak4Jet{}_btagSF".format(i)] = op.switch(
op.rng_len(self.ak4Jets) >= i,
self.DeepJetDiscReshapingSF(self.ak4Jets[i - 1]),
op.c_float(-9999.))
varsToKeep["ak4Jet{}_puid_eff".format(i)] = op.switch(
op.rng_len(self.ak4Jets) >= i,
self.jetpuid_mc_eff(self.ak4Jets[i - 1]),
op.c_float(-9999.))
varsToKeep["ak4Jet{}_puid_sfeff".format(i)] = op.switch(
op.rng_len(self.ak4Jets) >= i,
self.jetpuid_sf_eff(self.ak4Jets[i - 1]),
op.c_float(-9999.))
varsToKeep["ak4Jet{}_puid_mis".format(i)] = op.switch(
op.rng_len(self.ak4Jets) >= i,
self.jetpuid_mc_mis(self.ak4Jets[i - 1]),
op.c_float(-9999.))
varsToKeep["ak4Jet{}_puid_sfmis".format(i)] = op.switch(
op.rng_len(self.ak4Jets) >= i,
self.jetpuid_sf_mis(self.ak4Jets[i - 1]),
op.c_float(-9999.))
# VBF Jets #
for i in range(1, 6): # 5 leading jets
varsToKeep["ak4JetVBF{}_pt".format(i)] = op.switch(
op.rng_len(self.VBFJetsPreSel) >= i,
self.VBFJetsPreSel[i - 1].pt, op.c_float(-9999.))
varsToKeep["ak4JetVBF{}_eta".format(i)] = op.switch(
op.rng_len(self.VBFJetsPreSel) >= i,
self.VBFJetsPreSel[i - 1].eta, op.c_float(-9999.))
varsToKeep["ak4JetVBF{}_phi".format(i)] = op.switch(
op.rng_len(self.VBFJetsPreSel) >= i,
self.VBFJetsPreSel[i - 1].phi, op.c_float(-9999.))
varsToKeep["ak4JetVBF{}_E".format(i)] = op.switch(
op.rng_len(self.VBFJetsPreSel) >= i,
self.VBFJetsPreSel[i - 1].p4.E(), op.c_float(-9999.))
varsToKeep["ak4JetVBF{}_CSV".format(i)] = op.switch(
op.rng_len(self.VBFJetsPreSel) >= i,
self.VBFJetsPreSel[i - 1].btagDeepFlavB,
op.c_float(-9999.))
varsToKeep["ak4JetVBF{}_btagSF".format(i)] = op.switch(
op.rng_len(self.VBFJetsPreSel) >= i,
self.DeepJetDiscReshapingSF(self.VBFJetsPreSel[i - 1]),
op.c_float(-9999.))
if not self.inclusive_sel:
if not any([self.args.Res0b, self.args.Ak4, self.args.Ak8]):
varsToKeep["ak4JetVBFPair1_pt"] = op.switch(
op.rng_len(VBFJetPairsJPA) >= 1,
VBFJetPairsJPA[0][0].pt, op.c_float(-9999.))
varsToKeep["ak4JetVBFPair1_eta"] = op.switch(
op.rng_len(VBFJetPairsJPA) >= 1,
VBFJetPairsJPA[0][0].eta, op.c_float(-9999.))
varsToKeep["ak4JetVBFPair1_phi"] = op.switch(
op.rng_len(VBFJetPairsJPA) >= 1,
VBFJetPairsJPA[0][0].phi, op.c_float(-9999.))
varsToKeep["ak4JetVBFPair1_E"] = op.switch(
op.rng_len(VBFJetPairsJPA) >= 1,
VBFJetPairsJPA[0][0].p4.E(), op.c_float(-9999.))
varsToKeep["ak4JetVBFPair1_CSV"] = op.switch(
op.rng_len(VBFJetPairsJPA) >= 1,
VBFJetPairsJPA[0][0].btagDeepFlavB, op.c_float(-9999.))
varsToKeep["ak4JetVBFPair1_btagSF"] = op.switch(
op.rng_len(VBFJetPairsJPA) >= 1,
self.DeepJetDiscReshapingSF(VBFJetPairsJPA[0][0]),
op.c_float(-9999.))
varsToKeep["ak4JetVBFPair2_pt"] = op.switch(
op.rng_len(VBFJetPairsJPA) >= 1,
VBFJetPairsJPA[0][1].pt, op.c_float(-9999.))
varsToKeep["ak4JetVBFPair2_eta"] = op.switch(
op.rng_len(VBFJetPairsJPA) >= 1,
VBFJetPairsJPA[0][1].eta, op.c_float(-9999.))
varsToKeep["ak4JetVBFPair2_phi"] = op.switch(
op.rng_len(VBFJetPairsJPA) >= 1,
VBFJetPairsJPA[0][1].phi, op.c_float(-9999.))
varsToKeep["ak4JetVBFPair2_E"] = op.switch(
op.rng_len(VBFJetPairsJPA) >= 1,
VBFJetPairsJPA[0][1].p4.E(), op.c_float(-9999.))
varsToKeep["ak4JetVBFPair2_CSV"] = op.switch(
op.rng_len(VBFJetPairsJPA) >= 1,
VBFJetPairsJPA[0][1].btagDeepFlavB, op.c_float(-9999.))
varsToKeep["ak4JetVBFPair2_btagSF"] = op.switch(
op.rng_len(VBFJetPairsJPA) >= 1,
self.DeepJetDiscReshapingSF(VBFJetPairsJPA[0][1]),
op.c_float(-9999.))
else:
varsToKeep["ak4JetVBFPair1_pt"] = op.c_float(-9999.)
varsToKeep["ak4JetVBFPair1_eta"] = op.c_float(-9999.)
varsToKeep["ak4JetVBFPair1_phi"] = op.c_float(-9999.)
varsToKeep["ak4JetVBFPair1_E"] = op.c_float(-9999.)
varsToKeep["ak4JetVBFPair1_CSV"] = op.c_float(-9999.)
varsToKeep["ak4JetVBFPair1_btagSF"] = op.c_float(-9999.)
varsToKeep["ak4JetVBFPair2_pt"] = op.c_float(-9999.)
varsToKeep["ak4JetVBFPair2_eta"] = op.c_float(-9999.)
varsToKeep["ak4JetVBFPair2_phi"] = op.c_float(-9999.)
varsToKeep["ak4JetVBFPair2_E"] = op.c_float(-9999.)
varsToKeep["ak4JetVBFPair2_CSV"] = op.c_float(-9999.)
varsToKeep["ak4JetVBFPair2_btagSF"] = op.c_float(-9999.)
# AK8 Jets #
for i in range(1, 3): # 2 leading fatjets
varsToKeep["ak8Jet{}_pt".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i, self.ak8BJets[i - 1].pt,
op.c_float(-9999.))
varsToKeep["ak8Jet{}_eta".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i, self.ak8BJets[i - 1].eta,
op.c_float(-9999.))
varsToKeep["ak8Jet{}_phi".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i, self.ak8BJets[i - 1].phi,
op.c_float(-9999.))
varsToKeep["ak8Jet{}_E".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i,
self.ak8BJets[i - 1].p4.E(), op.c_float(-9999.))
varsToKeep["ak8Jet{}_msoftdrop".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i,
self.ak8BJets[i - 1].msoftdrop, op.c_float(-9999.))
varsToKeep["ak8Jet{}_tau1".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i, self.ak8BJets[i - 1].tau1,
op.c_float(-9999.))
varsToKeep["ak8Jet{}_tau2".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i, self.ak8BJets[i - 1].tau2,
op.c_float(-9999.))
varsToKeep["ak8Jet{}_subjet0_pt".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i,
self.ak8BJets[i - 1].subJet1.pt, op.c_float(-9999.))
varsToKeep["ak8Jet{}_subjet0_eta".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i,
self.ak8BJets[i - 1].subJet1.eta, op.c_float(-9999.))
varsToKeep["ak8Jet{}_subjet0_phi".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i,
self.ak8BJets[i - 1].subJet1.phi, op.c_float(-9999.))
varsToKeep["ak8Jet{}_subjet0_CSV".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i,
self.ak8BJets[i - 1].subJet1.btagDeepB, op.c_float(-9999.))
varsToKeep["ak8Jet{}_subjet1_pt".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i,
self.ak8BJets[i - 1].subJet2.pt, op.c_float(-9999.))
varsToKeep["ak8Jet{}_subjet1_eta".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i,
self.ak8BJets[i - 1].subJet2.eta, op.c_float(-9999.))
varsToKeep["ak8Jet{}_subjet1_phi".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i,
self.ak8BJets[i - 1].subJet2.phi, op.c_float(-9999.))
varsToKeep["ak8Jet{}_subjet1_CSV".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i,
self.ak8BJets[i - 1].subJet2.btagDeepB, op.c_float(-9999.))
varsToKeep["PFMET"] = self.corrMET.pt
varsToKeep["PFMETphi"] = self.corrMET.phi
varsToKeep["met1_E"] = self.corrMET.p4.E()
varsToKeep["met1_pt"] = self.corrMET.pt
varsToKeep["met1_eta"] = self.corrMET.eta
varsToKeep["met1_phi"] = self.corrMET.phi
# SF #
electronMuon_cont = op.combine(
(self.electronsFakeSel, self.muonsFakeSel))
varsToKeep["trigger_SF"] = op.multiSwitch(
(op.AND(
op.rng_len(self.electronsTightSel) == 1,
op.rng_len(self.muonsTightSel) == 0),
self.ttH_singleElectron_trigSF(self.electronsTightSel[0])),
(op.AND(
op.rng_len(self.electronsTightSel) == 0,
op.rng_len(self.muonsTightSel)
== 1), self.ttH_singleMuon_trigSF(self.muonsTightSel[0])),
(op.AND(
op.rng_len(self.electronsTightSel) >= 2,
op.rng_len(self.muonsTightSel) == 0),
self.lambda_ttH_doubleElectron_trigSF(
self.electronsTightSel)),
(op.AND(
op.rng_len(self.electronsTightSel) == 0,
op.rng_len(self.muonsTightSel) >= 2),
self.lambda_ttH_doubleMuon_trigSF(self.muonsTightSel)),
(op.AND(
op.rng_len(self.electronsTightSel) >= 1,
op.rng_len(self.muonsTightSel) >= 1),
self.lambda_ttH_electronMuon_trigSF(electronMuon_cont[0])),
op.c_float(1.))
if not self.inclusive_sel:
varsToKeep["weight_trigger_el_sf"] = op.switch(
op.rng_len(self.electronsTightSel) > 0,
self.ttH_singleElectron_trigSF(lep), op.c_float(1.))
varsToKeep["weight_trigger_mu_sf"] = op.switch(
op.rng_len(self.muonsTightSel) > 0,
self.ttH_singleMuon_trigSF(lep), op.c_float(1.))
varsToKeep["lepton_IDSF"] = op.rng_product(self.electronsFakeSel, lambda el : reduce(mul,self.lambda_ElectronLooseSF(el)+self.lambda_ElectronTightSF(el))) * \
op.rng_product(self.muonsFakeSel, lambda mu : reduce(mul,self.lambda_MuonLooseSF(mu)+self.lambda_MuonTightSF(mu)))
varsToKeep["lepton_IDSF_recoToLoose"] = op.rng_product(self.electronsFakeSel, lambda el : reduce(mul,self.lambda_ElectronLooseSF(el))) * \
op.rng_product(self.muonsFakeSel, lambda mu : reduce(mul,self.lambda_MuonLooseSF(mu)))
varsToKeep["lepton_IDSF_looseToTight"] = op.rng_product(self.electronsFakeSel, lambda el : reduce(mul,self.lambda_ElectronTightSF(el))) * \
op.rng_product(self.muonsFakeSel, lambda mu : reduce(mul,self.lambda_MuonTightSF(mu)))
if era == "2016" or era == "2017":
if self.args.Channel == "El":
varsToKeep["weight_electron_reco_low"] = op.switch(
op.AND(self.lambda_is_matched(lep), lep.pt <= 20.),
self.elLooseRecoPtLt20(lep), op.c_float(1.))
varsToKeep["weight_electron_reco_high"] = op.switch(
op.AND(self.lambda_is_matched(lep), lep.pt > 20.),
self.elLooseRecoPtGt20(lep), op.c_float(1.))
varsToKeep["weight_muon_idiso_loose"] = op.c_float(1.)
varsToKeep["weight_electron_id_loose_01"] = op.switch(
self.lambda_is_matched(lep), self.elLooseEff(lep),
op.c_float(1.))
varsToKeep["weight_electron_id_loose_02"] = op.switch(
self.lambda_is_matched(lep), self.elLooseId(lep),
op.c_float(1.))
varsToKeep[
"weight_electron_tth_loose"] = self.lambda_ElectronTightSF(
lep)[0]
varsToKeep["weight_muon_tth_loose"] = op.c_float(1.)
if self.args.Channel == "Mu":
varsToKeep["weight_muon_idiso_loose"] = op.switch(
self.lambda_is_matched(lep), self.muLooseId(lep),
op.c_float(1.))
varsToKeep["weight_electron_reco_low"] = op.c_float(1.)
varsToKeep["weight_electron_reco_high"] = op.c_float(
1.)
varsToKeep["weight_electron_id_loose_01"] = op.c_float(
1.)
varsToKeep["weight_electron_id_loose_02"] = op.c_float(
1.)
varsToKeep["weight_electron_tth_loose"] = op.c_float(
1.)
varsToKeep[
"weight_muon_tth_loose"] = self.lambda_MuonTightSF(
lep)[0]
else:
raise NotImplementedError
# L1 Prefire #
if era in ["2016", "2017"]:
varsToKeep["L1prefire"] = self.L1Prefiring
varsToKeep["weight_l1_ecal_prefiring"] = self.L1Prefiring
else:
varsToKeep["L1prefire"] = op.c_float(-9999.)
varsToKeep["weight_l1_ecal_prefiring"] = op.c_float(-9999.)
# Fake rate #
if self.args.Channel == "El":
varsToKeep["fakeRate"] = op.switch(
self.lambda_electronTightSel(self.electronsFakeSel[0]),
self.ElFakeFactor(self.electronsFakeSel[0]),
op.c_float(1.))
varsToKeep["weight_fake_electrons"] = op.switch(
self.lambda_electronTightSel(self.electronsFakeSel[0]),
op.abs(self.ElFakeFactor(self.electronsFakeSel[0])),
op.c_float(1.))
varsToKeep["weight_fake_muons"] = op.c_float(1.)
varsToKeep["weight_fake_two_non_tight"] = op.c_float(999.0)
if self.args.Channel == "Mu":
varsToKeep["fakeRate"] = op.switch(
self.lambda_muonTightSel(self.muonsFakeSel[0]),
self.MuFakeFactor(self.muonsFakeSel[0]), op.c_float(1.))
varsToKeep["weight_fake_electrons"] = op.c_float(1.)
varsToKeep["weight_fake_muons"] = op.switch(
self.lambda_muonTightSel(self.muonsFakeSel[0]),
op.abs(self.MuFakeFactor(self.muonsFakeSel[0])),
op.c_float(1.))
varsToKeep["weight_fake_two_non_tight"] = op.c_float(999.0)
if self.is_MC:
varsToKeep["weight_fake_is_mc"] = op.c_float(-1.)
else:
varsToKeep["weight_fake_is_mc"] = op.c_float(1.)
# PU ID SF #
varsToKeep["PU_jetID_SF"] = self.puid_reweighting
varsToKeep[
"weight_jet_PUid_efficiency"] = self.puid_reweighting_efficiency
varsToKeep["weight_jet_PUid_mistag"] = self.puid_reweighting_mistag
# Btagging SF #
varsToKeep["btag_SF"] = self.btagAk4SF
varsToKeep["weight_btagWeight"] = self.btagAk4SF
if "BtagRatioWeight" in self.__dict__.keys():
varsToKeep["btag_ratio_SF"] = self.BtagRatioWeight
varsToKeep["weight_btagNorm"] = self.BtagRatioWeight
# PS weights #
varsToKeep["weight_PSWeight_ISR"] = self.psISRSyst
varsToKeep["weight_PSWeight_FSR"] = self.psFSRSyst
# ttbar PT reweighting #
if "group" in sampleCfg and sampleCfg["group"] == 'ttbar':
varsToKeep["topPt_wgt"] = self.ttbar_weight(
self.genTop[0], self.genAntitop[0])
# Event Weight #
if self.is_MC:
varsToKeep["MC_weight"] = t.genWeight
puWeightsFile = os.path.join(os.path.dirname(__file__), "data",
"pileup",
sample + '_%s.json' % era)
#puWeightsFile = os.path.join(os.path.dirname(__file__), "data" , "pileup", sampleCfg["pufile"])
varsToKeep["PU_weight"] = makePileupWeight(
puWeightsFile,
t.Pileup_nTrueInt,
nameHint=f"puweightFromFile{sample}".replace('-', '_'))
varsToKeep[
"eventWeight"] = noSel.weight if self.inclusive_sel else selObj.sel.weight
if self.inclusive_sel:
return noSel, varsToKeep
else:
return selObj.sel, varsToKeep
#---------------------------------------------------------------------------------------#
# Selection tree #
#---------------------------------------------------------------------------------------#
#----- EVT variables -----#
varsToKeep["event"] = None # Already in tree
varsToKeep["run"] = None # Already in tree
varsToKeep["ls"] = t.luminosityBlock
genVarsList = self.HLL.comp_cosThetaSbetBeamAndHiggs(t.GenPart)
varsToKeep['mHH_gen'] = genVarsList[0]
varsToKeep['consTheta1_gen'] = genVarsList[1]
varsToKeep['consTheta2_gen'] = genVarsList[2]
if any([
self.args.__dict__[item] for item in [
"Ak4", "Res2b2Wj", "Res2b1Wj", "Res2b0Wj", "Res1b2Wj",
"Res1b1Wj", "Res1b0Wj", "Res0b"
]
]):
commonInputs_Resolved = returnCommonInputs_Resolved(self=self)
classicInputs_Resolved = returnClassicInputs_Resolved(
self=self,
lepton=lep,
jpaSelectedJets=jpaJets,
L1out=L1out,
L2out=L2out,
jpaArg=jpaarg)
inputs_resolved = {
**commonInputs_Resolved,
**classicInputs_Resolved
}
for (varname, _, _), var in inputs_resolved.items():
varsToKeep[varname] = var
#----- Fatjet variables -----#
if any([
self.args.__dict__[item]
for item in ["Ak8", "Hbb2Wj", "Hbb1Wj", "Hbb0Wj"]
]):
commonInputs_Boosted = returnCommonInputs_Boosted(self=self)
classicInputs_Boosted = returnClassicInputs_Boosted(
self=self,
lepton=lep,
jpaSelectedJets=jpaJets,
L1out=L1out,
L2out=L2out,
jpaArg=jpaarg)
inputs_boosted = {**commonInputs_Boosted, **classicInputs_Boosted}
for (varname, _, _), var in inputs_boosted.items():
varsToKeep[varname] = var
#----- Additional variables -----#
varsToKeep["MC_weight"] = t.genWeight
varsToKeep['total_weight'] = selObj.sel.weight
#return leptonSel.sel, varsToKeep
return selObj.sel, varsToKeep
def returnResonantMVAInputs(self, l1, l2, channel, jets, bjets, fatjets, met,
electrons, muons):
if channel == "ElEl":
l1conept = lambda l1: self.electron_conept[l1.idx]
l2conept = lambda l2: self.electron_conept[l2.idx]
elif channel == "MuMu":
l1conept = lambda l1: self.muon_conept[l1.idx]
l2conept = lambda l2: self.muon_conept[l2.idx]
elif channel == "ElMu":
l1conept = lambda l1: self.electron_conept[l1.idx]
l2conept = lambda l2: self.muon_conept[l2.idx]
else:
raise RuntimeError("Wrong channel")
dijets = op.combine(jets, N=2)
import bamboo.treeoperations as _to
def rng_min(rng, fun=(lambda x: x), typeName="float"):
return op._to.Reduce.fromRngFun(
rng, op.c_float(float("+inf"), typeName),
(lambda fn:
(lambda res, elm: op.extMethod("std::min", returnType="Float_t")
(res, fn(elm))))(fun))
if self.args.era is None:
era = op.c_int(int(self.era))
else:
era = op.c_int(int(self.args.era))
print(f'Using {self.args.era} as DNN input')
return {
('eventnr', 'Event number', (100, 0., 1e6)):
self.tree.event,
('era', 'Era', (3, 2016., 2019.)):
era,
('l1_E', 'Lead lepton E [GeV]', (50, 0., 500.)):
op.switch(l1conept(l1) >= l2conept(l2), l1.p4.E(), l2.p4.E()),
('l1_Px', 'Lead lepton P_x [GeV]', (40, -200., 200.)):
op.switch(l1conept(l1) >= l2conept(l2), l1.p4.Px(), l2.p4.Px()),
('l1_Py', 'Lead lepton P_y [GeV]', (40, -200., 200.)):
op.switch(l1conept(l1) >= l2conept(l2), l1.p4.Py(), l2.p4.Py()),
('l1_Pz', 'Lead lepton P_z [GeV]', (40, -200., 200.)):
op.switch(l1conept(l1) >= l2conept(l2), l1.p4.Pz(), l2.p4.Pz()),
('l1_charge', 'Lead lepton charge', (2, 0., 2.)):
op.switch(l1conept(l1) >= l2conept(l2), l1.charge, l2.charge),
('l1_pdgId', 'Lead lepton pdg ID', (45, -22., 22.)):
op.switch(l1conept(l1) >= l2conept(l2), l1.pdgId, l2.pdgId),
('l2_E', 'Sublead lepton E [GeV]', (50, 0., 500.)):
op.switch(l1conept(l1) >= l2conept(l2), l2.p4.E(), l1.p4.E()),
('l2_Px', 'Sublead lepton P_x [GeV]', (40, -200., 200.)):
op.switch(l1conept(l1) >= l2conept(l2), l2.p4.Px(), l1.p4.Px()),
('l2_Py', 'Sublead lepton P_y [GeV]', (40, -200., 200.)):
op.switch(l1conept(l1) >= l2conept(l2), l2.p4.Py(), l1.p4.Py()),
('l2_Pz', 'Sublead lepton P_z [GeV]', (40, -200., 200.)):
op.switch(l1conept(l1) >= l2conept(l2), l2.p4.Pz(), l1.p4.Pz()),
('l2_charge', 'Sublead lepton charge', (2, 0., 2.)):
op.switch(l1conept(l1) >= l2conept(l2), l2.charge, l1.charge),
('l2_pdgId', 'Sublead lepton pdg ID', (45, -22., 22.)):
op.switch(l1conept(l1) >= l2conept(l2), l2.pdgId, l1.pdgId),
('j1_E', 'Lead jet E [GeV]', (50, 0., 500.)):
op.switch(op.rng_len(jets) > 0, jets[0].p4.E(), op.c_float(0.)),
('j1_Px', 'Lead jet P_x [GeV]', (40, -200., 200.)):
op.switch(op.rng_len(jets) > 0, jets[0].p4.Px(), op.c_float(0.)),
('j1_Py', 'Lead jet P_y [GeV]', (40, -200., 200.)):
op.switch(op.rng_len(jets) > 0, jets[0].p4.Py(), op.c_float(0.)),
('j1_Pz', 'Lead jet P_z [GeV]', (40, -200., 200.)):
op.switch(op.rng_len(jets) > 0, jets[0].p4.Pz(), op.c_float(0.)),
('j2_E', 'Sublead jet E [GeV]', (50, 0., 500.)):
op.switch(op.rng_len(jets) > 1, jets[1].p4.E(), op.c_float(0.)),
('j2_Px', 'Sublead jet P_x [GeV]', (40, -200., 200.)):
op.switch(op.rng_len(jets) > 1, jets[1].p4.Px(), op.c_float(0.)),
('j2_Py', 'Sublead jet P_y [GeV]', (40, -200., 200.)):
op.switch(op.rng_len(jets) > 1, jets[1].p4.Py(), op.c_float(0.)),
('j2_Pz', 'Sublead jet P_z [GeV]', (40, -200., 200.)):
op.switch(op.rng_len(jets) > 1, jets[1].p4.Pz(), op.c_float(0.)),
('j3_E', 'Subsublead jet E [GeV]', (50, 0., 500.)):
op.switch(op.rng_len(jets) > 2, jets[2].p4.E(), op.c_float(0.)),
('j3_Px', 'Subsublead jet P_x [GeV]', (40, -200., 200.)):
op.switch(op.rng_len(jets) > 2, jets[2].p4.Px(), op.c_float(0.)),
('j3_Py', 'Subsublead jet P_y [GeV]', (40, -200., 200.)):
op.switch(op.rng_len(jets) > 2, jets[2].p4.Py(), op.c_float(0.)),
('j3_Pz', 'Subsublead jet P_z [GeV]', (40, -200., 200.)):
op.switch(op.rng_len(jets) > 2, jets[2].p4.Pz(), op.c_float(0.)),
('j4_E', 'Subsubsublead jet E [GeV]', (50, 0., 500.)):
op.switch(op.rng_len(jets) > 3, jets[3].p4.E(), op.c_float(0.)),
('j4_Px', 'Subsubsublead jet P_x [GeV]', (40, -200., 200.)):
op.switch(op.rng_len(jets) > 3, jets[3].p4.Px(), op.c_float(0.)),
('j4_Py', 'Subsubsublead jet P_y [GeV]', (40, -200., 200.)):
op.switch(op.rng_len(jets) > 3, jets[3].p4.Py(), op.c_float(0.)),
('j4_Pz', 'Subsubsublead jet P_z [GeV]', (40, -200., 200.)):
op.switch(op.rng_len(jets) > 3, jets[3].p4.Pz(), op.c_float(0.)),
('fatjet_E', 'Fatjet E [GeV]', (50, 0., 500.)):
op.switch(op.rng_len(fatjets) > 0, fatjets[0].p4.E(), op.c_float(0.)),
('fatjet_Px', 'Fatjet P_x [GeV]', (40, -200., 200.)):
op.switch(op.rng_len(fatjets) > 0, fatjets[0].p4.Px(), op.c_float(0.)),
('fatjet_Py', 'Fatjet P_y [GeV]', (40, -200., 200.)):
op.switch(op.rng_len(fatjets) > 0, fatjets[0].p4.Py(), op.c_float(0.)),
('fatjet_Pz', 'Fatjet P_z [GeV]', (40, -200., 200.)):
op.switch(op.rng_len(fatjets) > 0, fatjets[0].p4.Pz(), op.c_float(0.)),
('fatjet_tau1', 'Fatjet #tau_1', (50, 0., 1.)):
op.switch(op.rng_len(fatjets) > 0, fatjets[0].tau1, op.c_float(0.)),
('fatjet_tau2', 'Fatjet #tau_2', (50, 0., 1.)):
op.switch(op.rng_len(fatjets) > 0, fatjets[0].tau2, op.c_float(0.)),
('fatjet_tau3', 'Fatjet #tau_3', (50, 0., 1.)):
op.switch(op.rng_len(fatjets) > 0, fatjets[0].tau3, op.c_float(0.)),
('fatjet_tau4', 'Fatjet #tau_4', (50, 0., 1.)):
op.switch(op.rng_len(fatjets) > 0, fatjets[0].tau4, op.c_float(0.)),
('fatjet_softdrop', 'Fatjet softdrop mass [GeV]', (50, 0., 1000.)):
op.switch(
op.rng_len(fatjets) > 0, fatjets[0].msoftdrop, op.c_float(0.)),
('met_E', 'MET Energy', (50, 0., 500.)):
met.p4.E(),
('met_Px', 'MET P_x', (40, -200., 200.)):
met.p4.Px(),
('met_Py', 'MET P_y', (40, -200., 200.)):
met.p4.Py(),
('met_Pz', 'MET P_z', (40, -200., 200.)):
met.p4.Pz(),
('m_bb_bregcorr', 'Di-bjet invariant mass (regcorr) [GeV]', (100, 0., 1000.)):
op.multiSwitch(
(op.rng_len(bjets) == 0, op.c_float(0.)),
(op.rng_len(bjets) == 1, self.HLL.getCorrBp4(bjets[0]).M()),
op.invariant_mass(self.HLL.getCorrBp4(bjets[0]),
self.HLL.getCorrBp4(bjets[1]))),
('ht', 'HT(jets) [GeV]', (100, 0., 1000.)):
op.rng_sum(jets, lambda j: j.pt),
('min_dr_jets_lep1', 'Min(#Delta R(lead lepton,jets))', (25, 0., 5.)):
op.switch(
op.rng_len(jets) > 0,
op.switch(
l1conept(l1) >= l2conept(l2),
self.HLL.MinDR_part1_partCont(l1.p4, jets),
self.HLL.MinDR_part1_partCont(l2.p4, jets)), op.c_float(0.)),
('min_dr_jets_lep2', 'Min(#Delta R(sublead lepton,jets))', (25, 0., 5.)):
op.switch(
op.rng_len(jets) > 0,
op.switch(
l1conept(l1) >= l2conept(l2),
self.HLL.MinDR_part1_partCont(l2.p4, jets),
self.HLL.MinDR_part1_partCont(l1.p4, jets)), op.c_float(0.)),
('m_ll', 'Dilepton invariant mass [GeV]', (100, 0., 1000.)):
op.invariant_mass(l1.p4, l2.p4),
('dr_ll', 'Dilepton #Delta R', (25, 0., 5.)):
op.deltaR(l1.p4, l2.p4),
('min_dr_jet', 'Min(#Delta R(jets))', (25, 0., 5.)):
op.switch(
op.rng_len(dijets) > 0,
op.rng_min(dijets,
lambda dijet: op.deltaR(dijet[0].p4, dijet[1].p4)),
op.c_float(0.)),
('min_dphi_jet', 'Min(#Delta #Phi(jets))', (16, 0., 3.2)):
op.switch(
op.rng_len(dijets) > 0,
rng_min(
dijets,
lambda dijet: op.abs(op.deltaPhi(dijet[0].p4, dijet[1].p4)),
typeName='double'), op.c_float(0.)),
('m_hh_simplemet_bregcorr', 'M_{HH} (simple MET) (regcorr) [GeV]', (100, 0., 1000.)):
op.invariant_mass(
op.rng_sum(bjets,
lambda bjet: self.HLL.getCorrBp4(bjet),
start=self.HLL.empty_p4), l1.p4, l2.p4, met.p4),
('met_ld', 'MET_{LD}', (100, 0., 1000.)):
self.HLL.MET_LD_DL(met, jets, electrons, muons),
('dr_bb', 'Di-bjet #Delta R', (25, 0., 5.)):
op.switch(
op.rng_len(bjets) >= 2, op.deltaR(bjets[0].p4, bjets[1].p4),
op.c_float(0.)),
('min_dr_leps_b1', 'Min(#Delta R(lead bjet,dilepton))', (25, 0., 5.)):
op.switch(
op.rng_len(bjets) >= 1,
self.HLL.MinDR_part1_dipart(bjets[0].p4, [l1.p4, l2.p4]),
op.c_float(0.)),
('min_dr_leps_b2', 'Min(#Delta R(sublead bjet,dilepton))', (25, 0., 5.)):
op.switch(
op.rng_len(bjets) >= 2,
self.HLL.MinDR_part1_dipart(bjets[1].p4, [l1.p4, l2.p4]),
op.c_float(0.)),
('lep1_conept', 'Lead lepton cone-P_T [GeV]', (40, 0., 200.)):
op.switch(l1conept(l1) >= l2conept(l2), l1conept(l1), l2conept(l2)),
('lep2_conept', 'Sublead lepton cone-P_T [GeV]', (40, 0., 200.)):
op.switch(l1conept(l1) >= l2conept(l2), l2conept(l2), l1conept(l1)),
('mww_simplemet', 'M_{WW} (simple MET) [GeV]', (100, 0., 1000.)):
op.invariant_mass(l1.p4, l2.p4, met.p4),
('boosted_tag', 'Boosted tag', (2, 0., 2.)):
op.c_int(
op.OR(
op.rng_len(self.ak8BJets) > 0, # Boosted 1B
op.AND(
op.rng_len(self.ak8BJets) == 0, # Boosted 0B
op.rng_len(self.ak8Jets) > 0,
op.rng_len(self.ak4BJets) == 0))),
('dphi_met_dilep', 'Dilepton-MET #Delta #Phi', (32, -3.2, 3.2)):
op.abs(op.deltaPhi(met.p4, (l1.p4 + l2.p4))),
('dphi_met_dibjet', 'Dibjet-MET #Delta #Phi', (32, -3.2, 3.2)):
op.multiSwitch(
(op.rng_len(bjets) == 0, op.c_float(0.)),
(op.rng_len(bjets) == 1, op.abs(op.deltaPhi(met.p4, bjets[0].p4))),
op.abs(op.deltaPhi(met.p4, (bjets[0].p4 + bjets[1].p4)))),
('dr_dilep_dijet', 'Dilepton-dijet #Delta R', (25, 0., 5.)):
op.multiSwitch(
(op.rng_len(jets) == 0, op.c_float(0.)),
(op.rng_len(jets) == 1, op.deltaR((l1.p4 + l2.p4), jets[0].p4)),
op.deltaR((l1.p4 + l2.p4), (jets[0].p4 + jets[1].p4))),
('dr_dilep_dibjet', 'Dilepton-dibjet #Delta R', (25, 0., 5.)):
op.multiSwitch(
(op.rng_len(bjets) == 0, op.c_float(0.)),
(op.rng_len(bjets) == 1, op.deltaR((l1.p4 + l2.p4), bjets[0].p4)),
op.deltaR((l1.p4 + l2.p4), (bjets[0].p4 + bjets[1].p4))),
('m_T', 'Transverse mass', (100, 0., 1000.)):
op.sqrt(2 * (l1.p4 + l2.p4).Pt() * met.p4.E() *
(1 - op.cos((l1.p4 + l2.p4).Phi() - met.p4.Phi()))),
('cosThetaS_Hbb', 'Helicity angle between Hbb and bjet', (20, 0., 1.)):
op.switch(
op.rng_len(bjets) == 2,
op.extMethod("HHbbWWJPA::cosThetaS",
returnType="float")(bjets[0].p4, bjets[1].p4),
op.c_float(0.)),
('LBN_inputs', 'LBN inputs', None): [
op.switch(l1conept(l1) >= l2conept(l2), l1.p4.E(), l2.p4.E()),
op.switch(l1conept(l1) >= l2conept(l2), l1.p4.Px(), l2.p4.Px()),
op.switch(l1conept(l1) >= l2conept(l2), l1.p4.Py(), l2.p4.Py()),
op.switch(l1conept(l1) >= l2conept(l2), l1.p4.Pz(), l2.p4.Pz()),
op.switch(l1conept(l1) >= l2conept(l2), l2.p4.E(), l1.p4.E()),
op.switch(l1conept(l1) >= l2conept(l2), l2.p4.Px(), l1.p4.Px()),
op.switch(l1conept(l1) >= l2conept(l2), l2.p4.Py(), l1.p4.Py()),
op.switch(l1conept(l1) >= l2conept(l2), l2.p4.Pz(), l1.p4.Pz()),
op.switch(op.rng_len(jets) > 0, jets[0].p4.E(), op.c_float(0.)),
op.switch(op.rng_len(jets) > 0, jets[0].p4.Px(), op.c_float(0.)),
op.switch(op.rng_len(jets) > 0, jets[0].p4.Py(), op.c_float(0.)),
op.switch(op.rng_len(jets) > 0, jets[0].p4.Pz(), op.c_float(0.)),
op.switch(op.rng_len(jets) > 1, jets[1].p4.E(), op.c_float(0.)),
op.switch(op.rng_len(jets) > 1, jets[1].p4.Px(), op.c_float(0.)),
op.switch(op.rng_len(jets) > 1, jets[1].p4.Py(), op.c_float(0.)),
op.switch(op.rng_len(jets) > 1, jets[1].p4.Pz(), op.c_float(0.)),
op.switch(op.rng_len(jets) > 2, jets[2].p4.E(), op.c_float(0.)),
op.switch(op.rng_len(jets) > 2, jets[2].p4.Px(), op.c_float(0.)),
op.switch(op.rng_len(jets) > 2, jets[2].p4.Py(), op.c_float(0.)),
op.switch(op.rng_len(jets) > 2, jets[2].p4.Pz(), op.c_float(0.)),
op.switch(op.rng_len(jets) > 3, jets[3].p4.E(), op.c_float(0.)),
op.switch(op.rng_len(jets) > 3, jets[3].p4.Px(), op.c_float(0.)),
op.switch(op.rng_len(jets) > 3, jets[3].p4.Py(), op.c_float(0.)),
op.switch(op.rng_len(jets) > 3, jets[3].p4.Pz(), op.c_float(0.)),
op.switch(
op.rng_len(fatjets) > 0, fatjets[0].p4.E(), op.c_float(0.)),
op.switch(
op.rng_len(fatjets) > 0, fatjets[0].p4.Px(), op.c_float(0.)),
op.switch(
op.rng_len(fatjets) > 0, fatjets[0].p4.Py(), op.c_float(0.)),
op.switch(
op.rng_len(fatjets) > 0, fatjets[0].p4.Pz(), op.c_float(0.))
]
}
def definePlots(self, t, noSel, sample=None, sampleCfg=None):
from bamboo.plots import Plot, CutFlowReport, SummedPlot
from bamboo.plots import EquidistantBinning as EqB
from bamboo import treefunctions as op
isMC = self.isMC(sample)
if sampleCfg.get("alt-syst"):
noSel = noSel.refine("withoutsyst", autoSyst=False)
plots = []
trigCut, trigWeight = None, None
if isMC:
muR = op.systematic(op.c_float(1.),
name="muR",
up=t.PSWeight[2],
down=t.PSWeight[0])
muF = op.systematic(op.c_float(1.),
name="muF",
up=t.PSWeight[3],
down=t.PSWeight[1])
noSel = noSel.refine(
"mcWeight",
weight=[t.genWeight, t.puWeight, t.PrefireWeight, muR, muF])
trigCut = op.OR(t.HLT.HIEle20_Ele12_CaloIdL_TrackIdL_IsoVL_DZ,
t.HLT.HIL3DoubleMu0, t.HLT.HIL3Mu20,
t.HLT.HIEle20_WPLoose_Gsf)
trigWeight = op.switch(
op.OR(t.HLT.HIEle20_Ele12_CaloIdL_TrackIdL_IsoVL_DZ,
t.HLT.HIL3DoubleMu0), op.c_float(1.),
op.switch(t.HLT.HIL3Mu20, op.c_float(306.913 / 308.545),
op.c_float(264.410 / 308.545))
) ## FIXME these are wrong - you will get the final values from team A
else:
## trigger order: dielectron, dimuon or single muon, single electron
pd = sample.split("_")[0]
if pd == "SingleMuon":
trigCut = op.AND(
op.NOT(t.HLT.HIEle20_Ele12_CaloIdL_TrackIdL_IsoVL_DZ),
op.OR(t.HLT.HIL3DoubleMu0, t.HLT.HIL3Mu20))
elif pd == "HighEGJet":
trigCut = op.OR(
t.HLT.HIEle20_Ele12_CaloIdL_TrackIdL_IsoVL_DZ,
op.AND(op.NOT(op.OR(t.HLT.HIL3DoubleMu0, t.HLT.HIL3Mu20)),
t.HLT.HIEle20_WPLoose_Gsf))
noSel = noSel.refine("trig", cut=trigCut, weight=trigWeight)
#plots += [Plot.make1D("nTotalEvents", op.rng_len([1]), noSel , EqB(1, 0, 1.), title="nTotalEvents")]
plots.append(
Plot.make1D("nTotalJets",
op.rng_len(t.Jet),
noSel,
EqB(15, 0, 15.),
title="Initial Jet multiplicity"))
#noSel = noSel.refine("trig", cut=op.OR(t.HLT.HIL3DoubleMu0, t.HLT.HIEle20_Ele12_CaloIdL_TrackIdL_IsoVL_DZ))
# plots = []
goodLeptons = {
"el":
op.select(
t.Electron, lambda el: op.AND(el.pt > 15.,
op.abs(el.p4.Eta()) < 2.5)
), # op.select(t.Electron, partial(isGoodElectron, ptCut=15.)),
"mu":
op.select(t.Muon, lambda mu: mu.pt > 20.
) # op.select(t.Muon, partial(isGoodMuon, ptCut=15.))
}
plots += [
Plot.make1D(
"trig_nLeptons15",
op.rng_len(goodLeptons["el"]) + op.rng_len(goodLeptons["mu"]),
noSel, EqB(15, 0., 15.)),
Plot.make1D("trig_nEl15", op.rng_len(goodLeptons["el"]), noSel,
EqB(15, 0., 15.)),
Plot.make1D("trig_nMu15", op.rng_len(goodLeptons["mu"]), noSel,
EqB(15, 0., 15.))
]
from bamboo.scalefactors import get_scalefactor
sf_loose = {
"mu":
get_scalefactor("lepton",
"Muon_RecoToLoose",
sfLib=scalefactors_lepMVA,
paramDefs=binningVariables_nano_noScaleSyst,
systName="muLoose"),
"el":
get_scalefactor("lepton",
"Electron_RecoToLoose",
sfLib=scalefactors_lepMVA,
paramDefs=binningVariables_nano_noScaleSyst,
systName="elLoose")
}
sf_tight = {
"mu":
get_scalefactor("lepton",
"Muon_LooseToTight",
sfLib=scalefactors_lepMVA,
paramDefs=binningVariables_nano_noScaleSyst,
systName="muTight"),
"el":
get_scalefactor("lepton",
"Electron_LooseToTight",
sfLib=scalefactors_lepMVA,
paramDefs=binningVariables_nano_noScaleSyst,
systName="elTight")
}
nGoodLeptons = op.rng_len(goodLeptons["el"]) + op.rng_len(
goodLeptons["mu"])
hasTwoGoodLeptons = noSel.refine(
"has2Lep", cut=(nGoodLeptons > 1)) # avoid overlap with 1l
jets = op.sort(
op.select(
t.Jet, lambda j: op.AND(
j.pt > 25.,
op.abs(j.eta) < 2.4, j.jetId & 0x2,
op.AND(
op.NOT(
op.rng_any(goodLeptons["el"], lambda l: op.deltaR(
l.p4, j.p4) < 0.4)),
op.NOT(
op.rng_any(goodLeptons["mu"], lambda l: op.deltaR(
l.p4, j.p4) < 0.4))))), lambda j: -j.pt)
## WP: see https://twiki.cern.ch/twiki/bin/viewauth/CMS/BtagRecommendation94X
loosebjets = op.select(jets, lambda j: j.btagDeepB > 0.1522)
mediumbjets = op.select(jets, lambda j: j.btagDeepB > 0.4941)
for fl1, fl2 in product(*repeat(goodLeptons.keys(), 2)):
dilepSel = lambda l1, l2: op.AND(l1.charge != l2.charge,
(l1.p4 + l2.p4).M() > 12.)
if fl1 == fl2:
lGood = op.sort(goodLeptons[fl1], lambda l: -l.pt)
dilep = op.combine(lGood, N=2, pred=dilepSel)
else:
l1Good = op.sort(goodLeptons[fl1], lambda l: -l.pt)
l2Good = op.sort(goodLeptons[fl2], lambda l: -l.pt)
dilep = op.combine((l1Good, l2Good), pred=dilepSel)
ll = dilep[0]
hasDilep = hasTwoGoodLeptons.refine(
f"hasDilep{fl1}{fl2}",
cut=(op.rng_len(dilep) > 0, ll[0].pt > 25.),
weight=([
sf_loose[fl1](ll[0]), sf_loose[fl2](ll[1]), sf_tight[fl1](
ll[0]), sf_tight[fl2](ll[1])
] if isMC else None))
plots += [
Plot.make1D(f"dilepton_{fl1}{fl2}_Mll",
(ll[0].p4 + ll[1].p4).M(),
hasDilep,
EqB(50, 70, 120.),
title="Dilepton mass"),
]
for il, ifl in enumerate((fl1, fl2)):
plots += [
Plot.make1D(f"dilepton_{fl1}{fl2}_L{il:d}PT",
ll[il].pt,
hasDilep,
EqB(50, 0., 100.),
title=f"Lepton {il:d} PT"),
Plot.make1D(f"dilepton_{fl1}{fl2}_L{il:d}ETA",
ll[il].eta,
hasDilep,
EqB(50, -2.5, 2.5),
title=f"Lepton {il:d} ETA"),
]
plots += [
Plot.make1D(f"dilepton_{fl1}{fl2}_nJets",
op.rng_len(jets),
hasDilep,
EqB(15, 0, 15.),
title="Jet multiplicity"),
Plot.make1D(f"dilepton_{fl1}{fl2}_nLooseBJets",
op.rng_len(loosebjets),
hasDilep,
EqB(15, 0, 15.),
title="Loose b-jet multiplicity"),
Plot.make1D(f"dilepton_{fl1}{fl2}_nMediumBJets",
op.rng_len(mediumbjets),
hasDilep,
EqB(15, 0, 15.),
title="Medium b-jet multiplicity"),
#Plot.make1D(f"dilepton_{fl1}{fl2}_nSelectedEvents", 1, hasDilep, EqB(1, 0, 1.), title="nSelectedEvents")
]
#muons = op.select(t.Muon, lambda mu : mu.pt > 20.)
#twoMuSel = noSel.refine("twoMuons", cut=[ op.rng_len(muons) > 1 ])
#electrons = op.select(t.Electron, lambda el : op.AND(el.pt > 15. , op.abs(el.p4.Eta()) < 2.5))
#twoElSel = noSel.refine("twoElectrons", cut=[ op.rng_len(electrons) > 1 ])
#oselmu = op.combine((electrons, muons))
#leptons = oselmu[0]
#twoLepSel = noSel.refine("twoLeptons", cut=[ op.rng_len(electrons) == 1 , op.rng_len(muons) == 1 ])
#jets = op.select(t.Jet, lambda j : j.pt > 30.)
#bjets = op.select(jets, lambda j : j.btagDeepFlavB > 0.2217)
#plots.append(Plot.make1D("dimu_M",
# op.invariant_mass(muons[0].p4, muons[1].p4), twoMuSel, EqB(100, 20., 120.),
# title="Dimuon invariant mass", plotopts={"show-overflow":False,
# "legend-position": [0.2, 0.6, 0.5, 0.9]}))
#plots.append(Plot.make1D("diel_M",
# op.invariant_mass(electrons[0].p4, electrons[1].p4), twoElSel, EqB(100, 20., 120.),
# title="Dielectron invariant mass", plotopts={"show-overflow":False,
# "legend-position": [0.2, 0.6, 0.5, 0.9]}))
#plots.append(Plot.make1D("dilep_M",
# op.invariant_mass(leptons[0].p4, leptons[1].p4) , twoLepSel, EqB(100, 20., 120.),
# title="Dimuon invariant mass", plotopts={"show-overflow":False,
# "legend-position": [0.2, 0.6, 0.5, 0.9]}))
#plots.append(SummedPlot("Mjj", plots, title="m(jj)"))
#plots.append(Plot.make1D("nJets_dimu",op.rng_len(jets), twoMuSel, EqB(10, -0.5, 9.5),
# title="Jet multiplicity", plotopts={"show-overflow":False,
# "legend-position": [0.2, 0.6, 0.5, 0.9]}))
#plots.append(Plot.make1D("nBJets_dimu",op.rng_len(bjets), twoMuSel, EqB(10, -0.5, 9.5),
# title="Jet multiplicity", plotopts={"show-overflow":False,
# "legend-position": [0.2, 0.6, 0.5, 0.9]}))
#plots.append(Plot.make1D("nJets_diel",op.rng_len(jets), twoElSel, EqB(10, -0.5, 9.5),
# title="Jet multiplicity", plotopts={"show-overflow":False,
# "legend-position": [0.2, 0.6, 0.5, 0.9]}))
#plots.append(Plot.make1D("nBJets_diel",op.rng_len(bjets), twoElSel, EqB(10, -0.5, 9.5),
# title="Jet multiplicity", plotopts={"show-overflow":False,
# "legend-position": [0.2, 0.6, 0.5, 0.9]}))
#plots.append(Plot.make1D("nJets_elmu",op.rng_len(jets), twoLepSel, EqB(10, -0.5, 9.5),
# title="Jet multiplicity", plotopts={"show-overflow":False,
# "legend-position": [0.2, 0.6, 0.5, 0.9]}))
#plots.append(Plot.make1D("nBJets_elmu",op.rng_len(bjets), twoLepSel, EqB(10, -0.5, 9.5),
# title="Jet multiplicity", plotopts={"show-overflow":False,
# "legend-position": [0.2, 0.6, 0.5, 0.9]}))
return plots
def definePlots(self, t, noSel, sample=None, sampleCfg=None):
noSel = super(PlotterNanoHHtobbWWSL,self).prepareObjects(t, noSel, sample, sampleCfg, 'SL')
# --------------------------- Machine Learning Model --------------------------- #
# -------- for JPA --------- #
era = sampleCfg['era']
# ----------------------------------- NodeList ------------------------------------- #
# keep the exact same order of nodes as mentioned in respective xml files
ResolvedJPANodeList = ['2b2Wj','2b1Wj','1b2Wj','2b0Wj','1b1Wj','1b0Wj','0b']
BoostedJPANodeList = ['Hbb2Wj','Hbb1Wj','Hbb0Wj']
basepath = os.path.join(os.path.abspath(os.path.dirname(__file__)),'MachineLearning','ml-models','JPA_Loose_ttH')
resolvedModelDict = getResolvedJpaModelDict(basepath, ResolvedJPANodeList, era)
boostedModelDict = getBoostedJpaModelDict(basepath, BoostedJPANodeList, era)
# ---------- LBN+DNN models ----------- #
#path_model_resolved = os.path.join('/home/ucl/cp3/gsaha/bamboodev/HHbbWWAnalysis/MachineLearning/ml-models/DNN/Resolved','Resolved'+str(era)+'.pb')
#path_model_boosted = os.path.join('/home/ucl/cp3/gsaha/bamboodev/HHbbWWAnalysis/MachineLearning/ml-models/DNN/Boosted','Boosted_allEras_x512.pb')
path_model_resolved_SM = os.path.join('/home/ucl/cp3/gsaha/bamboodev/HHbbWWAnalysis/MachineLearning/ml-models/DNN/Resolved','Resolved'+str(era)+'SMv2.pb')
# path_model_resolved_BSM = os.path.join('/home/ucl/cp3/gsaha/bamboodev/HHbbWWAnalysis/MachineLearning/ml-models/DNN/Resolved','Resolved'+str(era)+'BSMv2.pb')
# path_model_resolved_BSM = os.path.join('/home/ucl/cp3/gsaha/bamboodev/HHbbWWAnalysis/MachineLearning/ml-models/DNN/Resolved','Resolved'+str(era)+'BSMv3_w0p1.pb')
path_model_resolved_BSM = os.path.join('/home/ucl/cp3/gsaha/bamboodev/HHbbWWAnalysis/MachineLearning/ml-models/DNN/Resolved','Resolved'+str(era)+'BSMv3_w1.pb')
path_model_boosted_SM = os.path.join('/home/ucl/cp3/gsaha/bamboodev/HHbbWWAnalysis/MachineLearning/ml-models/DNN/Boosted','BoostedSMv2.pb')
# path_model_boosted_BSM = os.path.join('/home/ucl/cp3/gsaha/bamboodev/HHbbWWAnalysis/MachineLearning/ml-models/DNN/Boosted','BoostedBSMv2.pb')
# path_model_boosted_BSM = os.path.join('/home/ucl/cp3/gsaha/bamboodev/HHbbWWAnalysis/MachineLearning/ml-models/DNN/Boosted','BoostedBSMv3_w0p1_256x4.pb')
path_model_boosted_BSM = os.path.join('/home/ucl/cp3/gsaha/bamboodev/HHbbWWAnalysis/MachineLearning/ml-models/DNN/Boosted','BoostedBSMv3_w1_256x4.pb')
logger.info('DNN_Model_Resolved SM : {}'.format(path_model_resolved_SM))
logger.info('DNN_Model_Resolved BSM : {}'.format(path_model_resolved_BSM))
logger.info('DNN_Model_Boosted SM : {}'.format(path_model_boosted_SM))
logger.info('DNN_Model_Boosted BSM : {}'.format(path_model_boosted_BSM))
plots = []
cutFlowPlots = []
self.sample = sample
self.sampleCfg = sampleCfg
self.era = era
self.yieldPlots = makeYieldPlots(self.args.Synchronization)
#----- Ratio reweighting variables (before lepton and jet selection) -----#
#if self.args.BtagReweightingOff or self.args.BtagReweightingOn:
# #plots.append(objectsNumberPlot(channel="NoChannel",suffix='NoSelection',sel=noSel,objCont=self.ak4Jets,objName='Ak4Jets',Nmax=15,xTitle='N(Ak4 jets)'))
# #plots.append(CutFlowReport("BtagReweightingCutFlowReport",noSel))
# return plots
#----- Stitching study -----#
if self.args.DYStitchingPlots or self.args.WJetsStitchingPlots:
if self.args.DYStitchingPlots and sampleCfg['group'] != 'DY':
raise RuntimeError("Stitching is only done on DY MC samples")
if self.args.WJetsStitchingPlots and sampleCfg['group'] != 'Wjets':
raise RuntimeError("Stitching is only done on WJets MC samples")
#plots.extend(makeLHEPlots(noSel,t.LHE))
#plots.append(objectsNumberPlot(channel="NoChannel",suffix='NoSelection',sel=noSel,objCont=self.ak4Jets,objName='Ak4Jets',Nmax=15,xTitle='N(Ak4 jets)'))
#plots.append(CutFlowReport("DYStitchingCutFlowReport",noSel))
return plots
#----- Singleleptons -----#
ElSelObj,MuSelObj = makeSingleLeptonSelection(self,noSel,plot_yield=True)
#----- Apply jet corrections -----#
ElSelObject.sel = self.beforeJetselection(ElSelObj.sel,'El')
MuSelObject.sel = self.beforeJetselection(MuSelObj.sel,'Mu')
# selObjectDict : keys -> level (str)
# values -> [El,Mu] x Selection object
# Select the jets selections that will be done depending on user input #
resolved_args = ["Res2b2Wj","Res2b1Wj","Res1b2Wj","Res2b0Wj","Res1b1Wj","Res1b0Wj","Res0b","Resolved"]
boosted_args = ["Hbb2Wj","Hbb1Wj","Hbb0Wj","Boosted"]
jet_level = resolved_args + boosted_args
jet_level.append("Ak4") # to call all resolved categories
jet_level.append("Ak8") # to call all boosted categories
jetplot_level = [arg for (arg,boolean) in self.args.__dict__.items() if arg in jet_level and boolean]
if len(jetplot_level) == 0:
jetplot_level = jet_level # If nothing said, will do all
jetsel_level = copy(jetplot_level) # A plot level might need a previous selection that needs to be defined but not necessarily plotted
if any(item in boosted_args for item in jetsel_level):
jetsel_level.append("Ak8") # SemiBoosted & Boosted needs the Ak8 selection
if any(item in resolved_args for item in jetsel_level):
jetsel_level.append("Ak4") # Resolved needs the Ak4 selection
logger.info ('jetSel_Level: {}'.format(jetsel_level))
# Selections:
#---- Lepton selection ----#
ElColl = [t.Electron[op.switch(op.rng_len(self.electronsTightSel) == 1,
self.electronsTightSel[0].idx,
self.electronsFakeSel[0].idx)]]
MuColl = [t.Muon[op.switch(op.rng_len(self.muonsTightSel) == 1,
self.muonsTightSel[0].idx,
self.muonsFakeSel[0].idx)]]
'''
if not self.args.OnlyYield:
ChannelDictList = []
ChannelDictList.append({'channel':'El','sel':ElSelObj.sel,'suffix':ElSelObj.selName})
ChannelDictList.append({'channel':'Mu','sel':MuSelObj.sel,'suffix':MuSelObj.selName})
for channelDict in ChannelDictList:
#----- Trigger plots -----#
plots.extend(singleLeptonTriggerPlots(**channelDict, triggerDict=self.triggersPerPrimaryDataset))
'''
LeptonKeys = ['channel','sel','lepton','suffix','is_MC']
JetKeys = ['channel','sel','jet1','jet2','jet3','jet4','suffix','nJet','nbJet','is_MC']
commonItems = ['channel','sel','suffix']
#----- Ak4 jets selection -----#
if "Ak4" in jetsel_level:
logger.info ("... Processing Ak4Jets Selection for Resolved category : nAk4Jets >= 3")
ElSelObjResolved = makeResolvedSelection(self,ElSelObj,copy_sel=True,plot_yield=True)
MuSelObjResolved = makeResolvedSelection(self,MuSelObj,copy_sel=True,plot_yield=True)
#----- Ak8-b jets selection -----#
if "Ak8" in jetsel_level:
logger.info ("...... Processing Ak8b jet selection for SemiBoosted & Boosted Category")
ElSelObjBoosted = makeBoostedSelection(self,ElSelObj,copy_sel=True,plot_yield=True)
MuSelObjBoosted = makeBoostedSelection(self,MuSelObj,copy_sel=True,plot_yield=True)
self.nodes = ['Ewk','GGF','H','Top','VBF','WJets']
inputsEventNr = returnEventNr(self, t)
output_name = "Identity"
ClassicInputKeys = ['lepton','jpaSelectedJets','L1out','L2out','jpaArg']
LBNInputKeys = ['lepton','jet1','jet2','jet3','jet4']
# ========================== JPA Resolved Categories ========================= #
if any(item in resolved_args for item in jetsel_level):
ChannelDictListR = []
# dict = {'key':'Node', 'value' : [refined selObj, [JPAjetIndices]]}
elL1OutList, elL2OutList, ElResolvedSelObjJetsIdxPerJpaNodeDict = findJPACategoryResolved (self, ElSelObjResolved, ElColl[0],self.muonsPreSel, self.electronsPreSel,
self.ak4Jets, self.ak4BJetsLoose,self.ak4BJets, self.corrMET,
resolvedModelDict, t.event,self.HLL, ResolvedJPANodeList,
plot_yield=True)
muL1OutList, muL2OutList, MuResolvedSelObjJetsIdxPerJpaNodeDict = findJPACategoryResolved (self, MuSelObjResolved, MuColl[0],self.muonsPreSel, self.electronsPreSel,
self.ak4Jets, self.ak4BJetsLoose,self.ak4BJets, self.corrMET,
resolvedModelDict, t.event,self.HLL, ResolvedJPANodeList,
plot_yield=True)
if "Res2b2Wj" in jetplot_level or "Resolved" in jetplot_level:
logger.info ('...... JPA : 2b2Wj Node Selection')
ElSelObjResolved2b2Wj = ElResolvedSelObjJetsIdxPerJpaNodeDict.get('2b2Wj')[0]
ElSelObjResolved2b2WjJets = ElResolvedSelObjJetsIdxPerJpaNodeDict.get('2b2Wj')[1]
MuSelObjResolved2b2Wj = MuResolvedSelObjJetsIdxPerJpaNodeDict.get('2b2Wj')[0]
MuSelObjResolved2b2WjJets = MuResolvedSelObjJetsIdxPerJpaNodeDict.get('2b2Wj')[1]
if self.args.onlypost:
ElSelObjResolved2b2Wj.record_yields = True
MuSelObjResolved2b2Wj.record_yields = True
ElSelObjResolved2b2Wj.yieldTitle = 'Resolved2b2Wj Channel $e^{\pm}$'
MuSelObjResolved2b2Wj.yieldTitle = 'Resolved2b2Wj Channel $\mu^{\pm}$'
if not self.args.OnlyYield:
ChannelDictListR.append({'channel':'El','selObj':ElSelObjResolved2b2Wj,'sel':ElSelObjResolved2b2Wj.sel,
'lepton':ElColl[0],'met':self.corrMET,'jpaSelectedJets':ElSelObjResolved2b2WjJets,
'jet1':ElSelObjResolved2b2WjJets[0],'jet2':ElSelObjResolved2b2WjJets[1],
'jet3':ElSelObjResolved2b2WjJets[2],'jet4':ElSelObjResolved2b2WjJets[3],
'nJet':4,'nbJet':2,'suffix':ElSelObjResolved2b2Wj.selName,
'is_MC':self.is_MC,'jpaArg':'Res2b2Wj'})
ChannelDictListR.append({'channel':'Mu','selObj':MuSelObjResolved2b2Wj,'sel':MuSelObjResolved2b2Wj.sel,
'lepton':MuColl[0],'met':self.corrMET,'jpaSelectedJets':MuSelObjResolved2b2WjJets,
'jet1':MuSelObjResolved2b2WjJets[0],'jet2':MuSelObjResolved2b2WjJets[1],
'jet3':MuSelObjResolved2b2WjJets[2],'jet4':MuSelObjResolved2b2WjJets[3],
'nJet':4,'nbJet':2,'suffix':MuSelObjResolved2b2Wj.selName,
'is_MC':self.is_MC,'jpaArg':'Res2b2Wj'})
if "Res2b1Wj" in jetplot_level or "Resolved" in jetplot_level:
logger.info ('...... JPA : 2b1Wj Node Selection')
ElSelObjResolved2b1Wj = ElResolvedSelObjJetsIdxPerJpaNodeDict.get('2b1Wj')[0]
ElSelObjResolved2b1WjJets = ElResolvedSelObjJetsIdxPerJpaNodeDict.get('2b1Wj')[1]
MuSelObjResolved2b1Wj = MuResolvedSelObjJetsIdxPerJpaNodeDict.get('2b1Wj')[0]
MuSelObjResolved2b1WjJets = MuResolvedSelObjJetsIdxPerJpaNodeDict.get('2b1Wj')[1]
if self.args.onlypost:
ElSelObjResolved2b1Wj.record_yields = True
MuSelObjResolved2b1Wj.record_yields = True
ElSelObjResolved2b1Wj.yieldTitle = 'Resolved2b1Wj Channel $e^{\pm}$'
MuSelObjResolved2b1Wj.yieldTitle = 'Resolved2b1Wj Channel $\mu^{\pm}$'
if not self.args.OnlyYield:
ChannelDictListR.append({'channel':'El','selObj':ElSelObjResolved2b1Wj,'sel':ElSelObjResolved2b1Wj.sel,
'lep':ElColl[0],'met':self.corrMET,'jpaSelectedJets':ElSelObjResolved2b1WjJets,
'jet1':ElSelObjResolved2b1WjJets[0],'jet2':ElSelObjResolved2b1WjJets[1],
'jet3':ElSelObjResolved2b1WjJets[2],'jet4':None,
'nJet':3,'nbJet':2,'suffix':ElSelObjResolved2b1Wj.selName,
'is_MC':self.is_MC, 'jpaArg':'Res2b1Wj'})
ChannelDictListR.append({'channel':'Mu','selObj':MuSelObjResolved2b1Wj,'sel':MuSelObjResolved2b1Wj.sel,
'lep':MuColl[0],'met':self.corrMET,'jpaSelectedJets':MuSelObjResolved2b1WjJets,
'jet1':MuSelObjResolved2b1WjJets[0],'jet2':MuSelObjResolved2b1WjJets[1],
'jet3':MuSelObjResolved2b1WjJets[2],'jet4':None,
'nJet':3,'nbJet':2,'suffix':MuSelObjResolved2b1Wj.selName,
'is_MC':self.is_MC, 'jpaArg':'Res2b1Wj'})
if "Res1b2Wj" in jetplot_level or "Resolved" in jetplot_level:
logger.info ('...... JPA : 1b2Wj Node Selection')
ElSelObjResolved1b2Wj = ElResolvedSelObjJetsIdxPerJpaNodeDict.get('1b2Wj')[0]
ElSelObjResolved1b2WjJets = ElResolvedSelObjJetsIdxPerJpaNodeDict.get('1b2Wj')[1]
MuSelObjResolved1b2Wj = MuResolvedSelObjJetsIdxPerJpaNodeDict.get('1b2Wj')[0]
MuSelObjResolved1b2WjJets = MuResolvedSelObjJetsIdxPerJpaNodeDict.get('1b2Wj')[1]
if self.args.onlypost:
ElSelObjResolved1b2Wj.record_yields = True
MuSelObjResolved1b2Wj.record_yields = True
ElSelObjResolved1b2Wj.yieldTitle = 'Resolved1b2Wj Channel $e^{\pm}$'
MuSelObjResolved1b2Wj.yieldTitle = 'Resolved1b2Wj Channel $\mu^{\pm}$'
if not self.args.OnlyYield:
ChannelDictListR.append({'channel':'El','selObj':ElSelObjResolved1b2Wj,'sel':ElSelObjResolved1b2Wj.sel,
'lep':ElColl[0],'met':self.corrMET,'jpaSelectedJets':ElSelObjResolved1b2WjJets,
'jet1':ElSelObjResolved1b2WjJets[0],'jet2':ElSelObjResolved1b2WjJets[1],
'jet3':ElSelObjResolved1b2WjJets[2],'jet4':None,
'nJet':3,'nbJet':1,'suffix':ElSelObjResolved1b2Wj.selName,
'is_MC':self.is_MC, 'jpaArg':'Res1b2Wj'})
ChannelDictListR.append({'channel':'Mu','selObj':MuSelObjResolved1b2Wj,'sel':MuSelObjResolved1b2Wj.sel,
'lep':MuColl[0],'met':self.corrMET,'jpaSelectedJets':MuSelObjResolved1b2WjJets,
'jet1':MuSelObjResolved1b2WjJets[0],'jet2':MuSelObjResolved1b2WjJets[1],
'jet3':MuSelObjResolved1b2WjJets[2],'jet4':None,
'nJet':3,'nbJet':1,'suffix':MuSelObjResolved1b2Wj.selName,
'is_MC':self.is_MC, 'jpaArg':'Res1b2Wj'})
if "Res2b0Wj" in jetplot_level or "Resolved" in jetplot_level:
logger.info ('...... JPA : 2b0Wj Node Selection')
ElSelObjResolved2b0Wj = ElResolvedSelObjJetsIdxPerJpaNodeDict.get('2b0Wj')[0]
ElSelObjResolved2b0WjJets = ElResolvedSelObjJetsIdxPerJpaNodeDict.get('2b0Wj')[1]
MuSelObjResolved2b0Wj = MuResolvedSelObjJetsIdxPerJpaNodeDict.get('2b0Wj')[0]
MuSelObjResolved2b0WjJets = MuResolvedSelObjJetsIdxPerJpaNodeDict.get('2b0Wj')[1]
if self.args.onlypost:
ElSelObjResolved2b0Wj.record_yields = True
MuSelObjResolved2b0Wj.record_yields = True
ElSelObjResolved2b0Wj.yieldTitle = 'Resolved2b0Wj Channel $e^{\pm}$'
MuSelObjResolved2b0Wj.yieldTitle = 'Resolved2b0Wj Channel $\mu^{\pm}$'
if not self.args.OnlyYield:
ChannelDictListR.append({'channel':'El','selObj':ElSelObjResolved2b0Wj,'sel':ElSelObjResolved2b0Wj.sel,
'lep':ElColl[0],'met':self.corrMET,'jpaSelectedJets':ElSelObjResolved2b0WjJets,
'jet1':ElSelObjResolved2b0WjJets[0],'jet2':ElSelObjResolved2b0WjJets[1],
'jet3':None,'jet4':None,
'nJet':2,'nbJet':2,'suffix':ElSelObjResolved2b0Wj.selName,
'is_MC':self.is_MC, 'jpaArg':'Res2b0Wj'})
ChannelDictListR.append({'channel':'Mu','selObj':MuSelObjResolved2b0Wj,'sel':MuSelObjResolved2b0Wj.sel,
'lep':MuColl[0],'met':self.corrMET,'jpaSelectedJets':MuSelObjResolved2b0WjJets,
'jet1':MuSelObjResolved2b0WjJets[0],'jet2':MuSelObjResolved2b0WjJets[1],
'jet3':None,'jet4':None,
'nJet':2,'nbJet':2,'suffix':MuSelObjResolved2b0Wj.selName,
'is_MC':self.is_MC, 'jpaArg':'Res2b0Wj'})
if "Res1b1Wj" in jetplot_level or "Resolved" in jetplot_level:
logger.info ('...... JPA : 1b1Wj Node Selection')
ElSelObjResolved1b1Wj = ElResolvedSelObjJetsIdxPerJpaNodeDict.get('1b1Wj')[0]
ElSelObjResolved1b1WjJets = ElResolvedSelObjJetsIdxPerJpaNodeDict.get('1b1Wj')[1]
MuSelObjResolved1b1Wj = MuResolvedSelObjJetsIdxPerJpaNodeDict.get('1b1Wj')[0]
MuSelObjResolved1b1WjJets = MuResolvedSelObjJetsIdxPerJpaNodeDict.get('1b1Wj')[1]
if self.args.onlypost:
ElSelObjResolved1b1Wj.record_yields = True
MuSelObjResolved1b1Wj.record_yields = True
ElSelObjResolved1b1Wj.yieldTitle = 'Resolved1b1Wj Channel $e^{\pm}$'
MuSelObjResolved1b1Wj.yieldTitle = 'Resolved1b1Wj Channel $\mu^{\pm}$'
if not self.args.OnlyYield:
ChannelDictListR.append({'channel':'El','selObj':ElSelObjResolved1b1Wj,'sel':ElSelObjResolved1b1Wj.sel,
'lep':ElColl[0],'met':self.corrMET,'jpaSelectedJets':ElSelObjResolved1b1WjJets,
'jet1':ElSelObjResolved1b1WjJets[0],'jet2':ElSelObjResolved1b1WjJets[1],
'jet3':None,'jet4':None,
'nJet':2,'nbJet':1,'suffix':ElSelObjResolved1b1Wj.selName,
'is_MC':self.is_MC, 'jpaArg':'Res1b1Wj'})
ChannelDictListR.append({'channel':'Mu','selObj':MuSelObjResolved1b1Wj,'sel':MuSelObjResolved1b1Wj.sel,
'lep':MuColl[0],'met':self.corrMET,'jpaSelectedJets':MuSelObjResolved1b1WjJets,
'jet1':MuSelObjResolved1b1WjJets[0],'jet2':MuSelObjResolved1b1WjJets[1],
'jet3':None,'jet4':None,
'nJet':2,'nbJet':1,'suffix':MuSelObjResolved1b1Wj.selName,
'is_MC':self.is_MC, 'jpaArg':'Res1b1Wj'})
if "Res1b0Wj" in jetplot_level or "Resolved" in jetplot_level:
logger.info('...... JPA : 1b0Wj Node Selection')
ElSelObjResolved1b0Wj = ElResolvedSelObjJetsIdxPerJpaNodeDict.get('1b0Wj')[0]
ElSelObjResolved1b0WjJets = ElResolvedSelObjJetsIdxPerJpaNodeDict.get('1b0Wj')[1]
MuSelObjResolved1b0Wj = MuResolvedSelObjJetsIdxPerJpaNodeDict.get('1b0Wj')[0]
MuSelObjResolved1b0WjJets = MuResolvedSelObjJetsIdxPerJpaNodeDict.get('1b0Wj')[1]
if self.args.onlypost:
ElSelObjResolved1b0Wj.record_yields = True
MuSelObjResolved1b0Wj.record_yields = True
ElSelObjResolved1b0Wj.yieldTitle = 'Resolved1b0Wj Channel $e^{\pm}$'
MuSelObjResolved1b0Wj.yieldTitle = 'Resolved1b0Wj Channel $\mu^{\pm}$'
if not self.args.OnlyYield:
ChannelDictListR.append({'channel':'El','selObj':ElSelObjResolved1b0Wj,'sel':ElSelObjResolved1b0Wj.sel,
'lep':ElColl[0],'met':self.corrMET,'jpaSelectedJets':ElSelObjResolved1b0WjJets,
'jet1':ElSelObjResolved1b0WjJets[0],'jet2':None,
'jet3':None,'jet4':None,
'nJet':1,'nbJet':1,'suffix':ElSelObjResolved1b0Wj.selName,
'is_MC':self.is_MC, 'jpaArg':'Res1b0Wj'})
ChannelDictListR.append({'channel':'Mu','selObj':MuSelObjResolved1b0Wj,'sel':MuSelObjResolved1b0Wj.sel,
'lep':MuColl[0],'met':self.corrMET,'jpaSelectedJets':MuSelObjResolved1b0WjJets,
'jet1':MuSelObjResolved1b0WjJets[0],'jet2':None,
'jet3':None,'jet4':None,
'nJet':1,'nbJet':1,'suffix':MuSelObjResolved1b0Wj.selName,
'is_MC':self.is_MC, 'jpaArg':'Res1b0Wj'})
if "Res0b" in jetplot_level or "Resolved" in jetplot_level:
logger.info ('...... JPA : 0b Node Selection')
ElSelObjResolved0b = ElResolvedSelObjJetsIdxPerJpaNodeDict.get('0b')[0]
MuSelObjResolved0b = MuResolvedSelObjJetsIdxPerJpaNodeDict.get('0b')[0]
print(type(ElSelObjResolved0b))
if self.args.onlypost:
ElSelObjResolved0b.record_yields = True
MuSelObjResolved0b.record_yields = True
ElSelObjResolved0b.yieldTitle = 'Resolved0b Channel $e^{\pm}$'
MuSelObjResolved0b.yieldTitle = 'Resolved0b Channel $\mu^{\pm}$'
if not self.args.OnlyYield:
ChannelDictListR.append({'channel':'El','selObj':ElSelObjResolved0b,'sel':ElSelObjResolved0b.sel,
'lep':ElColl[0],'met':self.corrMET,'jpaSelectedJets':None,
'jet1':None,'jet2':None,
'jet3':None,'jet4':None,
'nJet':1,'nbJet':1,'suffix':ElSelObjResolved0b.selName,
'is_MC':self.is_MC, 'jpaArg':'Res0b'})
ChannelDictListR.append({'channel':'Mu','selObj':MuSelObjResolved0b,'sel':MuSelObjResolved0b.sel,
'lep':MuColl[0],'met':self.corrMET,'jpaSelectedJets':None,
'jet1':None,'jet2':None,
'jet3':None,'jet4':None,
'nJet':1,'nbJet':1,'suffix':MuSelObjResolved1b0Wj.selName,
'is_MC':self.is_MC, 'jpaArg':'Res0b'})
for channelDict in ChannelDictListR:
if any(['Res2b2Wj','Res2b1Wj','Res1b2Wj','Res2b0Wj','Res1b1Wj','Res1b0Wj']) in jetplot_level:
# Singlelepton #
plots.extend(makeSinleptonPlots(**{k:channelDict[k] for k in LeptonKeys}))
# Number of jets #
#plots.append(objectsNumberPlot(**{k:channelDict[k] for k in commonItems},**JetsN))
#plots.append(objectsNumberPlot(**{k:channelDict[k] for k in commonItems},**FatJetsN))
# Ak4 Jets #
plots.extend(makeAk4JetsPlots(**{k:channelDict[k] for k in JetKeys},HLL=self.HLL))
# MET #
plots.extend(makeMETPlots(**{k:channelDict[k] for k in commonItems}, met=self.corrMET))
# High level #
##plots.extend(makeHighLevelPlotsResolved(**{k:channelDict[k] for k in ResolvedKeys},HLL=self.HLL))
inputsCommon = returnCommonInputs_Resolved(self)
inputsClassic = returnClassicInputs_Resolved(self, **{k:channelDict[k] for k in ClassicInputKeys})
inputsLBN = returnLBNInputs_Resolved(self, **{k:channelDict[k] for k in LBNInputKeys})
input_names = [key[0] for key in inputsClassic.keys()] + ['LBN_inputs','eventnr']
inputs_array = [op.array("double",val) for val in inputStaticCast(inputsCommon,"float")]
inputs_array.append(op.array("double",*inputStaticCast(inputsClassic,"float")))
inputs_array.append(op.array("double",*inputStaticCast(inputsLBN,"float")))
inputs_array.append(op.array("long",*inputStaticCast(inputsEventNr,"long")))
DNN_SM = op.mvaEvaluator (path_model_resolved_SM, mvaType='Tensorflow',otherArgs=(input_names, output_name))
DNN_BSM = op.mvaEvaluator(path_model_resolved_BSM, mvaType='Tensorflow',otherArgs=(input_names, output_name))
DNN_Score_SM = DNN_SM (*inputs_array)
DNN_Score_BSM = DNN_BSM (*inputs_array)
selObj = channelDict['selObj']
selObj_1b = makeExclusiveLooseResolvedJetComboSelection(self, selObj, 1, copy_sel=True)
selObj_2b = makeExclusiveLooseResolvedJetComboSelection(self, selObj, 2, copy_sel=True)
selObjNodesDict_SM = makeDNNOutputNodesSelections(self,selObj, DNN_Score_SM, suffix='_SM_')
selObjNodesDict_SM_1b = makeDNNOutputNodesSelections(self,selObj_1b,DNN_Score_SM, suffix='_SM_')
selObjNodesDict_SM_2b = makeDNNOutputNodesSelections(self,selObj_2b,DNN_Score_SM, suffix='_SM_')
selObjNodesDict_BSM = makeDNNOutputNodesSelections(self,selObj, DNN_Score_BSM, suffix='_BSM_')
selObjNodesDict_BSM_1b = makeDNNOutputNodesSelections(self,selObj_1b,DNN_Score_BSM, suffix='_BSM_')
selObjNodesDict_BSM_2b = makeDNNOutputNodesSelections(self,selObj_2b,DNN_Score_BSM, suffix='_BSM_')
logger.info('Filling SM DNN responses')
plots.extend(makeDoubleLeptonMachineLearningOutputPlots(selObjNodesDict_SM, DNN_Score_SM, self.nodes,channel=channelDict['channel']))
plots.extend(makeDoubleLeptonMachineLearningOutputPlots(selObjNodesDict_SM_1b, DNN_Score_SM, self.nodes,channel=channelDict['channel']))
plots.extend(makeDoubleLeptonMachineLearningOutputPlots(selObjNodesDict_SM_2b, DNN_Score_SM, self.nodes,channel=channelDict['channel']))
logger.info('Filling BSM DNN responses')
plots.extend(makeDoubleLeptonMachineLearningOutputPlots(selObjNodesDict_BSM, DNN_Score_BSM, self.nodes,channel=channelDict['channel']))
plots.extend(makeDoubleLeptonMachineLearningOutputPlots(selObjNodesDict_BSM_1b, DNN_Score_BSM, self.nodes,channel=channelDict['channel']))
plots.extend(makeDoubleLeptonMachineLearningOutputPlots(selObjNodesDict_BSM_2b, DNN_Score_BSM, self.nodes,channel=channelDict['channel']))
# ========================== JPA Boosted Categories ========================= #
if any(item in boosted_args for item in jetsel_level):
ChannelDictListB = []
FatJetKeys = ['channel','sel','jet1','jet2','jet3','jet4','has1fat1slim','has1fat2slim','suffix']
# dict = {'key':'Node', 'value' : [refined selObj, [JPAjetIndices]]}
elL1OutList, elL2OutList, ElBoostedSelObjJetsIdxPerJpaNodeDict = findJPACategoryBoosted (self, ElSelObjBoosted, ElColl[0], self.muonsPreSel, self.electronsPreSel,
self.ak8BJets, self.ak4JetsCleanedFromAk8b, self.ak4BJetsLoose,
self.ak4BJets, self.corrMET, boostedModelDict, t.event, self.HLL,
BoostedJPANodeList,
plot_yield=True)
muL1OutList, muL2OutList, MuBoostedSelObjJetsIdxPerJpaNodeDict = findJPACategoryBoosted (self, MuSelObjBoosted, MuColl[0], self.muonsPreSel, self.electronsPreSel,
self.ak8BJets, self.ak4JetsCleanedFromAk8b, self.ak4BJetsLoose,
self.ak4BJets, self.corrMET, boostedModelDict, t.event, self.HLL,
BoostedJPANodeList,
plot_yield=True)
if "Hbb2Wj" in jetplot_level or "Boosted" in jetplot_level:
print ('...... JPA : Hbb2Wj Node Selection')
ElSelObjBoostedHbb2Wj = ElBoostedSelObjJetsIdxPerJpaNodeDict.get('Hbb2Wj')[0]
ElSelObjBoostedHbb2WjJets = ElBoostedSelObjJetsIdxPerJpaNodeDict.get('Hbb2Wj')[1]
MuSelObjBoostedHbb2Wj = MuBoostedSelObjJetsIdxPerJpaNodeDict.get('Hbb2Wj')[0]
MuSelObjBoostedHbb2WjJets = MuBoostedSelObjJetsIdxPerJpaNodeDict.get('Hbb2Wj')[1]
if not self.args.OnlyYield:
ChannelDictListB.append({'channel':'El','selObj':ElSelObjBoostedHbb2Wj, 'sel':ElSelObjBoostedHbb2Wj.sel,
'lep':ElColl[0],'met':self.corrMET,'jpaSelectedJets':ElSelObjBoostedHbb2WjJets,
'jet1':self.ak8BJets[0],'jet2':None,'jet3':ElSelObjBoostedHbb2WjJets[0],'jet4':ElSelObjBoostedHbb2WjJets[1],
'has1fat1slim':False,'has1fat2slim':True,'bothAreFat':False,
'suffix':ElSelObjBoostedHbb2Wj.selName,
'is_MC':self.is_MC, 'jpaArg':'Hbb2Wj'})
ChannelDictListB.append({'channel':'Mu','selObj':MuSelObjBoostedHbb2Wj,'sel':MuSelObjBoostedHbb2Wj.sel,
'lep':MuColl[0],'met':self.corrMET,'jpaSelectedJets':MuSelObjBoostedHbb2WjJets,
'jet1':self.ak8BJets[0],'jet2':None,'jet3':MuSelObjBoostedHbb2WjJets[0],'jet4':MuSelObjBoostedHbb2WjJets[1],
'has1fat1slim':False,'has1fat2slim':True,'bothAreFat':False,
'suffix':MuSelObjBoostedHbb2Wj.selName,
'is_MC':self.is_MC, 'jpaArg':'Hbb2Wj'})
if "Hbb1Wj" in jetplot_level or "Boosted" in jetplot_level:
print ('...... JPA : Hbb1Wj Node Selection')
ElSelObjBoostedHbb1Wj = ElBoostedSelObjJetsIdxPerJpaNodeDict.get('Hbb1Wj')[0]
ElSelObjBoostedHbb1WjJets = ElBoostedSelObjJetsIdxPerJpaNodeDict.get('Hbb1Wj')[1]
MuSelObjBoostedHbb1Wj = MuBoostedSelObjJetsIdxPerJpaNodeDict.get('Hbb1Wj')[0]
MuSelObjBoostedHbb1WjJets = MuBoostedSelObjJetsIdxPerJpaNodeDict.get('Hbb1Wj')[1]
if not self.args.OnlyYield:
ChannelDictListB.append({'channel':'El','selObj':ElSelObjBoostedHbb1Wj,'sel':ElSelObjBoostedHbb1Wj.sel,
'lep':ElColl[0],'met':self.corrMET,'jpaSelectedJets':ElSelObjBoostedHbb1WjJets,
'jet1':self.ak8BJets[0],'jet2':None,'jet3':ElSelObjBoostedHbb1WjJets[0],'jet4':None,
'has1fat1slim':True,'has1fat2slim':False,'bothAreFat':False,
'suffix':ElSelObjBoostedHbb1Wj.selName,
'is_MC':self.is_MC, 'jpaArg':'Hbb1Wj'})
ChannelDictListB.append({'channel':'Mu','selObj':MuSelObjBoostedHbb1Wj,'sel':MuSelObjBoostedHbb1Wj.sel,
'lep':MuColl[0],'met':self.corrMET,'jpaSelectedJets':MuSelObjBoostedHbb1WjJets,
'jet1':self.ak8BJets[0],'jet2':None,'jet3':MuSelObjBoostedHbb1WjJets[0],'jet4':None,
'has1fat1slim':True,'has1fat2slim':False,'bothAreFat':False,
'suffix':MuSelObjBoostedHbb1Wj.selName,
'is_MC':self.is_MC, 'jpaArg':'Hbb1Wj'})
if "Hbb0Wj" in jetplot_level or "Boosted" in jetplot_level:
print ('...... JPA : Hbb0Wj Node Selection')
ElSelObjBoostedHbb0Wj = ElBoostedSelObjJetsIdxPerJpaNodeDict.get('Hbb0Wj')[0]
MuSelObjBoostedHbb0Wj = MuBoostedSelObjJetsIdxPerJpaNodeDict.get('Hbb0Wj')[0]
if not self.args.OnlyYield:
ChannelDictListB.append({'channel':'El','selObj':ElSelObjBoostedHbb0Wj,'sel':ElSelObjBoostedHbb0Wj.sel,
'lep':ElColl[0],'met':self.corrMET,'jpaSelectedJets':None,
'jet1':self.ak8BJets[0],'jet2':None,'jet3':None,'jet4':None,
'has1fat1slim':False,'has1fat2slim':False,'bothAreFat':False,
'suffix':ElSelObjBoostedHbb0Wj.selName,
'is_MC':self.is_MC, 'jpaArg':'Hbb0Wj'})
ChannelDictListB.append({'channel':'Mu','selObj':MuSelObjBoostedHbb0Wj,'sel':MuSelObjBoostedHbb0Wj.sel,
'lep':MuColl[0],'met':self.corrMET,'jpaSelectedJets':None,
'jet1':self.ak8BJets[0],'jet2':None,'jet3':None,'jet4':None,
'has1fat1slim':False,'has1fat2slim':False,'bothAreFat':False,
'suffix':MuSelObjBoostedHbb0Wj.selName,
'is_MC':self.is_MC, 'jpaArg':'Hbb0Wj'})
for channelDict in ChannelDictListB:
if any(['Hbb2Wj','Hbb1Wj']) in jetplot_level:
# Dilepton #
plots.extend(makeSinleptonPlots(**{k:channelDict[k] for k in LeptonKeys}))
# Number of jets #
##plots.append(objectsNumberPlot(**{k:channelDict[k] for k in commonItems},**FatJetsN))
##plots.append(objectsNumberPlot(**{k:channelDict[k] for k in commonItems},**SlimJetsN))
# Ak8 Jets #
plots.extend(makeSingleLeptonAk8JetsPlots(**{k:channelDict[k] for k in FatJetKeys},nMedBJets=self.nMediumBTaggedSubJets, HLL=self.HLL))
# MET #
plots.extend(makeMETPlots(**{k:channelDict[k] for k in commonItems}, met=self.corrMET))
# HighLevel #
##plots.extend(makeHighLevelPlotsBoosted(**{k:channelDict[k] for k in BoostedKeys}, HLL=self.HLL))
inputsCommon = returnCommonInputs_Boosted(self)
inputsClassic = returnClassicInputs_Boosted(self, **{k:channelDict[k] for k in ClassicInputKeys})
inputsLBN = returnLBNInputs_Boosted(self, **{k:channelDict[k] for k in LBNInputKeys})
input_names = [key[0] for key in inputsClassic.keys()] + ['LBN_inputs','eventnr']
inputs_array = [op.array("double",val) for val in inputStaticCast(inputsCommon,"float")]
inputs_array.append(op.array("double",*inputStaticCast(inputsClassic,"float")))
inputs_array.append(op.array("double",*inputStaticCast(inputsLBN,"float")))
inputs_array.append(op.array("long",*inputStaticCast(inputsEventNr,"long")))
DNN_SM = op.mvaEvaluator (path_model_boosted_SM, mvaType='Tensorflow',otherArgs=(input_names, output_name))
DNN_BSM = op.mvaEvaluator(path_model_boosted_BSM, mvaType='Tensorflow',otherArgs=(input_names, output_name))
DNN_Score_SM = DNN_SM (*inputs_array)
DNN_Score_BSM = DNN_BSM (*inputs_array)
selObjNodesDict_SM = makeDNNOutputNodesSelections(self,channelDict['selObj'],DNN_Score_SM,suffix='_SM_')
selObjNodesDict_BSM = makeDNNOutputNodesSelections(self,channelDict['selObj'],DNN_Score_BSM,suffix='_BSM_')
logger.info('Filling DNN responses Boosted')
plots.extend(makeDoubleLeptonMachineLearningOutputPlots(selObjNodesDict_SM,DNN_Score_SM,self.nodes,channel=selObjectDNNDict['channel']))
plots.extend(makeDoubleLeptonMachineLearningOutputPlots(selObjNodesDict_BSM,DNN_Score_BSM,self.nodes,channel=selObjectDNNDict['channel']))
#----- Add the Yield plots -----#
plots.append(self.yields)
#plots.extend(cutFlowPlots)
return plots
def definePlots(self, t, noSel, sample=None, sampleCfg=None):
from bamboo.plots import CutFlowReport, SummedPlot
from bamboo.plots import EquidistantBinning as EqB
from bamboo import treefunctions as op
isMC = self.isMC(sample)
trigCut, trigWeight = None, None
if isMC:
trigCut = op.OR(t.HLT.HIEle20_Ele12_CaloIdL_TrackIdL_IsoVL_DZ, t.HLT.HIL3DoubleMu0, t.HLT.HIL3Mu20, t.HLT.HIEle20_WPLoose_Gsf)
trigWeight = op.switch(op.OR(t.HLT.HIEle20_Ele12_CaloIdL_TrackIdL_IsoVL_DZ, t.HLT.HIL3DoubleMu0), op.c_float(1.),
op.switch(t.HLT.HIL3Mu20, op.c_float(306.913/308.545), op.c_float(264.410/308.545))) ## FIXME these are wrong - you will get the final values from team A
else:
## trigger order: dielectron, dimuon or single muon, single electron
pd = sample.split("_")[0]
if pd == "SingleMuon":
trigCut = op.AND(op.NOT(t.HLT.HIEle20_Ele12_CaloIdL_TrackIdL_IsoVL_DZ),
op.OR(t.HLT.HIL3DoubleMu0, t.HLT.HIL3Mu20))
elif pd == "HighEGJet":
trigCut = op.OR(t.HLT.HIEle20_Ele12_CaloIdL_TrackIdL_IsoVL_DZ,
op.AND(op.NOT(op.OR(t.HLT.HIL3DoubleMu0, t.HLT.HIL3Mu20)),
t.HLT.HIEle20_WPLoose_Gsf))
noSel = noSel.refine("trig", cut=trigCut, weight=trigWeight)
plots = []
def isGoodElectron(el, ptCut=10.):
return op.AND(
el.pt > ptCut,
op.abs(el.eta) < 2.5,
el.lostHits == 0, ## do you want this?
op.abs(el.sip3d) < 8.,
op.abs(el.dxy) < .05,
op.abs(el.dz ) < .1,
el.miniPFRelIso_all < 0.085,
el.mvaTTH > 0.125,
op.NOT(op.AND(el.jet.isValid, op.OR(el.jet.btagDeepB > .1522, el.jet.btagDeepB <= -999.)))
)
def isGoodMuon(mu, ptCut=10.):
return op.AND(
mu.pt > ptCut,
op.abs(mu.eta) < 2.4,
mu.mediumPromptId,
op.abs(mu.sip3d) < 8.,
op.abs(mu.dxy) < .05,
op.abs(mu.dz ) < .1,
mu.miniPFRelIso_all < 0.325,
mu.mvaTTH > 0.55,
op.NOT(op.AND(mu.jet.isValid, op.OR(mu.jet.btagDeepB > .1522, mu.jet.btagDeepB <= -999.)))
)
goodLeptons = {
"el" : op.select(t.Electron, partial(isGoodElectron, ptCut=15.)),
"mu" : op.select(t.Muon, partial(isGoodMuon, ptCut=15.))
}
plots += [
Plot.make1D("trig_nLeptons15", op.rng_len(goodLeptons["el"])+op.rng_len(goodLeptons["mu"]), noSel, EqB(15, 0., 15.)),
Plot.make1D("trig_nEl15", op.rng_len(goodLeptons["el"]), noSel, EqB(15, 0., 15.)),
Plot.make1D("trig_nMu15", op.rng_len(goodLeptons["mu"]), noSel, EqB(15, 0., 15.))
]
from bamboo.scalefactors import get_scalefactor
sf_loose = {
"mu": get_scalefactor("lepton", "Muon_RecoToLoose", sfLib=scalefactors_lepMVA, paramDefs=binningVariables_nano_noScaleSyst, systName="muLoose"),
"el": get_scalefactor("lepton", "Electron_RecoToLoose", sfLib=scalefactors_lepMVA, paramDefs=binningVariables_nano_noScaleSyst, systName="elLoose")
}
sf_tight = {
"mu": get_scalefactor("lepton", "Muon_LooseToTight", sfLib=scalefactors_lepMVA, paramDefs=binningVariables_nano_noScaleSyst, systName="muTight"),
"el": get_scalefactor("lepton", "Electron_LooseToTight", sfLib=scalefactors_lepMVA, paramDefs=binningVariables_nano_noScaleSyst, systName="elTight")
}
nGoodLeptons = op.rng_len(goodLeptons["el"])+op.rng_len(goodLeptons["mu"])
hasTwoGoodLeptons = noSel.refine("has2Lep", cut=(nGoodLeptons > 1)) # avoid overlap with 1l
jets = op.sort(op.select(t.Jet, lambda j : op.AND(
j.pt > 25.,
op.abs(j.eta) < 2.4,
j.jetId & 0x2,
op.AND(
op.NOT(op.rng_any(goodLeptons["el"], lambda l : op.deltaR(l.p4, j.p4) < 0.4)),
op.NOT(op.rng_any(goodLeptons["mu"], lambda l : op.deltaR(l.p4, j.p4) < 0.4)))
)), lambda j : -j.pt)
## WP: see https://twiki.cern.ch/twiki/bin/viewauth/CMS/BtagRecommendation94X
loosebjets = op.select(jets, lambda j : j.btagDeepB > 0.1522)
mediumbjets = op.select(jets, lambda j : j.btagDeepB > 0.4941)
for fl1,fl2 in product(*repeat(goodLeptons.keys(), 2)):
dilepSel = lambda l1,l2 : op.AND(
l1.charge != l2.charge,
(l1.p4+l2.p4).M() > 12.
)
if fl1 == fl2:
lGood = op.sort(goodLeptons[fl1], lambda l : -l.pt)
dilep = op.combine(lGood, N=2, pred=dilepSel)
else:
l1Good = op.sort(goodLeptons[fl1], lambda l : -l.pt)
l2Good = op.sort(goodLeptons[fl2], lambda l : -l.pt)
dilep = op.combine((l1Good, l2Good), pred=dilepSel)
ll = dilep[0]
hasDilep = hasTwoGoodLeptons.refine(f"hasDilep{fl1}{fl2}", cut=(op.rng_len(dilep) > 0, ll[0].pt > 25.),
weight=([ sf_loose[fl1](ll[0]), sf_loose[fl2](ll[1]), sf_tight[fl1](ll[0]), sf_tight[fl2](ll[1]) ] if isMC else None))
plots += [
Plot.make1D(f"dilepton_{fl1}{fl2}_Mll", (ll[0].p4+ll[1].p4).M(), hasDilep, EqB(50, 70, 120.), title="Dilepton mass"),
]
# for il,ifl in enumerate((fl1, fl2)):
## plots += [
# Plot.make1D(f"dilepton_{fl1}{fl2}_L{il:d}PT", ll[il].pt, hasDilep, EqB(50, 0., 100.), title=f"Lepton {il:d} PT"),
# Plot.make1D(f"dilepton_{fl1}{fl2}_L{il:d}ETA", ll[il].eta, hasDilep, EqB(50, -2.5, 2.5), title=f"Lepton {il:d} ETA"),
# ]
# plots += [
# Plot.make1D(f"dilepton_{fl1}{fl2}_nJets", op.rng_len(jets), hasDilep, EqB(15, 0, 15.), title="Jet multiplicity"),
# Plot.make1D(f"dilepton_{fl1}{fl2}_nLooseBJets", op.rng_len(loosebjets), hasDilep, EqB(15, 0, 15.), title="Loose b-jet multiplicity"),
# Plot.make1D(f"dilepton_{fl1}{fl2}_nMediumBJets", op.rng_len(mediumbjets), hasDilep, EqB(15, 0, 15.), title="Medium b-jet multiplicity")
# ]
return plots
def returnJetsMVAInputs(self,jets):
return {('j1_E', 'Lead jet E [GeV]', (50,0.,500.)) : op.switch(op.rng_len(jets)>0,jets[0].p4.E(),op.c_float(0.)),
('j1_Px', 'Lead jet P_x [GeV]', (40,-200.,200.)) : op.switch(op.rng_len(jets)>0,jets[0].p4.Px(),op.c_float(0.)),
('j1_Py', 'Lead jet P_y [GeV]', (40,-200.,200.)) : op.switch(op.rng_len(jets)>0,jets[0].p4.Py(),op.c_float(0.)),
('j1_Pz', 'Lead jet P_z [GeV]', (40,-200.,200.)) : op.switch(op.rng_len(jets)>0,jets[0].p4.Pz(),op.c_float(0.)),
('j1_btag', 'Lead jet btag score', (50,0.,1.) ) : op.switch(op.rng_len(jets)>0,jets[0].btagDeepFlavB,op.c_float(0.)),
('j2_E', 'Sublead jet E [GeV]', (50,0.,500.)) : op.switch(op.rng_len(jets)>1,jets[1].p4.E(),op.c_float(0.)),
('j2_Px', 'Sublead jet P_x [GeV]', (40,-200.,200.)) : op.switch(op.rng_len(jets)>1,jets[1].p4.Px(),op.c_float(0.)),
('j2_Py', 'Sublead jet P_y [GeV]', (40,-200.,200.)) : op.switch(op.rng_len(jets)>1,jets[1].p4.Py(),op.c_float(0.)),
('j2_Pz', 'Sublead jet P_z [GeV]', (40,-200.,200.)) : op.switch(op.rng_len(jets)>1,jets[1].p4.Pz(),op.c_float(0.)),
('j2_btag', 'Sublead jet btag score', (50,0.,1.) ) : op.switch(op.rng_len(jets)>1,jets[1].btagDeepFlavB,op.c_float(0.)),
('j3_E', 'Subsublead jet E [GeV]', (50,0.,500.)) : op.switch(op.rng_len(jets)>2,jets[2].p4.E(),op.c_float(0.)),
('j3_Px', 'Subsublead jet P_x [GeV]', (40,-200.,200.)) : op.switch(op.rng_len(jets)>2,jets[2].p4.Px(),op.c_float(0.)),
('j3_Py', 'Subsublead jet P_y [GeV]', (40,-200.,200.)) : op.switch(op.rng_len(jets)>2,jets[2].p4.Py(),op.c_float(0.)),
('j3_Pz', 'Subsublead jet P_z [GeV]', (40,-200.,200.)) : op.switch(op.rng_len(jets)>2,jets[2].p4.Pz(),op.c_float(0.)),
('j3_btag', 'Subsublead jet btag score', (50,0.,1.) ) : op.switch(op.rng_len(jets)>2,jets[2].btagDeepFlavB,op.c_float(0.)),
('j4_E', 'Subsubsublead jet E [GeV]', (50,0.,500.)) : op.switch(op.rng_len(jets)>3,jets[3].p4.E(),op.c_float(0.)),
('j4_Px', 'Subsubsublead jet P_x [GeV]', (40,-200.,200.)) : op.switch(op.rng_len(jets)>3,jets[3].p4.Px(),op.c_float(0.)),
('j4_Py', 'Subsubsublead jet P_y [GeV]', (40,-200.,200.)) : op.switch(op.rng_len(jets)>3,jets[3].p4.Py(),op.c_float(0.)),
('j4_Pz', 'Subsubsublead jet P_z [GeV]', (40,-200.,200.)) : op.switch(op.rng_len(jets)>3,jets[3].p4.Pz(),op.c_float(0.)),
('j4_btag', 'Subsubsublead jet btag score', (50,0.,1.) ) : op.switch(op.rng_len(jets)>3,jets[3].btagDeepFlavB,op.c_float(0.))}
def findJPACategoryResolved (self, selObj, lepton, muons, electrons, jets, bJetsL, bJetsM, met, modelPathDict, event, HLL, nodeList, plot_yield=False):
JPAfuncDict = {'f1':evaluateJPA_2b2Wj,
'f2':evaluateJPA_2b1Wj,
'f3':evaluateJPA_1b2Wj,
'f4':evaluateJPA_2b0Wj,
'f5':evaluateJPA_1b1Wj,
'f6':evaluateJPA_1b0Wj}
JPAMaxScoreList = []
bestCombo_per_cat = []
combo2_1b0W_1Wj = op.combine(jets, N=2, samePred=lambda j1,j2 : j1.idx != j2.idx)
combo2_2b0Wj = op.combine(jets, N=2, pred=lambda j1,j2 : j1.pt > j2.pt, samePred=lambda j1,j2 : j1.idx != j2.idx)
combo3_1b2Wj = op.combine(jets, N=3, pred=lambda j1,j2,j3 : j2.pt > j3.pt, samePred=lambda j1,j2 : j1.idx != j2.idx)
combo3_2b1Wj = op.combine(jets, N=3, pred=lambda j1,j2,j3 : j1.pt > j2.pt, samePred=lambda j1,j2 : j1.idx != j2.idx)
combo4 = op.combine(jets, N=4, pred=lambda j1,j2,j3,j4 : op.AND(j1.pt > j2.pt, j3.pt > j4.pt), samePred=lambda j1,j2 : j1.idx != j2.idx)
funckeys = [k for k in JPAfuncDict.keys()]
for idx, func in enumerate(funckeys):
node = nodeList[idx]
modelpaths = modelPathDict.get(node)
model = makeOddEvenEvaluator(event%2, modelpaths[1], modelpaths[0], mvaType="TMVA")
lambdaFunc = lambda jetCombo : JPAfuncDict[func](lepton, muons, electrons, jets, jetCombo, bJetsL, bJetsM, met, model, HLL)
if idx == 0:
best = op.rng_max_element_by(combo4, lambdaFunc)
maxScore = op.switch(best.idx != -1, best.idx.op.this.result.second, op.c_float(-1.))
#best.idx.op.this.canDefine=False
elif idx == 1:
best = op.rng_max_element_by(combo3_2b1Wj, lambdaFunc) ## hack: index of best is first in a pair, with the maximum value as second
maxScore = best.idx.op.this.result.second
elif idx == 2:
best = op.rng_max_element_by(combo3_1b2Wj, lambdaFunc) ## hack: index of best is first in a pair, with the maximum value as second
maxScore = best.idx.op.this.result.second
elif idx == 3:
best = op.rng_max_element_by(combo2_2b0Wj, lambdaFunc) ## hack: index of best is first in a pair, with the maximum value as second
maxScore = best.idx.op.this.result.second
elif idx == 4:
best = op.rng_max_element_by(combo2_1b0W_1Wj, lambdaFunc) ## hack: index of best is first in a pair, with the maximum value as second
maxScore = best.idx.op.this.result.second
else:
best = op.rng_max_element_by(combo2_1b0W_1Wj, lambdaFunc) ## hack: index of best is first in a pair, with the maximum value as second
maxScore = best.idx.op.this.result.second
JPAMaxScoreList.append(op.pow((1.0 + op.sqrt((1 - maxScore)/(1 + maxScore))), -1))
#JPAMaxScoreList.append(maxScore)
bestCombo_per_cat.append(best)
evtCat = makeOddEvenEvaluator(event%2, modelPathDict.get('evCat')[1], modelPathDict.get('evCat')[0], mvaType="TMVA")
evtCatOutList = evtCat(*JPAMaxScoreList)
maxIdx = op.rng_max_element_index(evtCatOutList)
newSelObj = copy(selObj)
selObjJPAjetsIdxDict = {}
for i, node in enumerate(nodeList):
outSelObj = copy(newSelObj)
outSelObj.selName += '%s'%node
outSelObj.yieldTitle += " in %s node"%node
outSelObj.refine(cut = (maxIdx == i))
if i < 6:
selObjJPAjetsIdxDict[node] = [outSelObj, bestCombo_per_cat[i]]
else:
selObjJPAjetsIdxDict[node] = [outSelObj, None]
return JPAMaxScoreList, evtCatOutList, selObjJPAjetsIdxDict
def returnHighLevelMVAInputs(self, lep, conep4, bjets, wjets, VBFJetPairs, channel):
if channel == 'El':
lepconept = self.electron_conept[lep.idx]
elif channel == 'Mu':
lepconept = self.muon_conept[lep.idx]
else:
raise RuntimeError('Please mention the correct channel name!')
import bamboo.treeoperations as _to
def rng_min(rng, fun=(lambda x : x), typeName="float"):
return op._to.Reduce.fromRngFun(rng, op.c_float(float("+inf"), typeName), ( lambda fn : (
lambda res, elm : op.extMethod("std::min", returnType="Float_t")(res, fn(elm))
) )(fun) )
return {
#('m_hh_bregcorr', 'm_hh_bregcorr', (50,0,400)) : self.HLL.comp_m_hh_bregcorr(bjets, wjets, lep, self.corrMET),
('m_hh_bregcorr', 'm_hh_bregcorr', (50,0,400)) : self.HLL.comp_m_hh_bregcorr(bjets, wjets, conep4, self.corrMET),
#('pt_hh', 'pt_hh', (50,0,400)) : self.HLL.comp_pt_hh(bjets, wjets, lep, self.corrMET),
('pt_hh', 'pt_hh', (50,0,400)) : self.HLL.comp_pt_hh(bjets, wjets, conep4, self.corrMET),
('m_hbb_bregcorr', 'm_hbb_bregcorr', (25,0,200)) : op.multiSwitch((op.rng_len(bjets) == 0, op.c_float(0.)),
(op.rng_len(bjets) == 1, self.HLL.getCorrBp4(bjets[0]).M()),
op.invariant_mass(self.HLL.getCorrBp4(bjets[0]),self.HLL.getCorrBp4(bjets[1]))),
('pt_hbb', 'pt_hbb', (25,0,200)) : op.multiSwitch((op.rng_len(bjets) == 0, op.c_float(0.)),
(op.rng_len(bjets) == 1, bjets[0].pt),
(bjets[0].p4 + bjets[1].p4).Pt()),
#('m_hww', 'm_hww', (25,0,200)) : op.multiSwitch((op.rng_len(wjets) >= 2, op.invariant_mass(wjets[0].p4 ,wjets[1].p4, self.corrMET.p4, lep.p4)),
# (op.rng_len(wjets) == 1, op.invariant_mass(wjets[0].p4 ,self.corrMET.p4, lep.p4)),
# op.invariant_mass(self.corrMET.p4, lep.p4)),
('m_hww', 'm_hww', (25,0,200)) : op.multiSwitch((op.rng_len(wjets) >= 2, op.invariant_mass(wjets[0].p4 ,wjets[1].p4, self.corrMET.p4, conep4)),
(op.rng_len(wjets) == 1, op.invariant_mass(wjets[0].p4 ,self.corrMET.p4, conep4)),
op.invariant_mass(self.corrMET.p4, conep4)),
#('pt_hww', 'pt_hww', (25,0,200)) : op.multiSwitch((op.rng_len(wjets) >= 2, (wjets[0].p4 + wjets[1].p4 + self.corrMET.p4 + lep.p4).Pt()),
# (op.rng_len(wjets) == 1, (wjets[0].p4 + self.corrMET.p4 + lep.p4).Pt()),
# (self.corrMET.p4 + lep.p4).Pt()),
('pt_hww', 'pt_hww', (25,0,200)) : op.multiSwitch((op.rng_len(wjets) >= 2, (wjets[0].p4 + wjets[1].p4 + self.corrMET.p4 + conep4).Pt()),
(op.rng_len(wjets) == 1, (wjets[0].p4 + self.corrMET.p4 + conep4).Pt()),
(self.corrMET.p4 + conep4).Pt()),
('m_wjj', 'm_wjj', (25,0,200)) : op.multiSwitch((op.rng_len(wjets) >= 2, op.invariant_mass(wjets[0].p4 ,wjets[1].p4)),
(op.rng_len(wjets) == 1, wjets[0].mass),
op.c_float(0.)),
('pt_wjj', 'pt_wjj', (25,0,200)) : op.multiSwitch((op.rng_len(wjets) >= 2, (wjets[0].p4 + wjets[1].p4).Pt()),
(op.rng_len(wjets) == 1, wjets[0].pt),
op.c_float(0.)),
#('m_wlep', 'm_wlep', (25,0,200)) : op.invariant_mass(self.corrMET.p4, lep.p4),
('m_wlep', 'm_wlep', (25,0,200)) : op.invariant_mass(self.corrMET.p4, conep4),
#('pt_wlep', 'pt_wlep', (25,0,200)) : (self.corrMET.p4 + lep.p4).Pt(),
('pt_wlep', 'pt_wlep', (25,0,200)) : (self.corrMET.p4 + conep4).Pt(),
('min_dr_lepbjets', 'min_dr_lepbjets', (25,0,5)) : op.switch(op.rng_len(bjets) > 0, self.HLL.MinDR_part1_partCont(lep, bjets), op.c_float(0.)),
#('dphi_hbb_hww', 'dphi_hbb_hww', (22,0,3.2)) : op.abs(self.HLL.comp_dphi_hbb_hww(bjets, wjets, lep, self.corrMET)),
('dphi_hbb_hww', 'dphi_hbb_hww', (22,0,3.2)) : op.abs(self.HLL.comp_dphi_hbb_hww(bjets, wjets, conep4, self.corrMET)),
#('dphi_hbb_hwwvis', 'dphi_hbb_hwwvis', (22,0,3.2)) : op.abs(self.HLL.comp_dphi_hbb_hwwvis(bjets, wjets, lep)),
('dphi_hbb_hwwvis', 'dphi_hbb_hwwvis', (22,0,3.2)) : op.abs(self.HLL.comp_dphi_hbb_hwwvis(bjets, wjets, conep4)),
#('dphi_met_lep', 'dphi_met_lep', (22,0,3.2)) : op.abs(op.deltaPhi(self.corrMET.p4, lep.p4)),
('dphi_met_lep', 'dphi_met_lep', (22,0,3.2)) : op.abs(op.deltaPhi(self.corrMET.p4, conep4)),
('dphi_met_hbb', 'dphi_met_hbb', (22,0,3.2)) : op.multiSwitch((op.rng_len(bjets) >= 2, op.abs(op.deltaPhi(self.corrMET.p4,(bjets[0].p4 + bjets[1].p4)))),
(op.rng_len(bjets) == 1, op.abs(op.deltaPhi(self.corrMET.p4, bjets[0].p4))),
op.c_float(0.)),
('dphi_met_wjj', 'dphi_met_wjj', (22,0,3.2)) : op.multiSwitch((op.rng_len(wjets) >= 2, op.abs(op.deltaPhi(self.corrMET.p4,(wjets[0].p4 + wjets[1].p4)))),
(op.rng_len(wjets) == 1, op.abs(op.deltaPhi(self.corrMET.p4,wjets[0].p4))),
op.c_float(0.)),
('dr_lep_hbb', 'dr_lep_hbb', (25,0,5)) : op.multiSwitch((op.rng_len(bjets) >= 2, op.deltaR(conep4, (bjets[0].p4+bjets[1].p4))),
(op.rng_len(bjets) == 1, op.deltaR(conep4, bjets[0].p4)),
op.c_float(0.)),
('dr_lep_wjj', 'dr_lep_wjj', (25,0,5)) : op.multiSwitch((op.rng_len(wjets) >= 2, op.deltaR(conep4, (wjets[0].p4+wjets[1].p4))),
(op.rng_len(wjets) == 1, op.deltaR(conep4, wjets[0].p4)),
op.c_float(0.)),
('min_dr_wjets', 'min_dr_wjets', (25,0,5)) : op.switch(op.rng_len(wjets) >= 2, op.deltaR(wjets[0].p4, wjets[1].p4), op.c_float(0.)),
('min_dhi_wjets', 'min_dphi_wjets', (22,0,3.2)) : op.switch(op.rng_len(wjets) >= 2, op.abs(op.deltaPhi(wjets[0].p4,wjets[1].p4)),op.c_float(0.)),
('min_dr_bjets', 'min_dr_bjets', (25,0,5)) : op.switch(op.rng_len(bjets) >= 2, op.deltaR(bjets[0].p4,bjets[1].p4), op.c_float(0.)),
('min_dphi_bjets', 'min_dphi_bjets', (22,0,3.2)) : op.switch(op.rng_len(bjets) >= 2, op.abs(op.deltaPhi(bjets[0].p4,bjets[1].p4)),op.c_float(0.)),
('ht', 'ht', (50,0,300)) : op.rng_sum(self.ak4Jets, lambda j : j.pt),
#('smin', 'smin', (50,0,300)) : self.HLL.comp_smin(lep,self.corrMET,self.ak4Jets,bjets,wjets),
('smin', 'smin', (50,0,300)) : self.HLL.comp_smin(conep4,self.corrMET,self.ak4Jets,bjets,wjets),
('vbf_pair_mass', 'vbf_pair_mass', (50,0,300)) : op.switch(op.rng_len(VBFJetPairs) > 0,op.invariant_mass(VBFJetPairs[0][0].p4, VBFJetPairs[0][1].p4),
op.c_float(0.)),
('vbf_pairs_absdeltaeta', 'vbf_pairs_absdeltaeta', (22,0,3.2)) : op.switch(op.rng_len(VBFJetPairs) > 0,op.abs(VBFJetPairs[0][0].eta - VBFJetPairs[0][1].eta),
op.c_float(0.)),
('lep_conept', 'lep_conept', (25,0,200)) : lepconept,
('VBF_tag', 'vbf_tag', (2,0,2)) : op.c_int(op.rng_len(VBFJetPairs) > 0),
('boosted_tag', 'boosted_tag', (2,0,2)) : op.c_int(op.rng_len(self.ak8BJets) > 0),
('n_btag', 'n_btag', (5,0,5)) : op.c_float(op.rng_len(self.ak4BJets)),
('sphericity', 'sphericity', (1,0,1)) : op.c_float(0.), # not used
('sphericity_T', 'sphericity_T', (1,0,1)) : op.c_float(0.), # not used
('aplanarity', 'aplanarity', (1,0,1)) : op.c_float(0.), # not used
('eventshape_C', 'eventshape_C', (1,0,1)) : op.c_float(0.), # not used
('eventshape_D', 'eventshape_D', (1,0,1)) : op.c_float(0.), # not used
('eventshape_Y', 'eventshape_Y', (1,0,1)) : op.c_float(0.), # not used
('foxwolfram1', 'foxwolfram1', (1,0,1)) : op.c_float(0.), # not used
('foxwolfram2', 'foxwolfram2', (1,0,1)) : op.c_float(0.), # not used
('foxwolfram3', 'foxwolfram3', (1,0,1)) : op.c_float(0.), # not used
('foxwolfram4', 'foxwolfram4', (1,0,1)) : op.c_float(0.), # not used
('foxwolfram5', 'foxwolfram5', (1,0,1)) : op.c_float(0.), # not used
('centrality', 'centrality', (1,0,1)) : op.c_float(0.), # not used
('centrality_jets', 'centrality_jets', (1,0,1)) : op.c_float(0.), # not used
('eigenvalue1', 'eigenvalue1', (1,0,1)) : op.c_float(0.), # not used
('eigenvalue2', 'eigenvalue2', (1,0,1)) : op.c_float(0.), # not used
('eigenvalue3', 'eigenvalue3', (1,0,1)) : op.c_float(0.), # not used
('sphericity_met', 'sphericity_met', (1,0,1)) : op.c_float(0.), # not used
('sphericity_T_met', 'sphericity_T_met', (1,0,1)) : op.c_float(0.), # not used
('aplanarity_met', 'aplanarity_met', (1,0,1)) : op.c_float(0.), # not used
('eventshape_C_met', 'eventshape_C_met', (1,0,1)) : op.c_float(0.), # not used
('eventshape_D_met', 'eventshape_D_met', (1,0,1)) : op.c_float(0.), # not used
('eventshape_Y_met', 'eventshape_Y_met', (1,0,1)) : op.c_float(0.), # not used
('foxwolfram1_met', 'foxwolfram1_met', (1,0,1)) : op.c_float(0.), # not used
('foxwolfram2_met', 'foxwolfram2_met', (1,0,1)) : op.c_float(0.), # not used
('foxwolfram3_met', 'foxwolfram3_met', (1,0,1)) : op.c_float(0.), # not used
('foxwolfram4_met', 'foxwolfram4_met', (1,0,1)) : op.c_float(0.), # not used
('foxwolfram5_met', 'foxwolfram5_met', (1,0,1)) : op.c_float(0.), # not used
('centrality_met', 'centrality_met', (1,0,1)) : op.c_float(0.), # not used
('centrality_jets_met','centrality_jets_met', (1,0,1)) : op.c_float(0.), # not used
('eigenvalue1_met', 'eigenvalue1_met', (1,0,1)) : op.c_float(0.), # not used
('eigenvalue2_met', 'eigenvalue2_met', (1,0,1)) : op.c_float(0.), # not used
('eigenvalue3_met', 'eigenvalue3_met', (1,0,1)) : op.c_float(0.) # not used
}
def defineSkimSelection(self, t, noSel, sample=None, sampleCfg=None):
noSel = super(SkimmerNanoHHtobbWWDL,
self).prepareObjects(t,
noSel,
sample,
sampleCfg,
"DL",
forSkimmer=True)
# For the Skimmer, SF must not use defineOnFirstUse -> segmentation fault
era = sampleCfg['era']
#self.datadrivenContributions = {} # Avoid all data-driven estimates
# Initialize varsToKeep dict #
varsToKeep = dict()
#---------------------------------------------------------------------------------------#
# Selections #
#---------------------------------------------------------------------------------------#
if not self.inclusive_sel:
#----- Check arguments -----#
lepton_level = [
"Preselected", "Fakeable", "Tight", "FakeExtrapolation"
] # Only one must be in args
jet_level = [
"Ak4", "Ak8", "Resolved0Btag", "Resolved1Btag",
"Resolved2Btag", "Boosted"
] # Only one must be in args
if [
boolean for (level, boolean) in self.args.__dict__.items()
if level in lepton_level
].count(True) != 1:
raise RuntimeError(
"Only one of the lepton arguments must be used, check --help"
)
if [
boolean for (level, boolean) in self.args.__dict__.items()
if level in jet_level
].count(True) != 1:
raise RuntimeError(
"Only one of the jet arguments must be used, check --help")
if self.args.Channel not in ["ElEl", "MuMu", "ElMu"]:
raise RuntimeError(
"Channel must be either 'ElEl', 'MuMu' or 'ElMu'")
#----- Lepton selection -----#
# Args are passed within the self #
selLeptonDict = makeDoubleLeptonSelection(self,
noSel,
use_dd=False)
# makeDoubleLeptonSelection returns dict -> value is list of three selections for 3 channels
# [0] -> we take the first and only key and value because restricted to one lepton selection
selLeptonList = list(selLeptonDict.values())[0]
if self.args.Channel == "ElEl":
selObj = selLeptonList[
0] # First item of list is ElEl selection
if self.args.Channel == "MuMu":
selObj = selLeptonList[
1] # Second item of list is MuMu selection
if self.args.Channel == "ElMu":
selObj = selLeptonList[
2] # Third item of list is ElMu selection
#----- Jet selection -----#
# Since the selections in one line, we can use the non copy option of the selection to modify the selection object internally
if any([
self.args.__dict__[item] for item in
["Ak4", "Resolved0Btag", "Resolved1Btag", "Resolved2Btag"]
]):
makeAtLeastTwoAk4JetSelection(self, selObj, use_dd=False)
if any([self.args.__dict__[item] for item in ["Ak8", "Boosted"]]):
makeAtLeastOneAk8JetSelection(self, selObj, use_dd=False)
if self.args.Resolved0Btag:
makeExclusiveResolvedNoBtagSelection(self,
selObj,
use_dd=False)
if self.args.Resolved1Btag:
makeExclusiveResolvedOneBtagSelection(self,
selObj,
use_dd=False)
if self.args.Resolved2Btag:
makeExclusiveResolvedTwoBtagsSelection(self,
selObj,
use_dd=False)
if self.args.Boosted:
makeInclusiveBoostedSelection(self, selObj, use_dd=False)
#---------------------------------------------------------------------------------------#
# Synchronization tree #
#---------------------------------------------------------------------------------------#
if self.args.Synchronization:
# Event variables #
varsToKeep["event"] = None # Already in tree
varsToKeep["run"] = None # Already in tree
varsToKeep["ls"] = t.luminosityBlock
varsToKeep["n_presel_mu"] = op.static_cast(
"UInt_t", op.rng_len(self.muonsPreSel))
varsToKeep["n_fakeablesel_mu"] = op.static_cast(
"UInt_t", op.rng_len(self.muonsFakeSel))
varsToKeep["n_mvasel_mu"] = op.static_cast(
"UInt_t", op.rng_len(self.muonsTightSel))
varsToKeep["n_presel_ele"] = op.static_cast(
"UInt_t", op.rng_len(self.electronsPreSel))
varsToKeep["n_fakeablesel_ele"] = op.static_cast(
"UInt_t", op.rng_len(self.electronsFakeSel))
varsToKeep["n_mvasel_ele"] = op.static_cast(
"UInt_t", op.rng_len(self.electronsTightSel))
varsToKeep["n_presel_ak4Jet"] = op.static_cast(
"UInt_t", op.rng_len(self.ak4Jets))
varsToKeep["n_presel_ak8Jet"] = op.static_cast(
"UInt_t", op.rng_len(self.ak8BJets))
varsToKeep["n_medium_ak4BJet"] = op.static_cast(
"UInt_t", op.rng_len(self.ak4BJets))
varsToKeep["is_SR"] = op.static_cast(
"UInt_t",
op.OR(
op.rng_len(self.ElElDileptonTightSel) >= 1,
op.rng_len(self.MuMuDileptonTightSel) >= 1,
op.rng_len(self.ElMuDileptonTightSel) >= 1))
varsToKeep["is_CR"] = op.static_cast(
"UInt_t",
op.OR(
op.rng_len(self.ElElDileptonFakeExtrapolationSel) >= 1,
op.rng_len(self.MuMuDileptonFakeExtrapolationSel) >= 1,
op.rng_len(self.ElMuDileptonFakeExtrapolationSel) >= 1))
varsToKeep["is_ee"] = op.static_cast(
"UInt_t",
op.OR(
op.rng_len(self.ElElDileptonTightSel) >= 1,
op.rng_len(self.ElElDileptonFakeExtrapolationSel) >= 1))
varsToKeep["is_mm"] = op.static_cast(
"UInt_t",
op.OR(
op.rng_len(self.MuMuDileptonTightSel) >= 1,
op.rng_len(self.MuMuDileptonFakeExtrapolationSel) >= 1))
varsToKeep["is_em"] = op.static_cast(
"UInt_t",
op.OR(
op.rng_len(self.ElMuDileptonTightSel) >= 1,
op.rng_len(self.ElMuDileptonFakeExtrapolationSel) >= 1))
varsToKeep["is_resolved"] = op.switch(
op.AND(
op.rng_len(self.ak4Jets) >= 2,
op.rng_len(self.ak4BJets) >= 1,
op.rng_len(self.ak8BJets) == 0), op.c_bool(True),
op.c_bool(False))
varsToKeep["is_boosted"] = op.switch(
op.rng_len(self.ak8BJets) >= 1, op.c_bool(True),
op.c_bool(False))
# Triggers #
varsToKeep['n_leadfakeableSel_ele'] = op.static_cast(
"UInt_t", op.rng_len(self.leadElectronsFakeSel))
varsToKeep['n_leadfakeableSel_mu'] = op.static_cast(
"UInt_t", op.rng_len(self.leadMuonsFakeSel))
varsToKeep["triggers"] = self.triggers
varsToKeep["triggers_SingleElectron"] = op.OR(
*self.triggersPerPrimaryDataset['SingleElectron'])
varsToKeep["triggers_SingleMuon"] = op.OR(
*self.triggersPerPrimaryDataset['SingleMuon'])
varsToKeep["triggers_DoubleElectron"] = op.OR(
*self.triggersPerPrimaryDataset['DoubleEGamma'])
varsToKeep["triggers_DoubleMuon"] = op.OR(
*self.triggersPerPrimaryDataset['DoubleMuon'])
varsToKeep["triggers_MuonElectron"] = op.OR(
*self.triggersPerPrimaryDataset['MuonEG'])
# Muons #
for i in range(1, 3): # 2 leading muons
varsToKeep["mu{}_pt".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].pt, op.c_float(-9999., "float"))
varsToKeep["mu{}_eta".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].eta, op.c_float(-9999.))
varsToKeep["mu{}_phi".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].phi, op.c_float(-9999.))
varsToKeep["mu{}_E".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].p4.E(),
op.c_float(-9999., "float"))
varsToKeep["mu{}_charge".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].charge, op.c_int(-9999.))
varsToKeep["mu{}_conept".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muon_conept[self.muonsPreSel[i - 1].idx],
op.c_float(-9999.))
varsToKeep["mu{}_miniRelIso".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].miniPFRelIso_all,
op.c_float(-9999.))
varsToKeep["mu{}_PFRelIso04".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].pfRelIso04_all, op.c_float(-9999.))
varsToKeep["mu{}_jetNDauChargedMVASel".format(i)] = op.c_float(
-9999.)
varsToKeep["mu{}_jetPtRel".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].jetPtRelv2, op.c_float(-9999.))
varsToKeep["mu{}_jetRelIso".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].jetRelIso, op.c_float(-9999.))
varsToKeep["mu{}_jetDeepJet".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].jet.btagDeepFlavB,
op.c_float(-9999.))
varsToKeep["mu{}_sip3D".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].sip3d, op.c_float(-9999.))
varsToKeep["mu{}_dxy".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].dxy, op.c_float(-9999.))
varsToKeep["mu{}_dxyAbs".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
op.abs(self.muonsPreSel[i - 1].dxy), op.c_float(-9999.))
varsToKeep["mu{}_dz".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].dz, op.c_float(-9999.))
varsToKeep["mu{}_segmentCompatibility".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].segmentComp, op.c_float(-9999.))
varsToKeep["mu{}_leptonMVA".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].mvaTTH, op.c_float(-9999.))
varsToKeep["mu{}_mediumID".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].mediumId,
op.c_float(-9999., "Bool_t"))
varsToKeep["mu{}_dpt_div_pt".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].tunepRelPt,
op.c_float(-9999.)) # Not sure
varsToKeep["mu{}_isfakeablesel".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
op.switch(self.lambda_muonFakeSel(self.muonsPreSel[i - 1]),
op.c_int(1), op.c_int(0)), op.c_int(-9999))
varsToKeep["mu{}_ismvasel".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
op.switch(
op.AND(
self.lambda_muonTightSel(self.muonsPreSel[i - 1]),
self.lambda_muonFakeSel(self.muonsPreSel[i - 1])),
op.c_int(1), op.c_int(0)),
op.c_int(-9999)) # mvasel encompasses fakeablesel
varsToKeep["mu{}_isGenMatched".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
op.switch(self.lambda_is_matched(self.muonsPreSel[i - 1]),
op.c_int(1), op.c_int(0)), op.c_int(-9999))
varsToKeep["mu{}_genPartFlav".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].genPartFlav, op.c_int(-9999))
varsToKeep["mu{}_FR".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonFR(self.muonsPreSel[i - 1]), op.c_int(-9999))
varsToKeep["mu{}_FRCorr".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.lambda_FF_mu(self.muonsPreSel[i - 1]),
op.c_int(-9999))
# Electrons #
for i in range(1, 3): # 2 leading electrons
varsToKeep["ele{}_pt".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].pt, op.c_float(-9999.))
varsToKeep["ele{}_eta".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].eta, op.c_float(-9999.))
varsToKeep["ele{}_phi".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].phi, op.c_float(-9999.))
varsToKeep["ele{}_E".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].p4.E(),
op.c_float(-9999., "float"))
varsToKeep["ele{}_charge".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].charge, op.c_int(-9999.))
varsToKeep["ele{}_conept".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electron_conept[self.electronsPreSel[i - 1].idx],
op.c_float(-9999.))
varsToKeep["ele{}_miniRelIso".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].miniPFRelIso_all,
op.c_float(-9999.))
varsToKeep["ele{}_PFRelIso03".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].pfRelIso03_all,
op.c_float(-9999.)) # Iso03, Iso04 not in NanoAOD
varsToKeep["ele{}_jetNDauChargedMVASel".format(
i)] = op.c_float(-9999.)
varsToKeep["ele{}_jetPtRel".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].jetPtRelv2, op.c_float(-9999.))
varsToKeep["ele{}_jetRelIso".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].jetRelIso, op.c_float(-9999.))
varsToKeep["ele{}_jetDeepJet".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].jet.btagDeepFlavB,
op.c_float(-9999.))
varsToKeep["ele{}_sip3D".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].sip3d, op.c_float(-9999.))
varsToKeep["ele{}_dxy".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].dxy, op.c_float(-9999.))
varsToKeep["ele{}_dxyAbs".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
op.abs(self.electronsPreSel[i - 1].dxy),
op.c_float(-9999.))
varsToKeep["ele{}_dz".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].dz, op.c_float(-9999.))
varsToKeep["ele{}_ntMVAeleID".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].mvaFall17V2noIso,
op.c_float(-9999.))
varsToKeep["ele{}_leptonMVA".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].mvaTTH, op.c_float(-9999.))
varsToKeep["ele{}_passesConversionVeto".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].convVeto,
op.c_float(-9999., "Bool_t"))
varsToKeep["ele{}_nMissingHits".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].lostHits,
op.c_float(-9999., "UChar_t"))
varsToKeep["ele{}_sigmaEtaEta".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].sieie, op.c_float(-9999.))
varsToKeep["ele{}_HoE".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].hoe, op.c_float(-9999.))
varsToKeep["ele{}_OoEminusOoP".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].eInvMinusPInv,
op.c_float(-9999.))
varsToKeep["ele{}_isfakeablesel".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
op.switch(
self.lambda_electronFakeSel(self.electronsPreSel[i -
1]),
op.c_int(1), op.c_int(0)), op.c_int(-9999))
varsToKeep["ele{}_ismvasel".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
op.switch(
op.AND(
self.lambda_electronTightSel(
self.electronsPreSel[i - 1]),
self.lambda_electronFakeSel(
self.electronsPreSel[i - 1])), op.c_int(1),
op.c_int(0)),
op.c_int(-9999)) # mvasel encompasses fakeablesel
varsToKeep["ele{}_isGenMatched".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
op.switch(
self.lambda_is_matched(self.electronsPreSel[i - 1]),
op.c_int(1), op.c_int(0)), op.c_int(-9999))
varsToKeep["ele{}_genPartFlav".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].genPartFlav, op.c_int(-9999))
varsToKeep["ele{}_deltaEtaSC".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].deltaEtaSC, op.c_int(-9999))
varsToKeep["ele{}_FR".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronFR(self.electronsPreSel[i - 1]),
op.c_int(-9999))
varsToKeep["ele{}_FF".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.lambda_FF_el(self.electronsPreSel[i - 1]),
op.c_int(-9999))
# AK4 Jets #
for i in range(1, 5): # 4 leading jets
varsToKeep["ak4Jet{}_pt".format(i)] = op.switch(
op.rng_len(self.ak4Jets) >= i, self.ak4Jets[i - 1].pt,
op.c_float(-9999., "float"))
varsToKeep["ak4Jet{}_eta".format(i)] = op.switch(
op.rng_len(self.ak4Jets) >= i, self.ak4Jets[i - 1].eta,
op.c_float(-9999.))
varsToKeep["ak4Jet{}_phi".format(i)] = op.switch(
op.rng_len(self.ak4Jets) >= i, self.ak4Jets[i - 1].phi,
op.c_float(-9999.))
varsToKeep["ak4Jet{}_E".format(i)] = op.switch(
op.rng_len(self.ak4Jets) >= i, self.ak4Jets[i - 1].p4.E(),
op.c_float(-9999., "float"))
varsToKeep["ak4Jet{}_CSV".format(i)] = op.switch(
op.rng_len(self.ak4Jets) >= i,
self.ak4Jets[i - 1].btagDeepFlavB, op.c_float(-9999.))
varsToKeep["ak4Jet{}_hadronFlavour".format(i)] = op.switch(
op.rng_len(self.ak4Jets) >= i,
self.ak4Jets[i - 1].hadronFlavour, op.c_float(-9999.))
varsToKeep["ak4Jet{}_btagSF".format(i)] = op.switch(
op.rng_len(self.ak4Jets) >= i,
self.DeepJetDiscReshapingSF(self.ak4Jets[i - 1]),
op.c_float(-9999.))
# AK8 Jets #
for i in range(1, 3): # 2 leading fatjets
varsToKeep["ak8Jet{}_pt".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i, self.ak8BJets[i - 1].pt,
op.c_float(-9999.))
varsToKeep["ak8Jet{}_eta".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i, self.ak8BJets[i - 1].eta,
op.c_float(-9999.))
varsToKeep["ak8Jet{}_phi".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i, self.ak8BJets[i - 1].phi,
op.c_float(-9999.))
varsToKeep["ak8Jet{}_E".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i,
self.ak8BJets[i - 1].p4.E(), op.c_float(-9999., "float"))
varsToKeep["ak8Jet{}_msoftdrop".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i,
self.ak8BJets[i - 1].msoftdrop, op.c_float(-9999.))
varsToKeep["ak8Jet{}_tau1".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i, self.ak8BJets[i - 1].tau1,
op.c_float(-9999.))
varsToKeep["ak8Jet{}_tau2".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i, self.ak8BJets[i - 1].tau2,
op.c_float(-9999.))
varsToKeep["ak8Jet{}_subjet0_pt".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i,
self.ak8BJets[i - 1].subJet1.pt, op.c_float(-9999.))
varsToKeep["ak8Jet{}_subjet0_eta".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i,
self.ak8BJets[i - 1].subJet1.eta, op.c_float(-9999.))
varsToKeep["ak8Jet{}_subjet0_phi".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i,
self.ak8BJets[i - 1].subJet1.phi, op.c_float(-9999.))
varsToKeep["ak8Jet{}_subjet0_CSV".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i,
self.ak8BJets[i - 1].subJet1.btagDeepB, op.c_float(-9999.))
varsToKeep["ak8Jet{}_subjet1_pt".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i,
self.ak8BJets[i - 1].subJet2.pt, op.c_float(-9999.))
varsToKeep["ak8Jet{}_subjet1_eta".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i,
self.ak8BJets[i - 1].subJet2.eta, op.c_float(-9999.))
varsToKeep["ak8Jet{}_subjet1_phi".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i,
self.ak8BJets[i - 1].subJet2.phi, op.c_float(-9999.))
varsToKeep["ak8Jet{}_subjet1_CSV".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i,
self.ak8BJets[i - 1].subJet2.btagDeepB, op.c_float(-9999.))
# MET #
varsToKeep["PFMET"] = self.corrMET.pt
varsToKeep["PFMETphi"] = self.corrMET.phi
# HME #
# SF #
from operator import mul
from functools import reduce
electronMuon_cont = op.combine(
(self.electronsFakeSel, self.muonsFakeSel))
varsToKeep["trigger_SF"] = op.multiSwitch(
(op.AND(
op.rng_len(self.electronsTightSel) == 1,
op.rng_len(self.muonsTightSel) == 0),
self.ttH_singleElectron_trigSF(self.electronsTightSel[0])),
(op.AND(
op.rng_len(self.electronsTightSel) == 0,
op.rng_len(self.muonsTightSel)
== 1), self.ttH_singleMuon_trigSF(self.muonsTightSel[0])),
(op.AND(
op.rng_len(self.electronsTightSel) >= 2,
op.rng_len(self.muonsTightSel) == 0),
self.lambda_ttH_doubleElectron_trigSF(
self.electronsTightSel)),
(op.AND(
op.rng_len(self.electronsTightSel) == 0,
op.rng_len(self.muonsTightSel) >= 2),
self.lambda_ttH_doubleMuon_trigSF(self.muonsTightSel)),
(op.AND(
op.rng_len(self.electronsTightSel) >= 1,
op.rng_len(self.muonsTightSel) >= 1),
self.lambda_ttH_electronMuon_trigSF(electronMuon_cont[0])),
op.c_float(1.))
varsToKeep["lepton_IDSF"] = op.rng_product(self.electronsTightSel, lambda el : reduce(mul,self.lambda_ElectronLooseSF(el)+self.lambda_ElectronTightSF(el))) * \
op.rng_product(self.muonsTightSel, lambda mu : reduce(mul,self.lambda_MuonLooseSF(mu)+self.lambda_MuonTightSF(mu)))
varsToKeep["lepton_IDSF_recoToLoose"] = op.rng_product(self.electronsTightSel, lambda el : reduce(mul,self.lambda_ElectronLooseSF(el))) * \
op.rng_product(self.muonsTightSel, lambda mu : reduce(mul,self.lambda_MuonLooseSF(mu)))
varsToKeep["lepton_IDSF_looseToTight"] = op.rng_product(self.electronsTightSel, lambda el : reduce(mul,self.lambda_ElectronTightSF(el))) * \
op.rng_product(self.muonsTightSel, lambda mu : reduce(mul,self.lambda_MuonTightSF(mu)))
# L1 Prefire #
if era in ["2016", "2017"]:
varsToKeep["L1prefire"] = self.L1Prefiring
else:
varsToKeep["L1prefire"] = op.c_float(-9999.)
# Fake rate #
if self.args.FakeExtrapolation:
varsToKeep["fakeRate"] = op.multiSwitch(
(op.rng_len(self.ElElDileptonFakeExtrapolationSel) >= 1,
self.ElElFakeFactor(
self.ElElDileptonFakeExtrapolationSel[0])),
(op.rng_len(self.MuMuDileptonFakeExtrapolationSel) >= 1,
self.MuMuFakeFactor(
self.MuMuDileptonFakeExtrapolationSel[0])),
(op.rng_len(self.ElMuDileptonFakeExtrapolationSel) >= 1,
self.ElMuFakeFactor(
self.ElMuDileptonFakeExtrapolationSel[0])),
op.c_float(0.))
else:
varsToKeep["fakeRate"] = op.c_float(-9999.)
# Btagging SF #
varsToKeep["btag_SF"] = self.btagSF
if "BtagRatioWeight" in self.__dict__.keys():
varsToKeep["btag_reweighting"] = self.BtagRatioWeight
varsToKeep[
"btag_reweighting_SF"] = self.btagSF * self.BtagRatioWeight
# ttbar PT reweighting #
if "group" in sampleCfg and sampleCfg["group"] == 'ttbar':
varsToKeep["topPt_wgt"] = self.ttbar_weight(
self.genTop[0], self.genAntitop[0])
# Event Weight #
if self.is_MC:
#varsToKeep["MC_weight"] = op.sign(t.genWeight)
varsToKeep["MC_weight"] = t.genWeight
puWeightsFile = os.path.join(os.path.dirname(__file__), "data",
"pileup", sampleCfg["pufile"])
varsToKeep["PU_weight"] = makePileupWeight(
puWeightsFile,
t.Pileup_nTrueInt,
nameHint=f"puweightFromFile{sample}".replace('-', '_'))
varsToKeep[
"eventWeight"] = noSel.weight if self.inclusive_sel else selObj.sel.weight
if self.inclusive_sel:
return noSel, varsToKeep
else:
return selObj.sel, varsToKeep
#---------------------------------------------------------------------------------------#
# Selection tree #
#---------------------------------------------------------------------------------------#
#----- MET variables -----#
MET = self.corrMET
varsToKeep['MET_pt'] = MET.pt
varsToKeep['MET_phi'] = MET.phi
#----- Lepton variables -----#
if self.args.Channel is None:
raise RuntimeError("You need to specify --Channel")
dilepton = None
if self.args.Preselected:
if self.args.Channel == "ElEl":
dilepton = self.ElElDileptonPreSel[0]
if self.args.Channel == "MuMu":
dilepton = self.MuMuDileptonPreSel[0]
if self.args.Channel == "ElMu":
dilepton = self.ElMuDileptonPreSel[0]
if self.args.Fakeable:
if self.args.Channel == "ElEl":
dilepton = self.ElElDileptonFakeSel[0]
if self.args.Channel == "MuMu":
dilepton = self.MuMuDileptonFakeSel[0]
if self.args.Channel == "ElMu":
dilepton = self.ElMuDileptonFakeSel[0]
if self.args.Tight:
if self.args.Channel == "ElEl":
dilepton = self.ElElDileptonTightSel[0]
if self.args.Channel == "MuMu":
dilepton = self.MuMuDileptonTightSel[0]
if self.args.Channel == "ElMu":
dilepton = self.ElMuDileptonTightSel[0]
if self.args.FakeExtrapolation:
if self.args.Channel == "ElEl":
dilepton = self.ElElDileptonFakeExtrapolationSel[0]
if self.args.Channel == "MuMu":
dilepton = self.MuMuDileptonFakeExtrapolationSel[0]
if self.args.Channel == "ElMu":
dilepton = self.ElMuDileptonFakeExtrapolationSel[0]
varsToKeep['l1_Px'] = dilepton[0].p4.Px()
varsToKeep['l1_Py'] = dilepton[0].p4.Py()
varsToKeep['l1_Pz'] = dilepton[0].p4.Pz()
varsToKeep['l1_E'] = dilepton[0].p4.E()
varsToKeep['l1_pt'] = dilepton[0].pt
varsToKeep['l1_eta'] = dilepton[0].eta
varsToKeep['l1_phi'] = dilepton[0].phi
varsToKeep['l2_Px'] = dilepton[1].p4.Px()
varsToKeep['l2_Py'] = dilepton[1].p4.Py()
varsToKeep['l2_Pz'] = dilepton[1].p4.Pz()
varsToKeep['l2_E'] = dilepton[1].p4.E()
varsToKeep['l2_pt'] = dilepton[1].pt
varsToKeep['l2_eta'] = dilepton[1].eta
varsToKeep['l2_phi'] = dilepton[1].phi
varsToKeep['ll_pt'] = (dilepton[0].p4 + dilepton[1].p4).Pt()
varsToKeep['ll_DR'] = op.deltaR(dilepton[0].p4, dilepton[1].p4)
varsToKeep['ll_DPhi'] = op.deltaPhi(dilepton[0].p4,
dilepton[1].p4) # Might need abs
varsToKeep['llmet_DPhi'] = self.HLL.DilepMET_deltaPhi(
dilepton[0], dilepton[1], MET)
varsToKeep['llmet_pt'] = self.HLL.DilepMET_Pt(dilepton[0], dilepton[1],
MET)
varsToKeep['ll_M'] = op.invariant_mass(dilepton[0].p4, dilepton[1].p4)
varsToKeep['ll_MT'] = self.HLL.MT_ll(dilepton[0], dilepton[1], MET)
#----- Jet variables -----#
if any([
self.args.__dict__[item] for item in
["Ak4", "Resolved0Btag", "Resolved1Btag", "Resolved2Btag"]
]):
if self.args.Ak4:
leadjet = self.ak4Jets[0]
subleadjet = self.ak4Jets[1]
if self.args.Resolved0Btag:
leadjet = self.ak4LightJetsByBtagScore[0]
subleadjet = self.ak4LightJetsByBtagScore[0]
if self.args.Resolved1Btag:
leadjet = self.ak4BJets[0]
subleadjet = self.ak4LightJetsByBtagScore[0]
if self.args.Resolved2Btag:
leadjet = self.ak4BJets[0]
subleadjet = self.ak4BJets[1]
varsToKeep['j1_Px'] = leadjet.p4.Px()
varsToKeep['j1_Py'] = leadjet.p4.Py()
varsToKeep['j1_Pz'] = leadjet.p4.Pz()
varsToKeep['j1_E'] = leadjet.p4.E()
varsToKeep['j1_pt'] = leadjet.pt
varsToKeep['j1_eta'] = leadjet.eta
varsToKeep['j1_phi'] = leadjet.phi
varsToKeep['j2_Px'] = subleadjet.p4.Px()
varsToKeep['j2_Py'] = subleadjet.p4.Py()
varsToKeep['j2_Pz'] = subleadjet.p4.Pz()
varsToKeep['j2_E'] = subleadjet.p4.E()
varsToKeep['j2_pt'] = subleadjet.pt
varsToKeep['j2_eta'] = subleadjet.eta
varsToKeep['j2_phi'] = subleadjet.phi
varsToKeep['jj_pt'] = (leadjet.p4 + subleadjet.p4).Pt()
varsToKeep['jj_DR'] = op.deltaR(leadjet.p4, subleadjet.p4)
varsToKeep['jj_DPhi'] = op.deltaPhi(
leadjet.p4, subleadjet.p4) # Might need abs
varsToKeep['jj_M'] = op.invariant_mass(leadjet.p4, subleadjet.p4)
varsToKeep['lljj_M'] = self.HLL.M_lljj(dilepton[0], dilepton[1],
leadjet, subleadjet)
varsToKeep['lljj_MT'] = self.HLL.MT_lljj(dilepton[0], dilepton[1],
leadjet, subleadjet, MET)
varsToKeep['lj_MinDR'] = self.HLL.MinDR_lj(dilepton[0],
dilepton[1], leadjet,
subleadjet)
varsToKeep['HT2'] = self.HLL.HT2(dilepton[0], dilepton[1], leadjet,
subleadjet, MET)
varsToKeep['HT2R'] = self.HLL.HT2R(dilepton[0], dilepton[1],
leadjet, subleadjet, MET)
#----- Fatjet variables -----#
if any([self.args.__dict__[item] for item in ["Ak8", "Boosted"]]):
if self.args.Ak8:
fatjet = self.ak8Jets[0]
if self.args.Boosted:
fatjet = self.ak8BJets[0]
varsToKeep['fatjet_Px'] = fatjet.p4.Px()
varsToKeep['fatjet_Py'] = fatjet.p4.Py()
varsToKeep['fatjet_Pz'] = fatjet.p4.Pz()
varsToKeep['fatjet_E'] = fatjet.p4.E()
varsToKeep['fatjet_pt'] = fatjet.pt
varsToKeep['fatjet_eta'] = fatjet.eta
varsToKeep['fatjet_phi'] = fatjet.phi
varsToKeep['fatjet_softdropMass'] = fatjet.msoftdrop
varsToKeep['lljj_M'] = self.HLL.M_lljj(dilepton[0], dilepton[1],
fatjet.subJet1,
fatjet.subJet2)
varsToKeep['lljj_MT'] = self.HLL.MT_lljj(dilepton[0], dilepton[1],
fatjet.subJet1,
fatjet.subJet2, MET)
varsToKeep['lj_MinDR'] = self.HLL.MinDR_lj(dilepton[0],
dilepton[1],
fatjet.subJet1,
fatjet.subJet2)
varsToKeep['HT2'] = self.HLL.HT2(dilepton[0], dilepton[1],
fatjet.subJet1, fatjet.subJet2,
MET)
varsToKeep['HT2R'] = self.HLL.HT2R(dilepton[0], dilepton[1],
fatjet.subJet1, fatjet.subJet2,
MET)
#----- Additional variables -----#
varsToKeep["MC_weight"] = t.genWeight
varsToKeep['total_weight'] = selObj.sel.weight
#return leptonSel.sel, varsToKeep
return selObj.sel, varsToKeep
def defineSkimSelection(self, t, noSel, sample=None, sampleCfg=None):
noSel = super(SkimmerMEMNanoHHtobbWWDL,self).prepareObjects(t, noSel, sample, sampleCfg, "DL", forSkimmer=True)
# For the Skimmer, SF must not use defineOnFirstUse -> segmentation fault
era = sampleCfg['era']
# Initialize varsToKeep dict #
varsToKeep = dict()
if self.inclusive_sel:
raise RuntimeError("Inclusive analysis not possible")
#---------------------------------------------------------------------------------------#
# Selections #
#---------------------------------------------------------------------------------------#
#----- Check arguments -----#
jet_level = ["Resolved0Btag","Resolved1Btag","Resolved2Btag","Boosted0Btag","Boosted1Btag"] # Only one must be in args
if [boolean for (level,boolean) in self.args.__dict__.items() if level in jet_level].count(True) != 1:
raise RuntimeError("Only one of the jet arguments must be used, check --help")
if self.args.Channel not in ["ElEl","MuMu","ElMu"]:
raise RuntimeError("Channel must be either 'ElEl', 'MuMu' or 'ElMu'")
#----- Lepton selection -----#
# Args are passed within the self #
ElElSelObj,MuMuSelObj,ElMuSelObj = makeDoubleLeptonSelection(self,noSel,use_dd=False,fake_selection=self.args.FakeCR)
if self.args.Channel == "ElEl":
selObj = ElElSelObj
dilepton = self.ElElFakeSel[0]
if self.args.Channel == "MuMu":
selObj = MuMuSelObj
dilepton = self.MuMuFakeSel[0]
if self.args.Channel == "ElMu":
selObj = ElMuSelObj
dilepton = self.ElMuFakeSel[0]
#----- Jet selection -----#
# Since the selections in one line, we can use the non copy option of the selection to modify the selection object internally
if any([self.args.__dict__[item] for item in ["Ak4","Resolved0Btag","Resolved1Btag","Resolved2Btag"]]):
makeAtLeastTwoAk4JetSelection(self,selObj,use_dd=False)
if any([self.args.__dict__[item] for item in ["Ak8","Boosted0Btag","Boosted1Btag"]]):
makeAtLeastOneAk8JetSelection(self,selObj,use_dd=False)
if self.args.Resolved0Btag:
makeExclusiveResolvedNoBtagSelection(self,selObj,use_dd=False)
if self.args.Resolved1Btag:
makeExclusiveResolvedOneBtagSelection(self,selObj,use_dd=False)
if self.args.Resolved2Btag:
makeExclusiveResolvedTwoBtagsSelection(self,selObj,use_dd=False)
if self.args.Boosted0Btag:
makeInclusiveBoostedNoBtagSelection(self,selObj,use_dd=False)
if self.args.Boosted1Btag:
makeInclusiveBoostedOneBtagSelection(self,selObj,use_dd=False)
#---------------------------------------------------------------------------------------#
# Selection tree #
#---------------------------------------------------------------------------------------#
#----- MET variables -----#
MET = self.corrMET
varsToKeep['met_pt'] = MET.pt
varsToKeep['met_phi'] = MET.phi
varsToKeep['met_E'] = MET.p4.E()
varsToKeep['met_Px'] = MET.p4.Px()
varsToKeep['met_Py'] = MET.p4.Py()
varsToKeep['met_Pz'] = MET.p4.Pz()
#----- Lepton variables -----#
if self.args.Channel is None:
raise RuntimeError("You need to specify --Channel")
if self.args.Channel == "ElEl": dilepton = self.ElElTightSel[0]
if self.args.Channel == "MuMu": dilepton = self.MuMuTightSel[0]
if self.args.Channel == "ElMu": dilepton = self.ElMuTightSel[0]
varsToKeep["is_SR"] = op.static_cast("UInt_t",op.OR(op.rng_len(self.ElElTightSel)>0,
op.rng_len(self.MuMuTightSel)>0,
op.rng_len(self.ElMuTightSel)>0))
varsToKeep['is_ee'] = op.static_cast("UInt_t",op.rng_len(self.ElElTightSel)>0)
varsToKeep['is_mm'] = op.static_cast("UInt_t",op.rng_len(self.MuMuTightSel)>0)
varsToKeep['is_em'] = op.static_cast("UInt_t",op.rng_len(self.ElMuTightSel)>0)
varsToKeep['resolved1b_tag'] = op.static_cast("UInt_t",op.AND(op.rng_len(self.ak4BJets)==1,op.rng_len(self.ak8BJets)==0))
varsToKeep['resolved2b_tag'] = op.static_cast("UInt_t",op.AND(op.rng_len(self.ak4BJets)>=2,op.rng_len(self.ak8BJets)==0))
varsToKeep['boosted1b_tag'] = op.static_cast("UInt_t",op.AND(op.rng_len(self.ak8BJets)>0))
l1 = dilepton[0]
l2 = dilepton[1]
varsToKeep['l1_Px'] = l1.p4.Px()
varsToKeep['l1_Py'] = l1.p4.Py()
varsToKeep['l1_Pz'] = l1.p4.Pz()
varsToKeep['l1_E'] = l1.p4.E()
varsToKeep['l1_pt'] = l1.pt
varsToKeep['l1_eta'] = l1.eta
varsToKeep['l1_phi'] = l1.phi
varsToKeep['l1_pdgId'] = l1.pdgId
varsToKeep['l1_charge'] = l1.charge
varsToKeep['l2_Px'] = l2.p4.Px()
varsToKeep['l2_Py'] = l2.p4.Py()
varsToKeep['l2_Pz'] = l2.p4.Pz()
varsToKeep['l2_E'] = l2.p4.E()
varsToKeep['l2_pt'] = l2.pt
varsToKeep['l2_eta'] = l2.eta
varsToKeep['l2_phi'] = l2.phi
varsToKeep['l2_pdgId'] = l2.pdgId
varsToKeep['l2_charge'] = l2.charge
#----- Jet variables -----#
jets = self.ak4JetsByBtagScore
for idx in range(1,5):
varsToKeep[f'j{idx}_Px'] = op.switch(op.rng_len(jets)>=idx, jets[idx-1].p4.Px(), op.c_float(-9999))
varsToKeep[f'j{idx}_Py'] = op.switch(op.rng_len(jets)>=idx, jets[idx-1].p4.Py(), op.c_float(-9999))
varsToKeep[f'j{idx}_Pz'] = op.switch(op.rng_len(jets)>=idx, jets[idx-1].p4.Pz(), op.c_float(-9999))
varsToKeep[f'j{idx}_E'] = op.switch(op.rng_len(jets)>=idx, jets[idx-1].p4.E(), op.c_float(-9999))
varsToKeep[f'j{idx}_pt'] = op.switch(op.rng_len(jets)>=idx, jets[idx-1].pt, op.c_float(-9999))
varsToKeep[f'j{idx}_eta'] = op.switch(op.rng_len(jets)>=idx, jets[idx-1].eta, op.c_float(-9999))
varsToKeep[f'j{idx}_phi'] = op.switch(op.rng_len(jets)>=idx, jets[idx-1].phi, op.c_float(-9999))
varsToKeep[f'j{idx}_btag']= op.switch(op.rng_len(jets)>=idx, jets[idx-1].btagDeepFlavB, op.c_float(-9999))
varsToKeep['n_ak4'] = op.static_cast("UInt_t",op.rng_len(self.ak4Jets))
varsToKeep['n_ak4_btag'] = op.static_cast("UInt_t",op.rng_len(self.ak4BJets))
#----- Fatjet variables -----#
fatjets = self.ak8BJets
subJet1 = fatjets[0].subJet1
subJet2 = fatjets[0].subJet2
varsToKeep['fatj_sub1_Px'] = op.switch(op.rng_len(fatjets)>0, subJet1.p4.Px(), op.c_float(-9999))
varsToKeep['fatj_sub1_Py'] = op.switch(op.rng_len(fatjets)>0, subJet1.p4.Py(), op.c_float(-9999))
varsToKeep['fatj_sub1_Pz'] = op.switch(op.rng_len(fatjets)>0, subJet1.p4.Pz(), op.c_float(-9999))
varsToKeep['fatj_sub1_E'] = op.switch(op.rng_len(fatjets)>0, subJet1.p4.E(), op.c_float(-9999))
varsToKeep['fatj_sub1_pt'] = op.switch(op.rng_len(fatjets)>0, subJet1.pt, op.c_float(-9999))
varsToKeep['fatj_sub1_eta'] = op.switch(op.rng_len(fatjets)>0, subJet1.eta, op.c_float(-9999))
varsToKeep['fatj_sub1_phi'] = op.switch(op.rng_len(fatjets)>0, subJet1.phi, op.c_float(-9999))
varsToKeep['fatj_sub1_btag'] = op.switch(op.rng_len(fatjets)>0, subJet1.btagDeepB, op.c_float(-9999))
varsToKeep['fatj_sub2_Px'] = op.switch(op.rng_len(fatjets)>0, subJet2.p4.Px(), op.c_float(-9999))
varsToKeep['fatj_sub2_Py'] = op.switch(op.rng_len(fatjets)>0, subJet2.p4.Py(), op.c_float(-9999))
varsToKeep['fatj_sub2_Pz'] = op.switch(op.rng_len(fatjets)>0, subJet2.p4.Pz(), op.c_float(-9999))
varsToKeep['fatj_sub2_E'] = op.switch(op.rng_len(fatjets)>0, subJet2.p4.E(), op.c_float(-9999))
varsToKeep['fatj_sub2_pt'] = op.switch(op.rng_len(fatjets)>0, subJet2.pt, op.c_float(-9999))
varsToKeep['fatj_sub2_eta'] = op.switch(op.rng_len(fatjets)>0, subJet2.eta, op.c_float(-9999))
varsToKeep['fatj_sub2_phi'] = op.switch(op.rng_len(fatjets)>0, subJet2.phi, op.c_float(-9999))
varsToKeep['fatj_sub2_btag'] = op.switch(op.rng_len(fatjets)>0, subJet2.btagDeepB, op.c_float(-9999))
varsToKeep['fatj_Px'] = op.switch(op.rng_len(fatjets)>0, fatjets[0].p4.Px(), op.c_float(-9999))
varsToKeep['fatj_Py'] = op.switch(op.rng_len(fatjets)>0, fatjets[0].p4.Py(), op.c_float(-9999))
varsToKeep['fatj_Pz'] = op.switch(op.rng_len(fatjets)>0, fatjets[0].p4.Pz(), op.c_float(-9999))
varsToKeep['fatj_E'] = op.switch(op.rng_len(fatjets)>0, fatjets[0].p4.E(), op.c_float(-9999))
varsToKeep['fatj_pt'] = op.switch(op.rng_len(fatjets)>0, fatjets[0].pt, op.c_float(-9999))
varsToKeep['fatj_eta'] = op.switch(op.rng_len(fatjets)>0, fatjets[0].eta, op.c_float(-9999))
varsToKeep['fatj_phi'] = op.switch(op.rng_len(fatjets)>0, fatjets[0].phi, op.c_float(-9999))
varsToKeep['fatj_softdropMass'] = op.switch(op.rng_len(fatjets)>0, fatjets[0].msoftdrop, op.c_float(-9999))
varsToKeep['fatj_btagDeepB'] = op.switch(op.rng_len(fatjets)>0, fatjets[0].btagDeepB, op.c_float(-9999))
varsToKeep['fatj_btagHbb'] = op.switch(op.rng_len(fatjets)>0, fatjets[0].btagHbb, op.c_float(-9999))
varsToKeep['n_ak8'] = op.static_cast("UInt_t",op.rng_len(self.ak8Jets))
varsToKeep['n_ak8_btag'] = op.static_cast("UInt_t",op.rng_len(self.ak8BJets))
#----- Additional variables -----#
if self.is_MC:
varsToKeep["MC_weight"] = t.genWeight
varsToKeep['total_weight'] = selObj.sel.weight
varsToKeep["event"] = None # Already in tree
varsToKeep["run"] = None # Already in tree
varsToKeep["ls"] = t.luminosityBlock
return selObj.sel, varsToKeep
def __init__(self, HHself):
# All the attributes of the BaseHH are contained in HHself object
# All the lambdas will be saved in the highlevelLambdas object to avoid confusions of all the attributes of HH base object
# conept #
self.conept = lambda lep: op.switch(
op.abs(lep.pdgId) == 11, HHself.electron_conept[lep.idx], HHself.
muon_conept[lep.idx])
self.electron_conept = lambda ele: HHself.electron_conept[ele.idx]
self.muon_conept = lambda mu: HHself.muon_conept[mu.idx]
# 4-Momentum association #
self.ll_p4 = lambda l1, l2: l1.p4 + l2.p4
self.lljj_p4 = lambda l1, l2, j1, j2: l1.p4 + l2.p4 + j1.p4 + j2.p4
self.lep1j_p4 = lambda lep, j1: lep.p4 + j1.p4
self.lep2j_p4 = lambda lep, j1, j2: lep.p4 + j1.p4 + j2.p4
self.lep3j_p4 = lambda lep, j1, j2, j3: lep.p4 + j1.p4 + j2.p4 + j3.p4
self.lep4j_p4 = lambda lep, j1, j2, j3, j4: lep.p4 + j1.p4 + j2.p4 + j3.p4 + j4.p4
# bReg corr 4 momenta of ak4-bTagged jet #
self.bJetCorrP4 = lambda j: op._to.Construct(
"ROOT::Math::LorentzVector<ROOT::Math::PtEtaPhiM4D<float> >",
(j.pt * j.bRegCorr, j.eta, j.phi, j.mass * j.bRegCorr)).result
# Dilep-Met variables #
self.DilepMET_deltaPhi = lambda l1, l2, met: self.ll_p4(l1, l2).Phi(
) - met.phi
self.DilepMET_Pt = lambda l1, l2, met: op.sqrt(
op.pow(met.pt * op.cos(met.phi) + self.ll_p4(l1, l2).Px(), 2) + op.
pow(met.pt * op.sin(met.phi) + self.ll_p4(l1, l2).Py(), 2))
# SingleLep-Met variables
#self.SinglepMet_Pt = lambda lep,met : op.sqrt(op.pow(met.pt*op.cos(met.phi)+lep.p4.Px(),2)+op.pow(met.pt*op.sin(met.phi)+lep.p4.Py(),2))
self.SinglepMet_Pt = lambda lep, met: (lep.p4 + met.p4).Pt()
#self.SinglepMet_dPhi = lambda lep, met : lep.p4.Phi()-met.phi
self.SinglepMet_dPhi = lambda lep, met: op.deltaPhi(lep.p4, met.p4)
# Transverse mass #
self.MT_ll = lambda l1, l2, met: op.sqrt(2 * self.ll_p4(l1, l2).Pt(
) * met.pt * (1 - op.cos(self.ll_p4(l1, l2).Phi() - met.phi)))
self.MT_lljj = lambda l1, l2, j1, j2, met: op.sqrt(
2 * self.lljj_p4(l1, l2, j1, j2).Pt() * met.pt *
(1 - op.cos(self.lljj_p4(l1, l2, j1, j2).Phi() - met.phi)))
self.MT = lambda lep, met: op.sqrt(2 * lep.p4.Pt() * met.pt * (
1 - op.cos(lep.p4.Phi() - met.phi)))
self.MT_W1W2_ljj = lambda lep, j1, j2, met: op.sqrt(
2 * self.lep2j_p4(lep, j1, j2).Pt() * met.pt *
(1 - op.cos(self.lep2j_p4(lep, j1, j2).Phi() - met.phi)))
self.MT_W1W2_lj = lambda lep, j1, met: op.sqrt(
2 * self.lep1j_p4(lep, j1).Pt() * met.pt *
(1 - op.cos(self.lep1j_p4(lep, j1).Phi() - met.phi)))
# TODO : clean different versions (eg MT)
# dilep + dijet #
self.M_lljj = lambda l1, l2, j1, j2: op.invariant_mass(
self.lljj_p4(l1, l2, j1, j2))
self.M_HH = lambda l1, l2, j1, j2, met: op.invariant_mass(
l1.p4, l2.p4, j1.p4, j2.p4, met.p4)
self.MinDR_lj = lambda l1, l2, j1, j2: op.min(
op.min(op.deltaR(l1.p4, j1.p4), op.deltaR(l1.p4, j2.p4)),
op.min(op.deltaR(l2.p4, j1.p4), op.deltaR(l2.p4, j2.p4)))
self.MinDR_part1_partCont = lambda part1, partCont: op.rng_min(
partCont, lambda part2: op.deltaR(part1.p4, part2.p4))
self.MinDEta_part1_partCont = lambda part1, partCont: op.rng_min(
partCont, lambda part2: op.abs(part1.eta - part2.eta))
self.MinDPhi_part1_partCont = lambda part1, partCont: op.rng_min(
partCont, lambda part2: op.abs(op.deltaPhi(part1.p4, part2.p4)))
self.MinDR_part1_dipart = lambda part1, dipart: op.min(*(
op.deltaR(part1.p4, dipart[i2].p4) for i2 in range(2)))
self.JetsMinDR = lambda l, j1, j2: op.min(op.deltaR(l.p4, j1.p4),
op.deltaR(l.p4, j2.p4))
self.LepsMinDR = lambda j, l1, l2: op.min(op.deltaR(j.p4, l1.p4),
op.deltaR(j.p4, l2.p4))
self.MinDR_lep3j = lambda lep, j1, j2, j3: op.min(
op.min(op.deltaR(lep.p4, j1.p4), op.deltaR(lep.p4, j2.p4)),
op.deltaR(lep.p4, j3.p4))
self.MinDR_lj = lambda l1, l2, j1, j2: op.min(
op.min(op.deltaR(l1.p4, j1.p4), op.deltaR(l1.p4, j2.p4)),
op.min(op.deltaR(l2.p4, j1.p4), op.deltaR(l2.p4, j2.p4)))
self.MinDR_lep2j = lambda lep, j1, j2: op.min(op.deltaR(lep.p4, j1.p4),
op.deltaR(lep.p4, j2.p4))
self.MinDR_lep3j = lambda lep, j1, j2, j3: op.min(
op.min(op.deltaR(lep.p4, j1.p4), op.deltaR(lep.p4, j2.p4)),
op.deltaR(lep.p4, j3.p4))
self.MinDR_lep4j = lambda lep, j1, j2, j3, j4: op.min(
op.min(op.min(op.deltaR(lep.p4, j1.p4), op.deltaR(lep.p4, j2.p4)),
op.deltaR(lep.p4, j3.p4)), op.deltaR(lep.p4, j4.p4))
self.MinDPhi_lep2j = lambda lep, j1, j2: op.min(
op.abs(op.deltaPhi(lep.p4, j1.p4)),
op.abs(op.deltaPhi(lep.p4, j2.p4)))
self.MinDPhi_lep3j = lambda lep, j1, j2, j3: op.min(
op.min(op.abs(op.deltaPhi(lep.p4, j1.p4)),
op.abs(op.deltaPhi(lep.p4, j2.p4))),
op.abs(op.deltaPhi(lep.p4, j3.p4)))
self.MinDPhi_lep4j = lambda lep, j1, j2, j3, j4: op.min(
op.min(
op.min(op.abs(op.deltaPhi(lep.p4, j1.p4)),
op.abs(op.deltaPhi(lep.p4, j2.p4))),
op.abs(op.deltaPhi(lep.p4, j3.p4))),
op.abs(op.deltaPhi(lep.p4, j4.p4)))
self.MinDEta_lep2j = lambda lep, j1, j2: op.min(
op.abs(lep.eta - j1.eta), op.abs(lep.eta - j2.eta))
self.MinDEta_lep3j = lambda lep, j1, j2, j3: op.min(
op.min(op.abs(lep.eta - j1.eta), op.abs(lep.eta - j2.eta)),
op.abs(lep.eta - j3.eta))
self.MinDEta_lep4j = lambda lep, j1, j2, j3, j4: op.min(
op.min(op.min(op.abs(lep.eta - j1.eta), op.abs(lep.eta - j2.eta)),
op.abs(lep.eta - j3.eta)), op.abs(lep.eta - j4.eta))
self.MaxDR_lep2j = lambda lep, j1, j2: op.max(op.deltaR(lep.p4, j1.p4),
op.deltaR(lep.p4, j2.p4))
self.MaxDR_lep3j = lambda lep, j1, j2, j3: op.max(
op.max(op.deltaR(lep.p4, j1.p4), op.deltaR(lep.p4, j2.p4)),
op.deltaR(lep.p4, j3.p4))
self.MaxDR_lep4j = lambda lep, j1, j2, j3, j4: op.max(
op.max(op.max(op.deltaR(lep.p4, j1.p4), op.deltaR(lep.p4, j2.p4)),
op.deltaR(lep.p4, j3.p4)), op.deltaR(lep.p4, j4.p4))
self.MaxDPhi_lep2j = lambda lep, j1, j2: op.max(
op.abs(op.deltaPhi(lep.p4, j1.p4)),
op.abs(op.deltaPhi(lep.p4, j2.p4)))
self.MaxDPhi_lep3j = lambda lep, j1, j2, j3: op.max(
op.max(op.abs(op.deltaPhi(lep.p4, j1.p4)),
op.abs(op.deltaPhi(lep.p4, j2.p4))),
op.abs(op.deltaPhi(lep.p4, j3.p4)))
self.MaxDPhi_lep4j = lambda lep, j1, j2, j3, j4: op.max(
op.max(
op.max(op.abs(op.deltaPhi(lep.p4, j1.p4)),
op.abs(op.deltaPhi(lep.p4, j2.p4))),
op.abs(op.deltaPhi(lep.p4, j3.p4))),
op.abs(op.deltaPhi(lep.p4, j4.p4)))
self.MaxDEta_lep2j = lambda lep, j1, j2: op.max(
op.abs(lep.eta - j1.eta), op.abs(lep.eta - j2.eta))
self.MaxDEta_lep3j = lambda lep, j1, j2, j3: op.max(
op.max(op.abs(lep.eta - j1.eta), op.abs(lep.eta - j2.eta)),
op.abs(lep.eta - j3.eta))
self.MaxDEta_lep4j = lambda lep, j1, j2, j3, j4: op.max(
op.max(op.max(op.abs(lep.eta - j1.eta), op.abs(lep.eta - j2.eta)),
op.abs(lep.eta - j3.eta)), op.abs(lep.eta - j4.eta))
# Higgs related variables #
#self.HT2 = lambda l1,l2,j1,j2,met : op.sqrt(op.pow(met.pt*op.cos(met.phi)+l1.p4.Px()+l2.p4.Px(),2)+op.pow(met.pt*op.sin(met.phi)+l1.p4.Py()+l2.p4.Py(),2)) + op.abs((j1.p4+j2.p4).Pt())
#self.HT2R = lambda l1,l2,j1,j2,met : self.HT2(met,l1,l2,j1,j2)/(met.pt+l1.p4.Pt()+l2.p4.Pt()+j1.p4.Pt()+j2.p4.Pt())
#self.HT2_l1jmet = lambda l,j1,met : op.sqrt(op.pow(met.pt*op.cos(met.phi)+l.p4.Px(),2)+op.pow(met.pt*op.sin(met.phi)+l.p4.Py(),2)) + op.abs(j1.p4.Pt())
#self.HT2R_l1jmet = lambda l,j1,met : self.HT2_l1jmet(l,j1,met)/(met.pt+l.p4.Pt()+j1.p4.Pt())
#self.HT2_l2jmet = lambda l,j1,j2,met : op.sqrt(op.pow(met.pt*op.cos(met.phi)+l.p4.Px(),2)+op.pow(met.pt*op.sin(met.phi)+l.p4.Py(),2)) + op.abs((j1.p4+j2.p4).Pt())
#self.HT2R_l2jmet = lambda l,j1,j2,met : self.HT2_l2jmet(l,j1,j2,met)/(met.pt+l.p4.Pt()+j1.p4.Pt()+j2.p4.Pt())
#self.HT2_l3jmet = lambda l,j1,j2,j3,met : op.sqrt(op.pow(met.pt*op.cos(met.phi)+l.p4.Px(),2)+op.pow(met.pt*op.sin(met.phi)+l.p4.Py(),2)) + op.abs((j1.p4+j2.p4+j3.p4).Pt())
self.HT_SL = lambda jets: op.rng_sum(jets, lambda j: j.pt)
# 0b
self.HT2_0b = lambda l, met: op.abs((met.p4 + l.p4).Pt())
self.HT2R_0b = lambda l, met: self.HT2_0b(l, met) / (met.pt + l.pt)
# 1b0Wj
self.HT2_1b0Wj = lambda l, j1, met: op.abs(
(met.p4 + l.p4).Pt()) + j1.pt
self.HT2R_1b0Wj = lambda l, j1, met: self.HT2_1b0Wj(l, j1, met) / (
met.pt + l.pt + j1.pt)
# 1b1Wj
self.HT2_1b1Wj = lambda l, j1, j3, met: op.abs(
(met.p4 + l.p4 + j3.p4).Pt()) + j1.pt
self.HT2R_1b1Wj = lambda l, j1, j3, met: self.HT2_1b1Wj(
l, j1, j3, met) / (met.pt + l.pt + j1.pt + j3.pt)
#2b0Wj
self.HT2_2b0Wj = lambda l, j1, j2, met: op.abs(
(met.p4 + l.p4).Pt()) + op.abs((j1.p4 + j2.p4).Pt())
self.HT2R_2b0Wj = lambda l, j1, j2, met: self.HT2_2b0Wj(
l, j1, j2, met) / (met.pt + l.pt + j1.pt + j2.pt)
# 1b2Wj
self.HT2_1b2Wj = lambda l, j1, j3, j4, met: op.abs(
(met.p4 + l.p4 + j3.p4 + j4.p4).Pt()) + j1.pt
self.HT2R_1b2Wj = lambda l, j1, j3, j4, met: self.HT2_1b2Wj(
l, j1, j3, j4, met) / (met.pt + l.pt + j1.pt + j3.pt + j4.pt)
# 2b1Wj
self.HT2_2b1Wj = lambda l, j1, j2, j3, met: op.abs(
(met.p4 + l.p4 + j3.p4).Pt()) + op.abs((j1.p4 + j2.p4).Pt())
self.HT2R_2b1Wj = lambda l, j1, j2, j3, met: self.HT2_2b1Wj(
l, j1, j2, j3, met) / (met.pt + l.pt + j1.pt + j2.pt + j3.pt)
#self.HT2_l4jmet = lambda l,j1,j2,j3,j4,met : op.sqrt(op.pow(met.pt*op.cos(met.phi)+l.p4.Px(),2)+op.pow(met.pt*op.sin(met.phi)+l.p4.Py(),2)) + op.abs((j1.p4+j2.p4+j3.p4+j4.p4).Pt())
# 2b2Wj
self.HT2_2b2Wj = lambda l, j1, j2, j3, j4, met: op.abs(
(met.p4 + l.p4 + j3.p4 + j4.p4).Pt()) + op.abs(
(j1.p4 + j2.p4).Pt())
self.HT2R_2b2Wj = lambda l, j1, j2, j3, j4, met: self.HT2_2b2Wj(
l, j1, j2, j3, j4, met) / (met.pt + l.pt + j1.pt + j2.pt + j3.pt +
j4.pt)
#min j1j2DR
self.MinDiJetDRLoose = lambda j1, j2, j3: op.min(
op.min(op.deltaR(j1.p4, j2.p4), op.deltaR(j2.p4, j3.p4)),
op.deltaR(j1.p4, j3.p4))
self.MinDiJetDRTight = lambda j1, j2, j3, j4: op.min(
op.min(
op.min(self.MinDiJetDRLoose(j1, j2, j3), op.deltaR(
j1.p4, j4.p4)), op.deltaR(j2.p4, j4.p4)),
op.deltaR(j3.p4, j4.p4))
self.MinDiJetDEtaLoose = lambda j1, j2, j3: op.min(
op.min(op.abs(j1.eta - j2.eta), op.abs(j2.eta - j3.eta)),
op.abs(j1.eta - j3.eta))
self.MinDiJetDEtaTight = lambda j1, j2, j3, j4: op.min(
op.min(
op.min(self.MinDiJetDEtaLoose(j1, j2, j3),
op.abs(j1.eta - j4.eta)), op.abs(j2.eta - j4.eta)),
op.abs(j3.eta - j4.eta))
self.MinDiJetDPhiLoose = lambda j1, j2, j3: op.min(
op.min(op.abs(op.deltaPhi(j1.p4, j2.p4)),
op.abs(op.deltaPhi(j2.p4, j3.p4))),
op.abs(op.deltaPhi(j1.p4, j3.p4)))
self.MinDiJetDPhiTight = lambda j1, j2, j3, j4: op.min(
op.min(
op.min(self.MinDiJetDPhiLoose(j1, j2, j3),
op.abs(op.deltaPhi(j1.p4, j4.p4))),
op.abs(op.deltaPhi(j2.p4, j4.p4))),
op.abs(op.deltaPhi(j3.p4, j4.p4)))
self.MaxDiJetDRLoose = lambda j1, j2, j3: op.max(
op.max(op.deltaR(j1.p4, j2.p4), op.deltaR(j2.p4, j3.p4)),
op.deltaR(j1.p4, j3.p4))
self.MaxDiJetDRTight = lambda j1, j2, j3, j4: op.max(
op.max(
op.max(self.MaxDiJetDRLoose(j1, j2, j3), op.deltaR(
j1.p4, j4.p4)), op.deltaR(j2.p4, j4.p4)),
op.deltaR(j3.p4, j4.p4))
self.MaxDiJetDEtaLoose = lambda j1, j2, j3: op.max(
op.max(op.abs(j1.eta - j2.eta), op.abs(j2.eta - j3.eta)),
op.abs(j1.eta - j3.eta))
self.MaxDiJetDEtaTight = lambda j1, j2, j3, j4: op.max(
op.max(
op.max(self.MaxDiJetDEtaLoose(j1, j2, j3),
op.abs(j1.eta - j4.eta)), op.abs(j2.eta - j4.eta)),
op.abs(j3.eta - j4.eta))
self.MaxDiJetDPhiLoose = lambda j1, j2, j3: op.max(
op.max(op.abs(op.deltaPhi(j1.p4, j2.p4)),
op.abs(op.deltaPhi(j2.p4, j3.p4))),
op.abs(op.deltaPhi(j1.p4, j3.p4)))
self.MaxDiJetDPhiTight = lambda j1, j2, j3, j4: op.max(
op.max(
op.max(self.MaxDiJetDPhiLoose(j1, j2, j3),
op.abs(op.deltaPhi(j1.p4, j4.p4))),
op.abs(op.deltaPhi(j2.p4, j4.p4))),
op.abs(op.deltaPhi(j3.p4, j4.p4)))
# ------------------------------------ lambdas for BDT variables ------------------------------------ #
# min jet-lep DR
self.mindr_lep1_jet = lambda lep, jets: op.deltaR(
lep.p4,
op.sort(jets, lambda j: op.deltaR(lep.p4, j.p4))[0].p4)
# HT
self.HTfull = lambda fleps, j1p4, j2p4, j3p4, j4p4: j1p4.Pt(
) + j2p4.Pt() + j3p4.Pt() + j4p4.Pt() + op.rng_sum(
fleps, lambda l: l.p4.Pt())
self.HTmiss = lambda fleps, j1p4, j2p4, j3p4: j1p4.Pt() + j2p4.Pt(
) + j3p4.Pt() + op.rng_sum(fleps, lambda l: l.p4.Pt())
# mT2
ET = lambda lepp4: op.sqrt(
op.pow(lepp4.M(), 2) + op.pow(lepp4.Pt(), 2))
self.mT2 = lambda jetp4, lepp4, metp4: (
op.pow(jetp4.M(), 2) + op.pow(lepp4.M(), 2) + op.pow(metp4.M(), 2)
+ 2 * (ET(lepp4) * ET(jetp4) -
(lepp4.Px() * jetp4.Px() + lepp4.Py() * jetp4.Py())) + 2 *
(ET(lepp4) * ET(metp4) -
(lepp4.Px() * metp4.Px() + lepp4.Py() * metp4.Py())) + 2 *
(ET(jetp4) * ET(metp4) -
(jetp4.Px() * metp4.Px() + jetp4.Py() * metp4.Py())))
# pZ component of met
# https://github.com/HEP-KBFI/hh-bbww/blob/f4ab60f81a920268a3f2187b97a58ec449b26883/src/comp_metP4_B2G_18_008.cc
# some necessary constants (visP4 = lepP4 + Wjj_simple)
# - - - - - used to compute neuP4 - - - - - #
ax = lambda visP4, met: 125.18 * 125.18 - op.pow(visP4.M(
), 2) + 2. * visP4.Px() * met.p4.Px() + 2. * visP4.Py() * met.p4.Py()
A = lambda visP4: 4.0 * op.pow(visP4.E(), 2) - op.pow(visP4.Pz(), 2)
B = lambda visP4, met: -4.0 * ax(visP4, met) * visP4.Pz()
C = lambda visP4, met: 4.0 * op.pow(visP4.E(), 2) * (op.pow(
met.p4.Px(), 2) + op.pow(met.p4.Py(), 2)) - op.pow(
ax(visP4, met), 2)
D = lambda visP4, met: (op.pow(B(visP4, met), 2) - 4.0 * A(visP4) * C(
visP4, met))
pos = lambda visP4, met: (-B(visP4, met) + op.sqrt(D(visP4, met))) / (
2. * A(visP4))
neg = lambda visP4, met: (-B(visP4, met) - op.sqrt(D(visP4, met))) / (
2. * A(visP4))
neuPz = lambda visP4, met: (op.switch(
D(visP4, met) < 0., -B(visP4, met) / (2 * A(visP4)),
op.switch(
op.abs(pos(visP4, met)) < op.abs(neg(visP4, met)),
pos(visP4, met), neg(visP4, met))))
# - - - - - - - - - - - - - - - - - - - - - #
self.neuP4 = lambda visP4, met: op._to.Construct(
"ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> >",
(met.p4.Px(), met.p4.Py(), neuPz(visP4, met),
op.sqrt(
op.pow(met.p4.Px(), 2) + op.pow(met.p4.Py(), 2) + op.pow(
neuPz(visP4, met), 2)))).result
# P4 of W1 (l,neu)
self.Wlep_simple = lambda wj1P4, wj2P4, lepP4, met: lepP4 + self.neuP4(
wj1P4 + wj2P4 + lepP4, met)
# P4 of W2 (j,j)
self.Wjj_simple = lambda j1P4, j2P4: j1P4 + j2P4
# DR_HadW_bJet
self.dR_HadW_bjet = lambda bP4, j1P4, j2P4: op.deltaR(
self.Wjj_simple(j1P4, j2P4), bP4)
# P4 of HWW (W1 + W2)
self.HWW_simple = lambda wj1P4, wj2P4, lepP4, met: self.Wjj_simple(
wj1P4, wj2P4) + self.Wlep_simple(wj1P4, wj2P4, lepP4, met)
# dR_HWW
self.dR_Hww = lambda j1P4, j2P4, lepP4, met: op.deltaR(
self.Wjj_simple(j1P4, j2P4),
self.Wlep_simple(j1P4, j2P4, lepP4, met))
self.dEta_Hww = lambda j1P4, j2P4, lepP4, met: op.abs(
self.Wjj_simple(j1P4, j2P4).Eta() - self.Wlep_simple(
j1P4, j2P4, lepP4, met).Eta())
self.dPhi_Hww = lambda j1P4, j2P4, lepP4, met: op.abs(
op.deltaPhi(self.Wjj_simple(j1P4, j2P4),
self.Wlep_simple(j1P4, j2P4, lepP4, met)))
# P4 of lep + met
self.Wlep_met_simple = lambda lepP4, metP4: lepP4 + metP4
# SimpleP4 of HWW (W1 + W2)
self.HWW_met_simple = lambda j1P4, j2P4, lepP4, metP4: self.Wjj_simple(
j1P4, j2P4) + self.Wlep_met_simple(lepP4, metP4)
# Total P4
self.HHP4_simple_met = lambda HbbRegP4, j1P4, j2P4, lepP4, metP4: HbbRegP4 + self.Wjj_simple(
j1P4, j2P4) + self.Wlep_met_simple(lepP4, metP4)
# CosThetaS calculation
#comp_cosThetaS = lambda ob1p4, ob2p4 : op.abs(ob1p4.Boost(-(ob1p4+ob2p4).BoostVector()).CosTheta())
motherPx = lambda ob1p4, ob2p4: (ob1p4.Px() + ob2p4.Px())
motherPy = lambda ob1p4, ob2p4: (ob1p4.Py() + ob2p4.Py())
motherPz = lambda ob1p4, ob2p4: (ob1p4.Pz() + ob2p4.Pz())
motherE = lambda ob1p4, ob2p4: (ob1p4.E() + ob2p4.E())
betaX = lambda ob1p4, ob2p4: motherPx(ob1p4, ob2p4) / motherE(
ob1p4, ob2p4)
betaY = lambda ob1p4, ob2p4: motherPy(ob1p4, ob2p4) / motherE(
ob1p4, ob2p4)
betaZ = lambda ob1p4, ob2p4: motherPz(ob1p4, ob2p4) / motherE(
ob1p4, ob2p4)
beta2 = lambda ob1p4, ob2p4: op.pow(betaX(ob1p4, ob2p4), 2) + op.pow(
betaY(ob1p4, ob2p4), 2) + op.pow(betaZ(ob1p4, ob2p4), 2)
gamma = lambda ob1p4, ob2p4: 1.0 / op.sqrt(1 - beta2(ob1p4, ob2p4))
betap = lambda ob1p4, ob2p4: betaX(ob1p4, ob2p4) * motherPx(
ob1p4, ob2p4) + betaY(ob1p4, ob2p4) * motherPy(
ob1p4, ob2p4) + betaZ(ob1p4, ob2p4) * motherPz(ob1p4, ob2p4)
gamma2 = lambda ob1p4, ob2p4: op.switch(
beta2(ob1p4, ob2p4) > 0,
(gamma(ob1p4, ob2p4) - 1) / beta2(ob1p4, ob2p4), op.c_float(0.0))
boostPx = lambda ob1p4, ob2p4: ob1p4.Px() + gamma2(
ob1p4, ob2p4) * betap(ob1p4, ob2p4) * betaX(ob1p4, ob2p4) + gamma(
ob1p4, ob2p4) * betaX(ob1p4, ob2p4) * ob1p4.E()
boostPy = lambda ob1p4, ob2p4: ob1p4.Px() + gamma2(
ob1p4, ob2p4) * betap(ob1p4, ob2p4) * betaY(ob1p4, ob2p4) + gamma(
ob1p4, ob2p4) * betaY(ob1p4, ob2p4) * ob1p4.E()
boostPz = lambda ob1p4, ob2p4: ob1p4.Pz() + gamma2(
ob1p4, ob2p4) * betap(ob1p4, ob2p4) * betaZ(ob1p4, ob2p4) + gamma(
ob1p4, ob2p4) * betaZ(ob1p4, ob2p4) * ob1p4.E()
boostP = lambda ob1p4, ob2p4: op.sqrt(
op.pow(boostPx(ob1p4, ob2p4), 2) + op.pow(boostPy(ob1p4, ob2p4), 2)
+ op.pow(boostPz(ob1p4, ob2p4), 2))
self.comp_cosThetaS = lambda ob1p4, ob2p4: op.abs(
boostPz(ob1p4, ob2p4) / boostP(ob1p4, ob2p4))
#BoostP3 = lambda ob1p4,ob2p4 : op._to.Construct("ROOT::Math::TVector<ROOT::Math::PxPyPz3D<float>>",(-motherPx(ob1p4,ob2p4), -motherPy(ob1p4,ob2p4), -motherPz(ob1p4,ob2p4))).result
#boost = lambda ob1p4,ob2p4 : op.construct("ROOT::Math::Boost", (-motherPx(ob1p4,ob2p4)/motherE(ob1p4,ob2p4),
# -motherPy(ob1p4,ob2p4)/motherE(ob1p4,ob2p4),
# -motherPz(ob1p4,ob2p4)/motherE(ob1p4,ob2p4)))
#self.comp_cosThetaS = lambda ob1p4,ob2p4 : op.abs(boost(ob1p4,ob2p4)(ob1p4).CosTheta())
#p4_boosted = lambda ob1p4,ob2p4 : op.extMethod("ROOT::Math::Boost{-motherPx(ob1p4,ob2p4)/motherE(ob1p4,ob2p4), -motherPy(ob1p4,ob2p4)/motherE(ob1p4,ob2p4), -motherPz(ob1p4,ob2p4)/motherE(ob1p4,ob2p4)}", returnType=(ob1p4+ob2p4)._typeName)(ob1p4+ob2p4)
#self.comp_cosThetaS = lambda ob1p4,ob2p4 : op.deltaR(ob1p4, p4_boosted(ob1p4,ob2p4))
#boost = lambda ob1p4, ob2p4: op.construct("ROOT::Math::Boost", (-betaX(ob1p4, ob2p4), -betaY(ob1p4, ob2p4), -betaZ(ob1p4, ob2p4)))
#boostP4 = lambda ob1p4,ob2p4 : boost(ob1p4,ob2p4)(ob1p4)
#self.comp_cosThetaS = lambda ob1p4,ob2p4 : op.abs(boostP4(ob1p4,ob2p4).Pz()/op.sqrt(op.pow(boostP4(ob1p4,ob2p4).Px(),2) + op.pow(boostP4(ob1p4,ob2p4).Py(),2) + op.pow(boostP4(ob1p4,ob2p4).Pz(),2)))
# MET_LD
# Equation 3 (page 33) of AN-2019/111 v13
# Similar to MET, but more robust against pileup
jetSumPx = lambda jets: op.rng_sum(jets, lambda j: j.p4.Px())
jetSumPy = lambda jets: op.rng_sum(jets, lambda j: j.p4.Py())
#lepSumPx = lambda leps : op.rng_sum(leps, lambda l : l.p4.Px())
#lepSumPy = lambda leps : op.rng_sum(leps, lambda l : l.p4.Py())
lepSumPx = lambda mus, els: op.rng_sum(mus, lambda l: l.p4.Px(
)) + op.rng_sum(els, lambda l: l.p4.Px())
lepSumPy = lambda mus, els: op.rng_sum(mus, lambda l: l.p4.Py(
)) + op.rng_sum(els, lambda l: l.p4.Py())
self.MET_LD = lambda met, jets, mus, els: 0.6 * met.pt + 0.4 * op.sqrt(
op.pow(jetSumPx(jets) + lepSumPx(mus, els), 2) + op.pow(
jetSumPy(jets) + lepSumPy(mus, els), 2))
empty_p4 = op.construct(
"ROOT::Math::LorentzVector<ROOT::Math::PtEtaPhiM4D<float> >",
([op.c_float(0.),
op.c_float(0.),
op.c_float(0.),
op.c_float(0.)]))
self.MET_LD_DL = lambda met, jets, electrons, muons : 0.6 * met.pt +\
0.4* (op.rng_sum(jets, (lambda j : j.p4), start=empty_p4) + op.rng_sum(electrons, (lambda e : e.p4), start=empty_p4) + op.rng_sum(muons, (lambda m : m.p4), start=empty_p4)).Pt()
# conept
self.lambdaConePt = lambda lep: op.switch(
op.abs(lep.pdgId) == 13, HHself.muon_conept[lep.idx], HHself.
electron_conept[lep.idx])
# angle between 2 planes
aDotB = lambda a, b: a.Px() * b.Px() + a.Py() * b.Py() + a.Pz() * b.Pz(
)
aMagB = lambda a, b: (op.sqrt(
op.pow(a.Px(), 2) + op.pow(a.Py(), 2) + op.pow(a.Pz(), 2))) * (
op.sqrt(
op.pow(b.Px(), 2) + op.pow(b.Py(), 2) + op.pow(b.Pz(), 2)))
self.angleWWplane = lambda lp4, met, j3p4, j4p4: op.acos(
aDotB(j3p4 + j4p4,
self.neuP4(j3p4 + j4p4 + lp4, met) + lp4) / aMagB(
j3p4 + j4p4,
self.neuP4(j3p4 + j4p4 + lp4, met) + lp4))
#self.angleWWplane = lambda lp4, met, j3p4, j4p4 : ((j3p4+j4p4).Vect().Unit()).Angle((self.neuP4(j3p4+j4p4+lp4, met)+lp4).Vect().Unit())
self.angleBetPlanes = lambda j1p4, j2p4, j3p4, j4p4: op.acos(
op.c_float(
aDotB(j1p4 + j2p4, j3p4 + j4p4) / aMagB(
j1p4 + j2p4, j3p4 + j4p4)))
self.empty_p4 = op.construct(
"ROOT::Math::LorentzVector<ROOT::Math::PtEtaPhiM4D<float> >",
([op.c_float(0.),
op.c_float(0.),
op.c_float(0.),
op.c_float(0.)]))
self.MET_LD_DL = lambda met, jets, electrons, muons : 0.6 * met.pt +\
0.4* (op.rng_sum(jets, (lambda j : j.p4), start=self.empty_p4) + op.rng_sum(electrons, (lambda e : e.p4), start=self.empty_p4) + op.rng_sum(muons, (lambda m : m.p4), start=self.empty_p4)).Pt()
self.isBoosted = op.AND(
op.rng_len(HHself.ak8BJets) >= 1,
op.rng_len(HHself.ak4JetsCleanedFromAk8b) >= 1)
#self.isBoosted = op.rng_len(HHself.ak8BJets) >= 1
self.isResolved = op.AND(
op.rng_len(HHself.ak4Jets) >= 3,
op.rng_len(HHself.ak4BJets) >= 1,
op.rng_len(HHself.ak8BJets) == 0)
#self.has1Wj = op.rng_len(HHself.probableWJets) == 1
#self.has2Wj = op.rng_len(HHself.wJetsPairs) >= 1
#self.isFullReco = op.AND(op.rng_len(HHself.bJetsByScore) >= 2, op.rng_len(HHself.wJetsPairs) >= 1)
#self.isMissReco = op.AND(op.rng_len(HHself.bJetsByScore) >= 2, op.rng_len(HHself.probableWJets) == 1)
#self.comp_m_hh_bregcorr = lambda bjets, wjets, lep, met : (op.rng_sum(bjets, (lambda bj : self.bJetCorrP4(bj)), start=empty_p4) +
# op.rng_sum(wjets, (lambda wj : self.bJetCorrP4(wj)), start=empty_p4) +
# met.p4 +
# lep.p4).M()
self.comp_m_hh_bregcorr = lambda bjets, wjets, lepconep4, met: (
op.rng_sum(bjets, (lambda bj: self.bJetCorrP4(bj)), start=empty_p4)
+ op.rng_sum(wjets, (lambda wj: self.bJetCorrP4(wj)),
start=empty_p4) + met.p4 + lepconep4).M()
#self.comp_pt_hh = lambda bjets, wjets, lep, met : (op.rng_sum(bjets, (lambda bj : bj.p4), start=empty_p4) +
# op.rng_sum(wjets, (lambda wj : wj.p4), start=empty_p4) +
# met.p4 +
# lep.p4).Pt()
self.comp_pt_hh = lambda bjets, wjets, lepconep4, met: (op.rng_sum(
bjets, (lambda bj: bj.p4), start=empty_p4) + op.rng_sum(
wjets,
(lambda wj: wj.p4), start=empty_p4) + met.p4 + lepconep4).Pt()
#self.comp_dphi_hbb_hww = lambda bjets, wjets, lep, met : op.deltaPhi((op.rng_sum(wjets, (lambda wj : wj.p4), start=empty_p4) + met.p4 + lep.p4),
# op.rng_sum(bjets, (lambda bj : bj.p4), start=empty_p4))
#self.comp_dphi_hbb_hwwvis = lambda bjets, wjets, lep : op.deltaPhi((op.rng_sum(wjets, (lambda wj : wj.p4), start=empty_p4) + lep.p4),
# op.rng_sum(bjets, (lambda bj : bj.p4), start=empty_p4))
self.comp_dphi_hbb_hww = lambda bjets, wjets, lepconep4, met: op.deltaPhi(
(op.rng_sum(wjets, (lambda wj: wj.p4), start=empty_p4) + met.p4 +
lepconep4), op.rng_sum(bjets, (lambda bj: bj.p4), start=empty_p4))
self.comp_dphi_hbb_hwwvis = lambda bjets, wjets, lepconep4: op.deltaPhi(
(op.rng_sum(wjets,
(lambda wj: wj.p4), start=empty_p4) + lepconep4),
op.rng_sum(bjets, (lambda bj: bj.p4), start=empty_p4))
def returnHighLevelMVAInputs(self,l1,l2,met,jets,bjets,electrons,muons,channel):
if channel == "ElEl":
cone_l1 = self.getElectronConeP4(l1)
cone_l2 = self.getElectronConeP4(l2)
elif channel == "MuMu":
cone_l1 = self.getMuonConeP4(l1)
cone_l2 = self.getMuonConeP4(l2)
elif channel == "ElMu":
cone_l1 = self.getElectronConeP4(l1)
cone_l2 = self.getMuonConeP4(l2)
else:
raise RuntimeError("Wrong channel")
dijets = op.combine(jets, N=2)
import bamboo.treeoperations as _to
def rng_min(rng, fun=(lambda x : x), typeName="float"):
return op._to.Reduce.fromRngFun(rng, op.c_float(float("+inf"), typeName), ( lambda fn : (
lambda res, elm : op.extMethod("std::min", returnType="Float_t")(res, fn(elm))
) )(fun) )
if self.args.Boosted0Btag or self.args.Boosted1Btag:
VBFJetPairs = self.VBFJetPairsBoosted
elif self.args.Resolved0Btag or self.args.Resolved1Btag or self.args.Resolved2Btag:
VBFJetPairs = self.VBFJetPairsResolved
else:
raise RuntimeError("Wrong selection to be used by the DNN")
return {
('m_bb_bregcorr', 'Di-bjet invariant mass (regcorr) [GeV]', (100,0.,1000.)) : op.multiSwitch((op.rng_len(bjets) == 0, op.c_float(0.)),
(op.rng_len(bjets) == 1, self.HLL.getCorrBp4(bjets[0]).M()),
op.invariant_mass(self.HLL.getCorrBp4(bjets[0]),self.HLL.getCorrBp4(bjets[1]))),
('ht', 'HT(jets) [GeV]', (100,0.,1000.)) : op.rng_sum(jets, lambda j : j.pt),
('min_dr_jets_lep1', 'Min(#Delta R(lead lepton,jets))', (25,0.,5.)) : op.switch(op.rng_len(jets) > 0,
op.switch(cone_l1.Pt() >= cone_l2.Pt(),
self.HLL.MinDR_part1_partCont(cone_l1,jets),
self.HLL.MinDR_part1_partCont(cone_l2,jets)),
op.c_float(0.)),
('min_dr_jets_lep2', 'Min(#Delta R(sublead lepton,jets))', (25,0.,5.)) : op.switch(op.rng_len(jets) > 0,
op.switch(cone_l1.Pt() >= cone_l2.Pt(),
self.HLL.MinDR_part1_partCont(cone_l2,jets),
self.HLL.MinDR_part1_partCont(cone_l1,jets)),
op.c_float(0.)),
('m_ll', 'Dilepton invariant mass [GeV]', (100,0.,1000.)) : op.invariant_mass(cone_l1,cone_l2),
('dr_ll', 'Dilepton #Delta R', (25,0.,5.)) : op.deltaR(cone_l1,cone_l2),
('min_dr_jet', 'Min(#Delta R(jets))', (25,0.,5.)) : op.switch(op.rng_len(dijets) > 0,
op.rng_min(dijets,lambda dijet : op.deltaR(dijet[0].p4,dijet[1].p4)),
op.c_float(0.)),
('min_dhi_jet', 'Min(#Delta #Phi(jets))', (16,0.,3.2)) : op.switch(op.rng_len(dijets) > 0,
rng_min(dijets,lambda dijet : op.abs(op.deltaPhi(dijet[0].p4,dijet[1].p4)),typeName='double'),
op.c_float(0.)),
('m_hh_simplemet_bregcorr','M_{HH} (simple MET) (regcorr) [GeV]', (100,0.,1000.)) : op.invariant_mass(op.rng_sum(bjets,
lambda bjet : self.HLL.getCorrBp4(bjet),
start=self.HLL.empty_p4),
cone_l1,
cone_l2,
met.p4),
('met_ld', 'MET_{LD}', (100,0.,1000.)) : self.HLL.MET_LD_DL(met,jets,electrons,muons),
('dr_bb', 'Di-bjet #Delta R', (25,0.,5.)) : op.switch(op.rng_len(bjets)>=2,
op.deltaR(bjets[0].p4,bjets[1].p4),
op.c_float(0.)),
('min_dr_leps_b1', 'Min(#Delta R(lead bjet,dilepton))', (25,0.,5.)) : op.switch(op.rng_len(bjets)>=1,
self.HLL.MinDR_part1_dipart(bjets[0].p4,[cone_l1,cone_l2]),
op.c_float(0.)),
('min_dr_leps_b2', 'Min(#Delta R(sublead bjet,dilepton))', (25,0.,5.)) : op.switch(op.rng_len(bjets)>=2,
self.HLL.MinDR_part1_dipart(bjets[1].p4,[cone_l1,cone_l2]),
op.c_float(0.)),
('lep1_conept', 'Lead lepton cone-P_T [GeV]', (40,0.,200.)) : op.switch(cone_l1.Pt() >= cone_l2.Pt() , cone_l1.Pt() , cone_l2.Pt()),
('lep2_conept', 'Sublead lepton cone-P_T [GeV]', (40,0.,200.)) : op.switch(cone_l1.Pt() >= cone_l2.Pt() , cone_l2.Pt() , cone_l1.Pt()),
('mww_simplemet', 'M_{WW} (simple MET) [GeV]', (100,0.,1000.)) : op.invariant_mass(cone_l1,cone_l2,met.p4),
('vbf_tag', 'VBF tag', (2,0.,2.)) : op.c_int(op.rng_len(VBFJetPairs)>0),
('boosted_tag', 'Boosted tag', (2,0.,2.)) : op.c_int(op.OR(op.rng_len(self.ak8BJets) > 0, # Boosted 1B
op.AND(op.rng_len(self.ak8BJets) == 0, # Boosted 0B
op.rng_len(self.ak8Jets) > 0,
op.rng_len(self.ak4BJets) == 0))),
('dphi_met_dilep', 'Dilepton-MET #Delta #Phi', (32,-3.2,3.2)) : op.abs(op.deltaPhi(met.p4,(cone_l1+cone_l2))),
('dphi_met_dibjet', 'Dibjet-MET #Delta #Phi', (32,-3.2,3.2)) : op.multiSwitch((op.rng_len(bjets) == 0, op.c_float(0.)),
(op.rng_len(bjets) == 1, op.abs(op.deltaPhi(met.p4,bjets[0].p4))),
op.abs(op.deltaPhi(met.p4,(bjets[0].p4+bjets[1].p4)))),
('dr_dilep_dijet', 'Dilepton-dijet #Delta R', (25,0.,5.)) : op.multiSwitch((op.rng_len(jets) == 0, op.c_float(0.)),
(op.rng_len(jets) == 1, op.deltaR((cone_l1+cone_l2),jets[0].p4)),
op.deltaR((cone_l1+cone_l2),(jets[0].p4+jets[1].p4))),
('dr_dilep_dibjet', 'Dilepton-dibjet #Delta R', (25,0.,5.)) : op.multiSwitch((op.rng_len(bjets) == 0, op.c_float(0.)),
(op.rng_len(bjets) == 1, op.deltaR((cone_l1+cone_l2),bjets[0].p4)),
op.deltaR((cone_l1+cone_l2),(bjets[0].p4+bjets[1].p4))),
('vbf_pair_mass', 'VBF pair M_{jj}', (100,0.,1000.)) : op.switch(op.rng_len(VBFJetPairs)>0,
op.invariant_mass(VBFJetPairs[0][0].p4,VBFJetPairs[0][1].p4),
op.c_float(0.)),
('vbf_pairs_absdeltaeta', 'VBF pair #Delta#eta', (25,0.,5.)) : op.switch(op.rng_len(VBFJetPairs)>0,
op.abs(VBFJetPairs[0][0].eta-VBFJetPairs[0][1].eta),
op.c_float(0.)),
('sphericity', 'None', (1,0.,1.)) : op.c_float(0.),
('sphericity_T', 'None', (1,0.,1.)) : op.c_float(0.),
('aplanarity', 'None', (1,0.,1.)) : op.c_float(0.),
('eventshape_C', 'None', (1,0.,1.)) : op.c_float(0.),
('eventshape_D', 'None', (1,0.,1.)) : op.c_float(0.),
('eventshape_Y', 'None', (1,0.,1.)) : op.c_float(0.),
('foxwolfram1', 'None', (1,0.,1.)) : op.c_float(0.),
('foxwolfram2', 'None', (1,0.,1.)) : op.c_float(0.),
('foxwolfram3', 'None', (1,0.,1.)) : op.c_float(0.),
('foxwolfram4', 'None', (1,0.,1.)) : op.c_float(0.),
('foxwolfram5', 'None', (1,0.,1.)) : op.c_float(0.),
('centrality', 'None', (1,0.,1.)) : op.c_float(0.),
('centrality_jets', 'None', (1,0.,1.)) : op.c_float(0.),
('eigenvalue1', 'None', (1,0.,1.)) : op.c_float(0.),
('eigenvalue2', 'None', (1,0.,1.)) : op.c_float(0.),
('eigenvalue3', 'None', (1,0.,1.)) : op.c_float(0.),
}
def definePlots(self, t, noSel, sample=None, sampleCfg=None):
from bamboo.plots import Plot, CutFlowReport, SummedPlot
from bamboo.plots import EquidistantBinning as EqB
from bamboo import treefunctions as op
isMC = self.isMC(sample)
trigCut, trigWeight = None, None
if isMC:
noSel = noSel.refine(
"mcWeight", weight=[t.genWeight, t.puWeight, t.PrefireWeight])
trigCut = op.OR(t.HLT.HIEle20_Ele12_CaloIdL_TrackIdL_IsoVL_DZ,
t.HLT.HIL3DoubleMu0, t.HLT.HIL3Mu20,
t.HLT.HIEle20_WPLoose_Gsf)
trigWeight = op.switch(
op.OR(t.HLT.HIEle20_Ele12_CaloIdL_TrackIdL_IsoVL_DZ,
t.HLT.HIL3DoubleMu0), op.c_float(1.),
op.switch(t.HLT.HIL3Mu20, op.c_float(306.913 / 308.545),
op.c_float(264.410 / 308.545)))
## TODO add a correction for prescaled triggers
else:
## suggested trigger order: dielectron, dimuon or single muon, single electron (to minimise loss due to prescales). Electron triggered-events should be taken from the HighEGJet primary datasets, muon-triggered events from the SingleMuon primary datset
### Remove overlap events in datasets -->Not used
#if not self.isMC(sample):
#trigSel = noSel.refine("trigAndPrimaryDataset",
# cut=makeMultiPrimaryDatasetTriggerSelection(sample, {
# "DoubleMuon" : [ t.HLT.HIL3DoubleMu0 ],
# "DoubleEG" : t.HLT.HIEle20_Ele12_CaloIdL_TrackIdL_IsoVL_DZ,
# "MuonEG" : [ t.HLT.HIL3Mu20, t.HLT.HIEle20_WPLoose_Gsf ]
# }))
###used following
pd = sample.split("_")[0]
if pd == "SingleMuon":
## TODO fill trigger cut
trigCut = op.AND(
op.OR(t.HLT.HIL3Mu20, t.HLT.HIL3DoubleMu0),
op.NOT(t.HLT.HIEle20_Ele12_CaloIdL_TrackIdL_IsoVL_DZ))
elif pd == "HighEGJet":
## TODO fill trigger cut
trigCut = op.AND(
op.OR(t.HLT.HIEle20_WPLoose_Gsf,
t.HLT.HIEle20_Ele12_CaloIdL_TrackIdL_IsoVL_DZ),
op.NOT(op.OR(t.HLT.HIL3Mu20, t.HLT.HIL3DoubleMu0)))
noSel = noSel.refine("trig", cut=trigCut, weight=trigWeight)
plots = []
goodLeptons = {
"el": op.select(t.Electron, partial(isGoodElectron, ptCut=15.)),
"mu": op.select(t.Muon, partial(isGoodMuon, ptCut=15.))
}
plots += [
Plot.make1D(
"trig_nLeptons15",
op.rng_len(goodLeptons["el"]) + op.rng_len(goodLeptons["mu"]),
noSel, EqB(15, 0., 15.)),
Plot.make1D("trig_nEl15", op.rng_len(goodLeptons["el"]), noSel,
EqB(15, 0., 15.)),
Plot.make1D("trig_nMu15", op.rng_len(goodLeptons["mu"]), noSel,
EqB(15, 0., 15.))
]
from bamboo.scalefactors import get_scalefactor
sf_loose = {
"mu":
get_scalefactor("lepton",
"Muon_RecoToLoose",
sfLib=scalefactors_lepMVA,
paramDefs=binningVariables_nano_noScaleSyst,
systName="muLoose"),
"el":
get_scalefactor("lepton",
"Electron_RecoToLoose",
sfLib=scalefactors_lepMVA,
paramDefs=binningVariables_nano_noScaleSyst,
systName="elLoose")
}
sf_tight = {
"mu":
get_scalefactor("lepton",
"Muon_LooseToTight",
sfLib=scalefactors_lepMVA,
paramDefs=binningVariables_nano_noScaleSyst,
systName="muTight"),
"el":
get_scalefactor("lepton",
"Electron_LooseToTight",
sfLib=scalefactors_lepMVA,
paramDefs=binningVariables_nano_noScaleSyst,
systName="elTight")
}
nGoodLeptons = op.rng_len(goodLeptons["el"]) + op.rng_len(
goodLeptons["mu"])
hasTwoGoodLeptons = noSel.refine(
"has2Lep", cut=(nGoodLeptons > 1)) # avoid overlap with 1l
jets = op.sort(
op.select(
t.Jet,
lambda j: op.AND(
j.pt > 25., ## you decide...
op.abs(j.eta) < 2.4,
j.jetId & 0x2, ## tight JetID
op.AND( ## lepton-jet cross-cleaning
op.NOT(
op.rng_any(goodLeptons["el"], lambda l: op.deltaR(
l.p4, j.p4) < 0.4)),
op.NOT(
op.rng_any(goodLeptons["mu"], lambda l: op.deltaR(
l.p4, j.p4) < 0.4))))),
lambda j: -j.pt)
for fl1, fl2 in product(*repeat(goodLeptons.keys(), 2)):
dilepSel = lambda l1, l2: op.AND(l1.charge != l2.charge,
(l1.p4 + l2.p4).M() > 12.)
if fl1 == fl2:
lGood = op.sort(goodLeptons[fl1], lambda l: -l.pt)
dilep = op.combine(lGood, N=2, pred=dilepSel)
else:
l1Good = op.sort(goodLeptons[fl1], lambda l: -l.pt)
l2Good = op.sort(goodLeptons[fl2], lambda l: -l.pt)
dilep = op.combine((l1Good, l2Good), pred=dilepSel)
ll = dilep[0]
hasDilep = hasTwoGoodLeptons.refine(
f"hasDilep{fl1}{fl2}",
cut=(op.rng_len(dilep) > 0, ll[0].pt > 25.),
weight=([
sf_loose[fl1](ll[0]), sf_loose[fl2](ll[1]), sf_tight[fl1](
ll[0]), sf_tight[fl2](ll[1])
] if isMC else None))
plots += [
Plot.make1D(f"dilepton_{fl1}{fl2}_Mll",
(ll[0].p4 + ll[1].p4).M(),
hasDilep,
EqB(200, 0, 200.),
title="Dilepton mass"),
]
for il, ifl in enumerate((fl1, fl2)):
plots += [
Plot.make1D(f"dilepton_{fl1}{fl2}_L{il:d}PT",
ll[il].pt,
hasDilep,
EqB(250, 0., 250.),
title=f"Lepton {il:d} PT"),
Plot.make1D(f"dilepton_{fl1}{fl2}_L{il:d}ETA",
ll[il].eta,
hasDilep,
EqB(50, -2.5, 2.5),
title=f"Lepton {il:d} ETA"),
]
plots += [
Plot.make1D(f"dilepton_{fl1}{fl2}_nJets",
op.rng_len(jets),
hasDilep,
EqB(15, 0, 15.),
title="Jet multiplicity"),
]
return plots
def __init__(self, HHself):
# All the attributes of the BaseHH are contained in HHself object
# All the lambdas will be saved in the highlevelLambdas object to avoid confusions of all the attributes of HH base object
# 4-Momentum association #
self.ll_p4 = lambda l1, l2: l1.p4 + l2.p4
self.lljj_p4 = lambda l1, l2, j1, j2: l1.p4 + l2.p4 + j1.p4 + j2.p4
self.lep1j_p4 = lambda lep, j1: lep.p4 + j1.p4
self.lep2j_p4 = lambda lep, j1, j2: lep.p4 + j1.p4 + j2.p4
self.lep3j_p4 = lambda lep, j1, j2, j3: lep.p4 + j1.p4 + j2.p4 + j3.p4
self.lep4j_p4 = lambda lep, j1, j2, j3, j4: lep.p4 + j1.p4 + j2.p4 + j3.p4 + j4.p4
# bReg corr 4 momenta of ak4-bTagged jet #
self.bJetCorrP4 = lambda j: op._to.Construct(
"ROOT::Math::LorentzVector<ROOT::Math::PtEtaPhiM4D<float> >",
(j.pt * j.bRegCorr, j.eta, j.phi, j.mass)).result
# Dilep-Met variables #
self.DilepMET_deltaPhi = lambda l1, l2, met: self.ll_p4(l1, l2).Phi(
) - met.phi
self.DilepMET_Pt = lambda l1, l2, met: op.sqrt(
op.pow(met.pt * op.cos(met.phi) + self.ll_p4(l1, l2).Px(), 2) + op.
pow(met.pt * op.sin(met.phi) + self.ll_p4(l1, l2).Py(), 2))
# SingleLep-Met variables
self.SinglepMet_Pt = lambda lep, met: op.sqrt(
op.pow(met.pt * op.cos(met.phi) + lep.p4.Px(), 2) + op.pow(
met.pt * op.sin(met.phi) + lep.p4.Py(), 2))
self.SinglepMet_dPhi = lambda lep, met: lep.p4.Phi() - met.phi
# Transverse mass #
self.MT_ll = lambda l1, l2, met: op.sqrt(2 * self.ll_p4(l1, l2).Pt(
) * met.pt * (1 - op.cos(self.ll_p4(l1, l2).Phi() - met.phi)))
self.MT_lljj = lambda l1, l2, j1, j2, met: op.sqrt(
2 * self.lljj_p4(l1, l2, j1, j2).Pt() * met.pt *
(1 - op.cos(self.lljj_p4(l1, l2, j1, j2).Phi() - met.phi)))
self.MT = lambda lep, met: op.sqrt(2 * lep.p4.Pt() * met.pt * (
1 - op.cos(lep.p4.Phi() - met.phi)))
self.MT_W1W2_ljj = lambda lep, j1, j2, met: op.sqrt(
2 * self.lep2j_p4(lep, j1, j2).Pt() * met.pt *
(1 - op.cos(self.lep2j_p4(lep, j1, j2).Phi() - met.phi)))
self.MT_W1W2_lj = lambda lep, j1, met: op.sqrt(
2 * self.lep1j_p4(lep, j1).Pt() * met.pt *
(1 - op.cos(self.lep1j_p4(lep, j1).Phi() - met.phi)))
# TODO : clean different versions (eg MT)
# dilep + dijet #
self.M_lljj = lambda l1, l2, j1, j2: op.invariant_mass(
self.lljj_p4(l1, l2, j1, j2))
self.MinDR_lj = lambda l1, l2, j1, j2: op.min(
op.min(op.deltaR(l1.p4, j1.p4), op.deltaR(l1.p4, j2.p4)),
op.min(op.deltaR(l2.p4, j1.p4), op.deltaR(l2.p4, j2.p4)))
self.MinDR_lep3j = lambda lep, j1, j2, j3: op.min(
op.min(op.deltaR(lep.p4, j1.p4), op.deltaR(lep.p4, j2.p4)),
op.deltaR(lep.p4, j3.p4))
# Higgs related variables #
self.HT2 = lambda l1, l2, j1, j2, met: op.sqrt(
op.pow(met.pt * op.cos(met.phi) + l1.p4.Px() + l2.p4.Px(), 2) + op.
pow(met.pt * op.sin(met.phi) + l1.p4.Py() + l2.p4.Py(), 2
)) + op.abs((j1.p4 + j2.p4).Pt())
self.HT2R = lambda l1, l2, j1, j2, met: self.HT2(
met, l1, l2, j1, j2) / (met.pt + l1.p4.Pt() + l2.p4.Pt() + j1.p4.
Pt() + j2.p4.Pt())
self.HT2_l3jmet = lambda l, j1, j2, j3, met: op.sqrt(
op.pow(met.pt * op.cos(met.phi) + l.p4.Px(), 2) + op.pow(
met.pt * op.sin(met.phi) + l.p4.Py(), 2)) + op.abs(
(j1.p4 + j2.p4 + j3.p4).Pt())
self.HT2R_l3jmet = lambda l, j1, j2, j3, met: self.HT2_l3jmet(
met, l, j1, j2, j3) / (met.pt + l.p4.Pt() + j1.p4.Pt() + j2.p4.Pt(
) + j3.p4.Pt())
self.HT2_l4jmet = lambda l, j1, j2, j3, j4, met: op.sqrt(
op.pow(met.pt * op.cos(met.phi) + l.p4.Px(), 2) + op.pow(
met.pt * op.sin(met.phi) + l.p4.Py(), 2)) + op.abs(
(j1.p4 + j2.p4 + j3.p4 + j4.p4).Pt())
self.HT2R_l4jmet = lambda l, j1, j2, j3, j4, met: self.HT2_l4jmet(
met, l, j1, j2, j3, j4) / (met.pt + l.p4.Pt() + j1.p4.Pt() + j2.p4.
Pt() + j3.p4.Pt() + j4.p4.Pt())
#min j1j2DR
self.MinDiJetDRLoose = lambda j1, j2, j3: op.min(
op.min(op.deltaR(j1.p4, j2.p4), op.deltaR(j2.p4, j3.p4)),
op.deltaR(j1.p4, j3.p4))
# ------------------------------------ lambdas for BDT variables ------------------------------------ #
self.mindr_lep1_jet = lambda lep, jets: op.deltaR(
lep.p4,
op.sort(jets, lambda j: op.deltaR(lep.p4, j.p4))[0].p4)
self.HT = lambda jets: op.rng_sum(jets, lambda j: j.p4.Pt())
# mT2
self.ET = lambda lep: op.sqrt(
op.pow(lep.p4.M(), 2) + op.pow(lep.p4.Pt(), 2))
self.mT2 = lambda jet, lep, met: (
op.pow(jet.p4.M(), 2) + op.pow(lep.p4.M(), 2) + op.pow(
met.p4.M(), 2) + 2 *
(ET(lep) * ET(jet) -
(lep.p4.Px() * jet.p4.Px() + lep.p4.Py() * jet.p4.Py())) + 2 *
(ET(lep) * ET(met) -
(lep.p4.Px() * met.p4.Px() + lep.p4.Py() * met.p4.Py())) + 2 *
(ET(jet) * ET(met) -
(jet.p4.Px() * met.p4.Px() + jet.p4.Py() * met.p4.Py())))
# pZ component of met
# https://github.com/HEP-KBFI/hh-bbww/blob/f4ab60f81a920268a3f2187b97a58ec449b26883/src/comp_metP4_B2G_18_008.cc
# some necessary constants (visP4 = lepP4 + Wjj_simple)
# - - - - - used to compute neuP4 - - - - - #
_a = lambda visP4, met, mH: (op.pow(mH, 2) - op.pow(visP4.M(
), 2) + 2. * visP4.Px() * met.p4.Px() + 2. * visP4.Py() * met.p4.Py())
_A = lambda visP4: 4.0 * op.pow(visP4.E(), 2) - op.pow(visP4.Pz(), 2)
_B = lambda visP4, met, mH: -4.0 * _a(visP4, met, mH) * visP4.Pz()
_C = lambda visP4, met, mH: 4.0 * op.pow(visP4.E(), 2) * (op.pow(
met.p4.Px(), 2) + op.pow(met.p4.Py(), 2)) - op.pow(
_a(visP4, met, mH), 2)
_D = lambda visP4, met, mH: (op.pow(_B(visP4, met, mH), 2) - 4.0 * _A(
visP4) * _C(visP4, met, mH))
_pos = lambda visP4, met, mH: (-_B(visP4, met, mH) + op.sqrt(
_D(visP4, met, mH))) / (2. * _A(visP4))
_neg = lambda visP4, met, mH: (-_B(visP4, met, mH) - op.sqrt(
_D(visP4, met, mH))) / (2. * _A(visP4))
neuPz = lambda visP4, met, mH: (op.switch(
_D(visP4, met, mH) < 0., -_B(visP4, met, mH) / (2. * _A(visP4)),
op.switch(
op.abs(_pos(visP4, met, mH)) < op.abs(_neg(visP4, met, mH)),
_pos(visP4, met, mH), _neg(visP4, met, mH))))
# - - - - - - - - - - - - - - - - - - - - - #
neuP4 = lambda visP4, met, mH: op._to.Construct(
"ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> >",
(met.p4.Px(), met.p4.Py(), neuPz(visP4, met, mH),
op.sqrt(
op.pow(met.p4.Px(), 2) + op.pow(met.p4.Py(), 2) + op.pow(
neuPz(visP4, met, mH), 2)))).result
# P4 of W1 (l,neu)
self.Wlep_simple = lambda j1P4, j2P4, lepP4, met, mH: lepP4 + neuP4(
j1P4 + j2P4 + lepP4, met, mH)
# P4 of W2 (j,j)
self.Wjj_simple = lambda j1P4, j2P4: j1P4 + j2P4
# P4 of HWW (W1 + W2)
self.HWW_simple = lambda j1P4, j2P4, lepP4, met, mH: Wjj_simple(
j1P4, j2P4) + Wlep_simple(lepP4, neuP4(j1P4 + j2P4 + lepP4, met, mH
))
# dR_HWW
self.dR_Hww = lambda j1P4, j2P4, lepP4, met, mH: op.deltaR(
Wjj_simple(j1P4, j2P4), Wlep_simple(j1P4, j2P4, lepP4, met, mH))
# P4 of lep + met
self.Wlep_met_simple = lambda lepP4, metP4: lepP4 + metP4
# SimpleP4 of HWW (W1 + W2)
self.HWW_met_simple = lambda j1P4, j2P4, lepP4, metP4: Wjj_simple(
j1P4, j2P4) + Wlep_met_simple(lepP4, metP4)
# Total P4
self.HHP4_simple_met = lambda HbbRegP4, j1P4, j2P4, lepP4, metP4: HbbRegP4 + Wjj_simple(
j1P4, j2P4) + Wlep_met_simple(lepP4, metP4)
# CosThetaS calculation
#comp_cosThetaS = lambda ob1p4, ob2p4 : op.abs(ob1p4.Boost(-(ob1p4+ob2p4).BoostVector()).CosTheta())
motherPx = lambda ob1p4, ob2p4: (ob1p4.Px() + ob2p4.Px())
motherPy = lambda ob1p4, ob2p4: (ob1p4.Py() + ob2p4.Py())
motherPz = lambda ob1p4, ob2p4: (ob1p4.Pz() + ob2p4.Pz())
motherE = lambda ob1p4, ob2p4: (ob1p4.E() + ob2p4.E())
BoostP4 = lambda ob1p4, ob2p4: op._to.Construct(
"ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<float> >",
(motherPx(ob1p4, ob2p4), motherPy(ob1p4, ob2p4),
motherPz(ob1p4, ob2p4), motherE(ob1p4, ob2p4))).result
self.comp_cosThetaS = lambda ob1p4, ob2p4: op.abs(
op.cos(op.deltaR(BoostP4(ob1p4, ob2p4), ob1p4)))
# MET_LD
# Equation 3 (page 33) of AN-2019/111 v13
# Similar to MET, but more robust against pileup
jetSumPx = lambda jets: op.rng_sum(jets, lambda j: j.p4.Px())
jetSumPy = lambda jets: op.rng_sum(jets, lambda j: j.p4.Py())
lepSumPx = lambda leps: op.rng_sum(leps, lambda l: l.p4.Px())
lepSumPy = lambda leps: op.rng_sum(leps, lambda l: l.p4.Py())
self.MET_LD = lambda met, jets, leps: 0.6 * met.pt + 0.4 * op.sqrt(
op.pow(jetSumPx(jets) + lepSumPx(leps), 2) + op.pow(
jetSumPy(jets) + lepSumPy(leps), 2))
def defineSkimSelection(self, t, noSel, sample=None, sampleCfg=None):
noSel = super(SkimmerNanoHHtobbWWSL,
self).prepareObjects(t,
noSel,
sample,
sampleCfg,
"SL",
forSkimmer=True)
era = sampleCfg['era']
# Initialize varsToKeep dict #
varsToKeep = dict()
if not self.inclusive_sel:
jet_level = ["Resolved2Btag", "Resolved1Btag", "Boosted"]
# Only one lepton_level must be in args and Only one jet_level must be in args
if [
boolean for (level, boolean) in self.args.__dict__.items()
if level in jet_level
].count(True) != 1:
raise RuntimeError(
"Only one of the jet arguments must be used, check --help")
if self.args.Channel not in ["El", "Mu"]:
raise RuntimeError("Channel must be either 'El' or 'Mu'")
#----- Machine Learning Model -----#
model_nums = ["01", "02"]
path_model_01 = os.path.join(
os.path.abspath(os.path.dirname(__file__)), 'MachineLearning',
'ml-models', 'models', 'multi-classification', 'dnn', 'SL',
model_nums[0], 'model', 'model.pb')
path_model_02 = os.path.join(
os.path.abspath(os.path.dirname(__file__)), 'MachineLearning',
'ml-models', 'models', 'multi-classification', 'dnn', 'SL',
model_nums[1], 'model', 'model.pb')
input_names_01 = [
"lep", "jet", "fat", "met", "hl", "param", "eventnr"
]
input_names_02 = [
"lep", "jet", "fat", "met", "nu", "hl", "param", "eventnr"
]
output_name = "Identity"
if not self.args.OnlyYield:
print("DNN model : %s" % path_model_02)
if not os.path.exists(path_model_02):
raise RuntimeError('Could not find model file %s' %
path_model_02)
try:
DNN_02 = op.mvaEvaluator(path_model_02,
mvaType='Tensorflow',
otherArgs=(input_names_02,
output_name))
except:
raise RuntimeError('Could not load model %s' %
path_model_02)
self.nodes = ['GGF', 'VBF', 'TT', 'ST', 'WJets', 'H', 'Other']
#----- Lepton selection -----#
# Args are passed within the self #
#ElSelObj, MuSelObj = makeSingleLeptonSelection(self,noSel,use_dd=False)
ElSelObj, MuSelObj = makeSingleLeptonSelection(
self, noSel, use_dd=False, fake_selection=self.args.FakeCR)
# --- apply jet correction --- #
ElSelObj.sel = self.beforeJetselection(ElSelObj.sel, 'El')
MuSelObj.sel = self.beforeJetselection(MuSelObj.sel, 'Mu')
if self.args.Channel == "El":
selObj = ElSelObj
#lepton = self.electronsTightSel[0]
lepton = self.electronsFakeSel[0]
lepconep4 = self.getElectronConeP4(lepton)
if self.args.Channel == "Mu":
selObj = MuSelObj
#lepton = self.muonsTightSel[0]
lepton = self.muonsFakeSel[0]
lepconep4 = self.getMuonConeP4(lepton)
#----- Jet selection -----#
# Since the selections in one line, we can use the non copy option of the selection to modify the selection object internally
if any([
self.args.__dict__[item]
for item in ["Resolved2Btag", "Resolved1Btag"]
]):
makeResolvedSelection(self, selObj)
#VBFJetPairs = mvaEvaluatorSL_nonres_DNN01.VBFJetPairs_Resolved(self)
VBFJetPairs = self.VBFJetPairsResolved
if self.args.Resolved2Btag:
makeExclusiveResolvedSelection(self, selObj, nbJet=2)
print('Resolved2Btag')
if self.args.Resolved1Btag:
makeExclusiveResolvedSelection(self, selObj, nbJet=1)
print('Resolved1Btag')
if self.args.Boosted:
makeBoostedSelection(self, selObj)
#VBFJetPairs = mvaEvaluatorSL_nonres_DNN01.VBFJetPairs_Boosted(self)
VBFJetPairs = self.VBFJetPairsBoosted
print('BoostedHbb')
else:
noSel = self.beforeJetselection(noSel)
#---------------------------------------------------------------------------------------#
# Synchronization tree #
#---------------------------------------------------------------------------------------#
if self.args.Synchronization:
# Event variables #
varsToKeep["event"] = None # Already in tree
varsToKeep["run"] = None # Already in tree
varsToKeep["ls"] = t.luminosityBlock
varsToKeep["n_presel_mu"] = op.static_cast(
"UInt_t", op.rng_len(self.muonsPreSel))
varsToKeep["n_fakeablesel_mu"] = op.static_cast(
"UInt_t", op.rng_len(self.muonsFakeSel))
varsToKeep["n_tightsel_mu"] = op.static_cast(
"UInt_t", op.rng_len(self.muonsTightSel))
varsToKeep["n_presel_ele"] = op.static_cast(
"UInt_t", op.rng_len(self.electronsPreSel))
varsToKeep["n_fakeablesel_ele"] = op.static_cast(
"UInt_t", op.rng_len(self.electronsFakeSel))
varsToKeep["n_tightsel_ele"] = op.static_cast(
"UInt_t", op.rng_len(self.electronsTightSel))
varsToKeep["n_ak4Jet"] = op.static_cast("UInt_t",
op.rng_len(self.ak4Jets))
varsToKeep["n_ak8Jet"] = op.static_cast("UInt_t",
op.rng_len(self.ak8Jets))
varsToKeep["n_presel_ak8BJet"] = op.static_cast(
"UInt_t", op.rng_len(self.ak8BJets))
varsToKeep["n_loose_ak4BJet"] = op.static_cast(
"UInt_t", op.rng_len(self.ak4BJetsLoose))
varsToKeep["n_medium_ak4BJet"] = op.static_cast(
"UInt_t", op.rng_len(self.ak4BJets))
varsToKeep["n_ak4JetsCleanAk8b"] = op.static_cast(
"UInt_t", op.rng_len(self.ak4JetsCleanedFromAk8b))
varsToKeep["n_presel_ak4JetVBF"] = op.static_cast(
"UInt_t", op.rng_len(self.VBFJetsPreSel))
#varsToKeep["is_SR"] = op.static_cast("UInt_t",op.OR(op.rng_len(self.electronsTightSel)==1,
# op.rng_len(self.muonsTightSel)==1))
varsToKeep["is_e_SR_prompt"] = op.switch(
op.rng_len(self.electronsTightSel) == 1, op.c_bool(True),
op.c_bool(False))
varsToKeep["is_m_SR_prompt"] = op.switch(
op.rng_len(self.muonsTightSel) == 1, op.c_bool(True),
op.c_bool(False))
varsToKeep["is_e_FR_prompt"] = op.switch(
op.AND(
op.rng_len(self.electronsFakeSel) > 0,
op.AND(
self.lambda_is_matched(self.electronsFakeSel[0]),
op.NOT(
self.lambda_electronTightSel(
self.electronsFakeSel[0])))), op.c_bool(True),
op.c_bool(False))
varsToKeep["is_m_FR_prompt"] = op.switch(
op.AND(
op.rng_len(self.muonsFakeSel) > 0,
op.AND(
self.lambda_is_matched(self.muonsFakeSel[0]),
op.NOT(self.lambda_muonTightSel(
self.muonsFakeSel[0])))), op.c_bool(True),
op.c_bool(False))
varsToKeep["is_resolved"] = op.switch(
op.AND(
op.rng_len(self.ak4Jets) >= 3,
op.rng_len(self.ak4BJets) >= 1,
op.rng_len(self.ak8BJets) == 0), op.c_bool(True),
op.c_bool(False))
varsToKeep["is_boosted"] = op.switch(
op.AND(
op.rng_len(self.ak8BJets) >= 1,
op.rng_len(self.ak4JetsCleanedFromAk8b) >= 1),
op.c_bool(True), op.c_bool(False))
varsToKeep["is_resolved_1b"] = op.switch(
op.AND(
op.rng_len(self.ak4Jets) >= 3,
op.rng_len(self.ak4BJets) == 1,
op.rng_len(self.ak8BJets) == 0), op.c_bool(True),
op.c_bool(False))
varsToKeep["is_resolved_2b"] = op.switch(
op.AND(
op.rng_len(self.ak4Jets) >= 3,
op.rng_len(self.ak4BJets) >= 2,
op.rng_len(self.ak8BJets) == 0), op.c_bool(True),
op.c_bool(False))
varsToKeep["n_tau"] = op.static_cast("UInt_t",
op.rng_len(self.tauCleanSel))
#varsToKeep['resolved_tag'] = op.static_cast("UInt_t",op.AND(op.rng_len(self.ak4Jets) >= 3,
# op.rng_len(self.ak4BJets) >= 1,
# op.rng_len(self.ak8BJets) == 0))
#varsToKeep['boosted_tag'] = op.static_cast("UInt_t",op.AND(op.rng_len(self.ak8BJets) >= 1,op.rng_len(self.ak4JetsCleanedFromAk8b) >= 1))
# Triggers #
'''
varsToKeep["triggers"] = self.triggers
varsToKeep["triggers_SingleElectron"] = op.OR(*self.triggersPerPrimaryDataset['SingleElectron'])
varsToKeep["triggers_SingleMuon"] = op.OR(*self.triggersPerPrimaryDataset['SingleMuon'])
varsToKeep["triggers_DoubleElectron"] = op.OR(*self.triggersPerPrimaryDataset['DoubleEGamma'])
varsToKeep["triggers_DoubleMuon"] = op.OR(*self.triggersPerPrimaryDataset['DoubleMuon'])
varsToKeep["triggers_MuonElectron"] = op.OR(*self.triggersPerPrimaryDataset['MuonEG'])
'''
# Muons #
for i in range(1, 3): # 2 leading muons
varsToKeep["mu{}_pt".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].pt, op.c_float(-9999., "float"))
varsToKeep["mu{}_eta".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].eta, op.c_float(-9999.))
varsToKeep["mu{}_phi".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].phi, op.c_float(-9999.))
varsToKeep["mu{}_E".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].p4.E(),
op.c_float(-9999., "float"))
varsToKeep["mu{}_charge".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].charge, op.c_int(-9999.))
varsToKeep["mu{}_conept".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muon_conept[self.muonsPreSel[i - 1].idx],
op.c_float(-9999.))
varsToKeep["mu{}_miniRelIso".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].miniPFRelIso_all,
op.c_float(-9999.))
varsToKeep["mu{}_PFRelIso04".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].pfRelIso04_all, op.c_float(-9999.))
varsToKeep["mu{}_jetNDauChargedMVASel".format(i)] = op.c_float(
-9999.)
varsToKeep["mu{}_jetPtRel".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].jetPtRelv2, op.c_float(-9999.))
varsToKeep["mu{}_jetRelIso".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].jetRelIso, op.c_float(-9999.))
varsToKeep["mu{}_jetDeepJet".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].jet.btagDeepFlavB,
op.c_float(-9999.))
varsToKeep["mu{}_sip3D".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].sip3d, op.c_float(-9999.))
varsToKeep["mu{}_dxy".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].dxy, op.c_float(-9999.))
varsToKeep["mu{}_dxyAbs".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
op.abs(self.muonsPreSel[i - 1].dxy), op.c_float(-9999.))
varsToKeep["mu{}_dz".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].dz, op.c_float(-9999.))
varsToKeep["mu{}_segmentCompatibility".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].segmentComp, op.c_float(-9999.))
varsToKeep["mu{}_leptonMVA".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].mvaTTH, op.c_float(-9999.))
varsToKeep["mu{}_mediumID".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].mediumId,
op.c_float(-9999., "Bool_t"))
varsToKeep["mu{}_dpt_div_pt".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
self.muonsPreSel[i - 1].tunepRelPt,
op.c_float(-9999.)) # Not sure
varsToKeep["mu{}_isfakeablesel".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
op.switch(self.lambda_muonFakeSel(self.muonsPreSel[i - 1]),
op.c_int(1), op.c_int(0)), op.c_int(-9999))
varsToKeep["mu{}_ismvasel".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
op.switch(
op.AND(
self.lambda_muonTightSel(self.muonsPreSel[i - 1]),
self.lambda_muonFakeSel(self.muonsPreSel[i - 1])),
op.c_int(1), op.c_int(0)),
op.c_int(-9999)) # mvasel encompasses fakeablesel
varsToKeep["mu{}_isGenMatched".format(i)] = op.switch(
op.rng_len(self.muonsPreSel) >= i,
op.switch(self.lambda_is_matched(self.muonsPreSel[i - 1]),
op.c_int(1), op.c_int(0)), op.c_int(-9999))
'''
varsToKeep["mu{}_genPartFlav".format(i)] = op.switch(op.rng_len(self.muonsPreSel) >= i, self.muonsPreSel[i-1].genPartFlav, op.c_int(-9999))
varsToKeep["mu{}_FR".format(i)] = op.switch(op.rng_len(self.muonsPreSel) >= i, self.lambda_FR_mu(self.muonsPreSel[i-1]), op.c_int(-9999))
varsToKeep["mu{}_FRcorr".format(i)] = op.switch(op.rng_len(self.muonsPreSel) >= i, self.lambda_FRcorr_mu(self.muonsPreSel[i-1]), op.c_int(-9999))
varsToKeep["mu{}_FF".format(i)] = op.switch(op.rng_len(self.muonsPreSel) >= i, self.lambda_FF_mu(self.muonsPreSel[i-1]), op.c_int(-9999))
varsToKeep["mu{}_looseSF".format(i)] = op.switch(op.rng_len(self.muonsPreSel) >= i, reduce(mul,self.lambda_MuonLooseSF(self.muonsPreSel[i-1])), op.c_int(-9999))
varsToKeep["mu{}_tightSF".format(i)] = op.switch(op.rng_len(self.muonsPreSel) >= i, reduce(mul,self.lambda_MuonTightSF(self.muonsPreSel[i-1])), op.c_int(-9999))
'''
# Electrons #
for i in range(1, 3): # 2 leading electrons
varsToKeep["ele{}_pt".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].pt, op.c_float(-9999.))
varsToKeep["ele{}_eta".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].eta, op.c_float(-9999.))
varsToKeep["ele{}_phi".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].phi, op.c_float(-9999.))
varsToKeep["ele{}_E".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].p4.E(), op.c_float(-9999., ))
varsToKeep["ele{}_charge".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].charge, op.c_int(-9999.))
varsToKeep["ele{}_conept".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electron_conept[self.electronsPreSel[i - 1].idx],
op.c_float(-9999.))
varsToKeep["ele{}_miniRelIso".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].miniPFRelIso_all,
op.c_float(-9999.))
varsToKeep["ele{}_PFRelIso03".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].pfRelIso03_all,
op.c_float(-9999.)) # Iso03, Iso04 not in NanoAOD
varsToKeep["ele{}_jetNDauChargedMVASel".format(
i)] = op.c_float(-9999.)
varsToKeep["ele{}_jetPtRel".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].jetPtRelv2, op.c_float(-9999.))
varsToKeep["ele{}_jetRelIso".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].jetRelIso, op.c_float(-9999.))
varsToKeep["ele{}_jetDeepJet".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].jet.btagDeepFlavB,
op.c_float(-9999.))
varsToKeep["ele{}_sip3D".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].sip3d, op.c_float(-9999.))
varsToKeep["ele{}_dxy".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].dxy, op.c_float(-9999.))
varsToKeep["ele{}_dxyAbs".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
op.abs(self.electronsPreSel[i - 1].dxy),
op.c_float(-9999.))
varsToKeep["ele{}_dz".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].dz, op.c_float(-9999.))
varsToKeep["ele{}_ntMVAeleID".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].mvaFall17V2noIso,
op.c_float(-9999.))
varsToKeep["ele{}_leptonMVA".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].mvaTTH, op.c_float(-9999.))
varsToKeep["ele{}_passesConversionVeto".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].convVeto,
op.c_float(-9999., "Bool_t"))
varsToKeep["ele{}_nMissingHits".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].lostHits,
op.c_float(-9999., "UChar_t"))
varsToKeep["ele{}_sigmaEtaEta".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].sieie, op.c_float(-9999.))
varsToKeep["ele{}_HoE".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].hoe, op.c_float(-9999.))
varsToKeep["ele{}_OoEminusOoP".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
self.electronsPreSel[i - 1].eInvMinusPInv,
op.c_float(-9999.))
varsToKeep["ele{}_isfakeablesel".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
op.switch(
self.lambda_electronFakeSel(self.electronsPreSel[i -
1]),
op.c_int(1), op.c_int(0)), op.c_int(-9999))
varsToKeep["ele{}_ismvasel".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
op.switch(
op.AND(
self.lambda_electronTightSel(
self.electronsPreSel[i - 1]),
self.lambda_electronFakeSel(
self.electronsPreSel[i - 1])), op.c_int(1),
op.c_int(0)),
op.c_int(-9999)) # mvasel encompasses fakeablesel
varsToKeep["ele{}_isGenMatched".format(i)] = op.switch(
op.rng_len(self.electronsPreSel) >= i,
op.switch(
self.lambda_is_matched(self.electronsPreSel[i - 1]),
op.c_int(1), op.c_int(0)), op.c_int(-9999))
'''
varsToKeep["ele{}_genPartFlav".format(i)] = op.switch(op.rng_len(self.electronsPreSel) >= i, self.electronsPreSel[i-1].genPartFlav, op.c_int(-9999))
varsToKeep["ele{}_deltaEtaSC".format(i)] = op.switch(op.rng_len(self.electronsPreSel) >= i, self.electronsPreSel[i-1].deltaEtaSC, op.c_int(-9999))
varsToKeep["ele{}_FR".format(i)] = op.switch(op.rng_len(self.electronsPreSel) >= i, self.lambda_FR_el(self.electronsPreSel[i-1]), op.c_int(-9999))
varsToKeep["ele{}_FRcorr".format(i)] = op.switch(op.rng_len(self.electronsPreSel) >= i, self.lambda_FRcorr_el(self.electronsPreSel[i-1]), op.c_int(-9999))
varsToKeep["ele{}_FF".format(i)] = op.switch(op.rng_len(self.electronsPreSel) >= i, self.lambda_FF_el(self.electronsPreSel[i-1]), op.c_int(-9999))
varsToKeep["ele{}_looseSF".format(i)] = op.switch(op.rng_len(self.electronsPreSel) >= i, reduce(mul,self.lambda_ElectronLooseSF(self.electronsPreSel[i-1])), op.c_int(-9999))
varsToKeep["ele{}_tightSF".format(i)] = op.switch(op.rng_len(self.electronsPreSel) >= i, reduce(mul,self.lambda_ElectronTightSF(self.electronsPreSel[i-1])), op.c_int(-9999))
'''
# AK4 Jets #
for i in range(1, 5): # 4 leading jets
varsToKeep["ak4Jet{}_pt".format(i)] = op.switch(
op.rng_len(self.ak4Jets) >= i, self.ak4Jets[i - 1].pt,
op.c_float(-9999.))
varsToKeep["ak4Jet{}_eta".format(i)] = op.switch(
op.rng_len(self.ak4Jets) >= i, self.ak4Jets[i - 1].eta,
op.c_float(-9999.))
varsToKeep["ak4Jet{}_phi".format(i)] = op.switch(
op.rng_len(self.ak4Jets) >= i, self.ak4Jets[i - 1].phi,
op.c_float(-9999.))
varsToKeep["ak4Jet{}_E".format(i)] = op.switch(
op.rng_len(self.ak4Jets) >= i, self.ak4Jets[i - 1].p4.E(),
op.c_float(-9999.))
varsToKeep["ak4Jet{}_CSV".format(i)] = op.switch(
op.rng_len(self.ak4Jets) >= i,
self.ak4Jets[i - 1].btagDeepFlavB, op.c_float(-9999.))
#varsToKeep["ak4Jet{}_hadronFlavour".format(i)] = op.switch(op.rng_len(self.ak4Jets) >= i, self.ak4Jets[i-1].hadronFlavour, op.c_float(-9999.))
#varsToKeep["ak4Jet{}_btagSF".format(i)] = op.switch(op.rng_len(self.ak4Jets) >= i, self.DeepJetDiscReshapingSF(self.ak4Jets[i-1]), op.c_float(-9999.))
#varsToKeep["ak4Jet{}_puid_eff".format(i)] = op.switch(op.rng_len(self.ak4Jets) >= i, self.jetpuid_mc_eff(self.ak4Jets[i-1]), op.c_float(-9999.))
#varsToKeep["ak4Jet{}_puid_sfeff".format(i)] = op.switch(op.rng_len(self.ak4Jets) >= i, self.jetpuid_sf_eff(self.ak4Jets[i-1]), op.c_float(-9999.))
#varsToKeep["ak4Jet{}_puid_mis".format(i)] = op.switch(op.rng_len(self.ak4Jets) >= i, self.jetpuid_mc_mis(self.ak4Jets[i-1]), op.c_float(-9999.))
#varsToKeep["ak4Jet{}_puid_sfmis".format(i)] = op.switch(op.rng_len(self.ak4Jets) >= i, self.jetpuid_sf_mis(self.ak4Jets[i-1]), op.c_float(-9999.))
# VBF Jets #
if not self.inclusive_sel:
varsToKeep["ak4JetVBFPair1_pt"] = op.switch(
op.rng_len(VBFJetPairs) >= 1, VBFJetPairs[0][0].pt,
op.c_float(-9999.))
varsToKeep["ak4JetVBFPair1_eta"] = op.switch(
op.rng_len(VBFJetPairs) >= 1, VBFJetPairs[0][0].eta,
op.c_float(-9999.))
varsToKeep["ak4JetVBFPair1_phi"] = op.switch(
op.rng_len(VBFJetPairs) >= 1, VBFJetPairs[0][0].phi,
op.c_float(-9999.))
varsToKeep["ak4JetVBFPair1_E"] = op.switch(
op.rng_len(VBFJetPairs) >= 1, VBFJetPairs[0][0].p4.E(),
op.c_float(-9999.))
varsToKeep["ak4JetVBFPair2_pt"] = op.switch(
op.rng_len(VBFJetPairs) >= 1, VBFJetPairs[0][1].pt,
op.c_float(-9999.))
varsToKeep["ak4JetVBFPair2_eta"] = op.switch(
op.rng_len(VBFJetPairs) >= 1, VBFJetPairs[0][1].eta,
op.c_float(-9999.))
varsToKeep["ak4JetVBFPair2_phi"] = op.switch(
op.rng_len(VBFJetPairs) >= 1, VBFJetPairs[0][1].phi,
op.c_float(-9999.))
varsToKeep["ak4JetVBFPair2_E"] = op.switch(
op.rng_len(VBFJetPairs) >= 1, VBFJetPairs[0][1].p4.E(),
op.c_float(-9999.))
'''
# inputs :
inputsLeps = mvaEvaluatorSL_nonres_DNN01.returnLeptonsMVAInputs (self = self, lep = lepton)
inputsJets = mvaEvaluatorSL_nonres_DNN01.returnJetsMVAInputs (self = self, bjets = self.bJetsByScore, jets = self.probableWJets)
inputsMET = mvaEvaluatorSL_nonres_DNN01.returnMETMVAInputs (self = self, met = self.corrMET)
inputsFatjet = mvaEvaluatorSL_nonres_DNN01.returnFatjetMVAInputs(self = self, fatjets = self.ak8Jets)
inputsHL = mvaEvaluatorSL_nonres_DNN01.returnHighLevelMVAInputs (self = self,
lep = lepton,
bjets = self.bJetsByScore,
wjets = self.wJetsByPt,
VBFJetPairs = VBFJetPairs,
channel = self.args.Channel)
inputsParam = mvaEvaluatorSL_nonres_DNN01.returnParamMVAInputs (self)
inputsEventNr = mvaEvaluatorSL_nonres_DNN01.returnEventNrMVAInputs (self,t)
inputDict = {**inputsLeps, **inputsJets, **inputsMET, **inputsFatjet, **inputsHL}
for (varname,_,_),var in inputDict.items():
varsToKeep[varname] = var
from mvaEvaluatorSL_nonres_DNN01 import inputStaticCast
inputs = [op.array("double",*inputStaticCast(inputsLeps,"float")),
op.array("double",*inputStaticCast(inputsJets,"float")),
op.array("double",*inputStaticCast(inputsFatjet,"float")),
op.array("double",*inputStaticCast(inputsMET,"float")),
op.array("double",*inputStaticCast(inputsHL,"float")),
op.array("double",*inputStaticCast(inputsParam,"float")),
op.array("long",*inputStaticCast(inputsEventNr,"long"))]
output_01 = DNN_01(*inputs)
for node, output in zip(self.nodes,output_01):
varsToKeep['DNN_node_'+node] = output
'''
# AK8 Jets #
for i in range(1, 3): # 2 leading fatjets
varsToKeep["ak8Jet{}_pt".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i, self.ak8BJets[i - 1].pt,
op.c_float(-9999.))
varsToKeep["ak8Jet{}_eta".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i, self.ak8BJets[i - 1].eta,
op.c_float(-9999.))
varsToKeep["ak8Jet{}_phi".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i, self.ak8BJets[i - 1].phi,
op.c_float(-9999.))
varsToKeep["ak8Jet{}_E".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i,
self.ak8BJets[i - 1].p4.E(), op.c_float(-9999.))
varsToKeep["ak8Jet{}_msoftdrop".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i,
self.ak8BJets[i - 1].msoftdrop, op.c_float(-9999.))
varsToKeep["ak8Jet{}_tau1".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i, self.ak8BJets[i - 1].tau1,
op.c_float(-9999.))
varsToKeep["ak8Jet{}_tau2".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i, self.ak8BJets[i - 1].tau2,
op.c_float(-9999.))
varsToKeep["ak8Jet{}_subjet0_pt".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i,
self.ak8BJets[i - 1].subJet1.pt, op.c_float(-9999.))
varsToKeep["ak8Jet{}_subjet0_eta".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i,
self.ak8BJets[i - 1].subJet1.eta, op.c_float(-9999.))
varsToKeep["ak8Jet{}_subjet0_phi".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i,
self.ak8BJets[i - 1].subJet1.phi, op.c_float(-9999.))
varsToKeep["ak8Jet{}_subjet0_CSV".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i,
self.ak8BJets[i - 1].subJet1.btagDeepB, op.c_float(-9999.))
varsToKeep["ak8Jet{}_subjet1_pt".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i,
self.ak8BJets[i - 1].subJet2.pt, op.c_float(-9999.))
varsToKeep["ak8Jet{}_subjet1_eta".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i,
self.ak8BJets[i - 1].subJet2.eta, op.c_float(-9999.))
varsToKeep["ak8Jet{}_subjet1_phi".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i,
self.ak8BJets[i - 1].subJet2.phi, op.c_float(-9999.))
varsToKeep["ak8Jet{}_subjet1_CSV".format(i)] = op.switch(
op.rng_len(self.ak8BJets) >= i,
self.ak8BJets[i - 1].subJet2.btagDeepB, op.c_float(-9999.))
varsToKeep["PFMET"] = self.corrMET.pt
varsToKeep["PFMETphi"] = self.corrMET.phi
varsToKeep["met1_E"] = self.corrMET.p4.E()
varsToKeep["met1_pt"] = self.corrMET.pt
varsToKeep["met1_eta"] = self.corrMET.eta
varsToKeep["met1_phi"] = self.corrMET.phi
# SF #
electronMuon_cont = op.combine(
(self.electronsFakeSel, self.muonsFakeSel))
'''
varsToKeep["trigger_SF"] = op.multiSwitch(
(op.AND(op.rng_len(self.electronsTightSel)==1,op.rng_len(self.muonsTightSel)==0) , self.ttH_singleElectron_trigSF(self.electronsTightSel[0])),
(op.AND(op.rng_len(self.electronsTightSel)==0,op.rng_len(self.muonsTightSel)==1) , self.ttH_singleMuon_trigSF(self.muonsTightSel[0])),
(op.AND(op.rng_len(self.electronsTightSel)>=2,op.rng_len(self.muonsTightSel)==0) , self.lambda_ttH_doubleElectron_trigSF(self.electronsTightSel)),
(op.AND(op.rng_len(self.electronsTightSel)==0,op.rng_len(self.muonsTightSel)>=2) , self.lambda_ttH_doubleMuon_trigSF(self.muonsTightSel)),
(op.AND(op.rng_len(self.electronsTightSel)>=1,op.rng_len(self.muonsTightSel)>=1) , self.lambda_ttH_electronMuon_trigSF(electronMuon_cont[0])),
op.c_float(1.))
if not self.inclusive_sel:
#varsToKeep["weight_trigger_el_sf"] = op.switch(op.rng_len(self.electronsTightSel)>0, self.ttH_singleElectron_trigSF(lepton),op.c_float(1.))
#varsToKeep["weight_trigger_mu_sf"] = op.switch(op.rng_len(self.muonsTightSel)>0, self.ttH_singleMuon_trigSF(lepton),op.c_float(1.))
varsToKeep["lepton_IDSF"] = op.rng_product(self.electronsFakeSel, lambda el : reduce(mul,self.lambda_ElectronLooseSF(el)+self.lambda_ElectronTightSF(el))) * \
op.rng_product(self.muonsFakeSel, lambda mu : reduce(mul,self.lambda_MuonLooseSF(mu)+self.lambda_MuonTightSF(mu)))
varsToKeep["lepton_IDSF_recoToLoose"] = op.rng_product(self.electronsFakeSel, lambda el : reduce(mul,self.lambda_ElectronLooseSF(el))) * \
op.rng_product(self.muonsFakeSel, lambda mu : reduce(mul,self.lambda_MuonLooseSF(mu)))
varsToKeep["lepton_IDSF_looseToTight"] = op.rng_product(self.electronsFakeSel, lambda el : reduce(mul,self.lambda_ElectronTightSF(el))) * \
op.rng_product(self.muonsFakeSel, lambda mu : reduce(mul,self.lambda_MuonTightSF(mu)))
if era == "2016" or era == "2017":
if self.args.Channel == "El":
varsToKeep["weight_electron_reco_low"] = op.switch(op.AND(self.lambda_is_matched(lepton),lepton.pt<=20.), self.elLooseRecoPtLt20(lepton), op.c_float(1.))
varsToKeep["weight_electron_reco_high"] = op.switch(op.AND(self.lambda_is_matched(lepton),lepton.pt>20.), self.elLooseRecoPtGt20(lepton), op.c_float(1.))
varsToKeep["weight_muon_idiso_loose"] = op.c_float(1.)
varsToKeep["weight_electron_id_loose_01"] = op.switch(self.lambda_is_matched(lepton), self.elLooseEff(lepton), op.c_float(1.))
varsToKeep["weight_electron_id_loose_02"] = op.switch(self.lambda_is_matched(lepton), self.elLooseId(lepton), op.c_float(1.))
varsToKeep["weight_electron_tth_loose"] = self.lambda_ElectronTightSF(lepton)[0]
varsToKeep["weight_muon_tth_loose"] = op.c_float(1.)
if self.args.Channel == "Mu":
varsToKeep["weight_muon_idiso_loose"] = op.switch(self.lambda_is_matched(lepton), self.muLooseId(lepton), op.c_float(1.))
varsToKeep["weight_electron_reco_low"] = op.c_float(1.)
varsToKeep["weight_electron_reco_high"] = op.c_float(1.)
varsToKeep["weight_electron_id_loose_01"] = op.c_float(1.)
varsToKeep["weight_electron_id_loose_02"] = op.c_float(1.)
varsToKeep["weight_electron_tth_loose"] = op.c_float(1.)
varsToKeep["weight_muon_tth_loose"] = self.lambda_MuonTightSF(lepton)[0]
else:
raise NotImplementedError
# L1 Prefire #
if era in ["2016","2017"]:
varsToKeep["L1prefire"] = self.L1Prefiring
varsToKeep["weight_l1_ecal_prefiring"] = self.L1Prefiring
else:
varsToKeep["L1prefire"] = op.c_float(-9999.)
varsToKeep["weight_l1_ecal_prefiring"] = op.c_float(-9999.)
# Fake rate #
if self.args.Channel == "El":
varsToKeep["fakeRate"] = op.switch(self.lambda_electronTightSel(self.electronsFakeSel[0]), self.ElFakeFactor(self.electronsFakeSel[0]), op.c_float(1.))
varsToKeep["weight_fake_electrons"] = op.switch(self.lambda_electronTightSel(self.electronsFakeSel[0]), op.abs(self.ElFakeFactor(self.electronsFakeSel[0])), op.c_float(1.))
varsToKeep["weight_fake_muons"] = op.c_float(1.)
varsToKeep["weight_fake_two_non_tight"] = op.c_float(999.0)
if self.args.Channel == "Mu":
varsToKeep["fakeRate"] = op.switch(self.lambda_muonTightSel(self.muonsFakeSel[0]), self.MuFakeFactor(self.muonsFakeSel[0]), op.c_float(1.))
varsToKeep["weight_fake_electrons"] = op.c_float(1.)
varsToKeep["weight_fake_muons"] = op.switch(self.lambda_muonTightSel(self.muonsFakeSel[0]), op.abs(self.MuFakeFactor(self.muonsFakeSel[0])), op.c_float(1.))
varsToKeep["weight_fake_two_non_tight"] = op.c_float(999.0)
if self.is_MC:
varsToKeep["weight_fake_is_mc"] = op.c_float(-1.)
else:
varsToKeep["weight_fake_is_mc"] = op.c_float(1.)
# PU ID SF #
#varsToKeep["PU_jetID_SF"] = self.puid_reweighting
#varsToKeep["weight_jet_PUid_efficiency"] = self.puid_reweighting_efficiency
#varsToKeep["weight_jet_PUid_mistag"] = self.puid_reweighting_mistag
# Btagging SF #
varsToKeep["btag_SF"] = self.btagAk4SF
varsToKeep["weight_btagWeight"] = self.btagAk4SF
if "BtagRatioWeight" in self.__dict__.keys():
varsToKeep["btag_ratio_SF"] = self.BtagRatioWeight
varsToKeep["weight_btagNorm"] = self.BtagRatioWeight
# PS weights #
varsToKeep["weight_PSWeight_ISR"] = self.psISRSyst
varsToKeep["weight_PSWeight_FSR"] = self.psFSRSyst
'''
# ttbar PT reweighting #
if "group" in sampleCfg and sampleCfg["group"] == 'ttbar':
varsToKeep["topPt_wgt"] = self.ttbar_weight(
self.genTop[0], self.genAntitop[0])
# Event Weight #
if self.is_MC:
varsToKeep["MC_weight"] = t.genWeight
puWeightsFile = os.path.join(os.path.dirname(__file__), "data",
"pileup",
sample + '_%s.json' % era)
#puWeightsFile = os.path.join(os.path.dirname(__file__), "data" , "pileup", sampleCfg["pufile"])
varsToKeep["PU_weight"] = makePileupWeight(
puWeightsFile,
t.Pileup_nTrueInt,
nameHint=f"puweightFromFile{sample}".replace('-', '_'))
varsToKeep[
"eventWeight"] = noSel.weight if self.inclusive_sel else selObj.sel.weight
if self.inclusive_sel:
return noSel, varsToKeep
else:
return selObj.sel, varsToKeep
#---------------------------------------------------------------------------------------#
# Selection tree #
#---------------------------------------------------------------------------------------#
#----- EVT variables -----#
varsToKeep["event"] = None # Already in tree
varsToKeep["run"] = None # Already in tree
varsToKeep["ls"] = t.luminosityBlock
'''
inputsLeps = mva02.returnLeptonsMVAInputs (self = self, lep = lepton)
inputsJets = mva02.returnJetsMVAInputs (self = self, bjets = self.bJetsByScore, jets = self.probableWJets)
inputsMET = mva02.returnMETMVAInputs (self = self, met = self.corrMET)
inputsFatjet = mva02.returnFatjetMVAInputs (self = self, fatbjets = self.ak8BJets)
inputNeu = mva02.returnNuMVAInputs (self = self)
inputsHL = mva02.returnHighLevelMVAInputs (self = self,
lep = lepton,
bjets = self.bJetsByScore,
wjets = self.wJetsByPt,
VBFJetPairs = VBFJetPairs,
channel = self.args.Channel)
inputsParam = mva02.returnParamMVAInputs (self)
inputsEventNr = mva02.returnEventNrMVAInputs (self,t)
'''
inputsLeps = mva02.returnLeptonsMVAInputs(self=self,
lep=lepton,
conep4=lepconep4)
inputsJets = mva02.returnJetsMVAInputs(self=self,
bjets=self.bJetsByScore,
jets=self.probableWJets)
inputsMET = mva02.returnMETMVAInputs(self=self, met=self.corrMET)
inputsFatjet = mva02.returnFatjetMVAInputs(self=self,
fatbjets=self.ak8BJets)
inputNeu = mva02.returnNuMVAInputs(self=self)
inputsHL = mva02.returnHighLevelMVAInputs(self=self,
lep=lepton,
conep4=lepconep4,
bjets=self.bJetsByScore,
wjets=self.wJetsByPt,
VBFJetPairs=VBFJetPairs,
channel=self.args.Channel)
inputsParam = mva02.returnParamMVAInputs(self)
inputsEventNr = mva02.returnEventNrMVAInputs(self, t)
inputDict = {
**inputsLeps,
**inputsJets,
**inputsFatjet,
**inputsMET,
**inputNeu,
**inputsHL,
**inputsParam,
**inputsEventNr
}
for (varname, _, _), var in inputDict.items():
varsToKeep[varname] = var
#from mvaEvaluatorSL_nonres_DNN01 import inputStaticCast
inputs = [
op.array("double", *mva02.inputStaticCast(inputsLeps, "float")),
op.array("double", *mva02.inputStaticCast(inputsJets, "float")),
op.array("double", *mva02.inputStaticCast(inputsFatjet, "float")),
op.array("double", *mva02.inputStaticCast(inputsMET, "float")),
op.array("double", *mva02.inputStaticCast(inputNeu, "float")),
op.array("double", *mva02.inputStaticCast(inputsHL, "float")),
op.array("double", *mva02.inputStaticCast(inputsParam, "float")),
op.array("long", *mva02.inputStaticCast(inputsEventNr, "long"))
]
output_02 = DNN_02(*inputs)
for node, output in zip(self.nodes, output_02):
varsToKeep['DNN_node_' + node] = output
#----- Additional variables -----#
varsToKeep["MC_weight"] = t.genWeight
varsToKeep['total_weight'] = selObj.sel.weight
#return leptonSel.sel, varsToKeep
return selObj.sel, varsToKeep
