diff --git a/PhysicsTools/NanoAOD/python/nanoDQM_cfi.py b/PhysicsTools/NanoAOD/python/nanoDQM_cfi.py index 0037e673116c8..76c3691d86546 100644 --- a/PhysicsTools/NanoAOD/python/nanoDQM_cfi.py +++ b/PhysicsTools/NanoAOD/python/nanoDQM_cfi.py @@ -820,7 +820,8 @@ Plot1D('charge', 'charge', 3, -1.5, 1.5, 'electric charge'), Plot1D('chargedIso', 'chargedIso', 20, 0, 200, 'charged isolation'), Plot1D('decayMode', 'decayMode', 12, -0.5, 11.5, 'decayMode()'), - Plot1D('decayModePNet', 'decayModePNet', 13, -1.5, 11.5, 'decay mode of the highest PNet tau score'), + Plot1D('decayModePNet', 'decayModePNet', 13, -1.5, 11.5, 'decay mode of the highest PNet tau score (CHS jets)'), + Plot1D('decayModeUParT', 'decayModeUParT', 13, -1.5, 11.5, 'decay mode of the highest UParT tau score (PUPPI jets)'), Plot1D('dxy', 'dxy', 20, -1000, 1000, 'd_{xy} of lead track with respect to PV, in cm (with sign)'), Plot1D('dz', 'dz', 20, -20, 20, 'd_{z} of lead track with respect to PV, in cm (with sign)'), Plot1D('eta', 'eta', 20, -3, 3, 'eta'), @@ -852,18 +853,28 @@ Plot1D('rawDeepTau2018v2p5VSe', 'rawDeepTau2018v2p5VSe', 20, 0, 1, 'byDeepTau2018v2p5VSe raw output discriminator (deepTau2018v2p5)'), Plot1D('rawDeepTau2018v2p5VSjet', 'rawDeepTau2018v2p5VSjet', 20, 0, 1, 'byDeepTau2018v2p5VSjet raw output discriminator (deepTau2018v2p5)'), Plot1D('rawDeepTau2018v2p5VSmu', 'rawDeepTau2018v2p5VSmu', 20, 0, 1, 'byDeepTau2018v2p5VSmu raw output discriminator (deepTau2018v2p5)'), - Plot1D('rawPNetVSe', 'rawPNetVSe', 20, 0, 1, 'byPNetVSe raw output discriminator (PNet 2023)'), - Plot1D('rawPNetVSjet', 'rawPNetVSjet', 20, 0, 1, 'byPNetVSjet raw output discriminator (PNet 2023)'), - Plot1D('rawPNetVSmu', 'rawPNetVSmu', 20, 0, 1, 'byPNetVSmu raw output discriminator (PNet 2023)'), + Plot1D('rawPNetVSe', 'rawPNetVSe', 20, 0, 1, 'byPNetVSe raw output discriminator (PNet 2023 - CHS Jets)'), + Plot1D('rawPNetVSjet', 'rawPNetVSjet', 20, 0, 1, 'byPNetVSjet raw output discriminator (PNet 2023 - CHS Jets)'), + Plot1D('rawPNetVSmu', 'rawPNetVSmu', 20, 0, 1, 'byPNetVSmu raw output discriminator (PNet 2023 - CHS Jets)'), + Plot1D('rawUParTVSe', 'rawUParTVSe', 20, 0, 1, 'byUParTVSe raw output discriminator (UParT 2024 - PUPPI Jets)'), + Plot1D('rawUParTVSjet', 'rawUParTVSjet', 20, 0, 1, 'byUParTVSjet raw output discriminator (UParT 2024 - PUPPI Jets)'), + Plot1D('rawUParTVSmu', 'rawUParTVSmu', 20, 0, 1, 'byUParTVSmu raw output discriminator (UParT 2024 - PUPPI Jets)'), Plot1D('rawIso', 'rawIso', 20, 0, 200, 'combined isolation (deltaBeta corrections)'), Plot1D('rawIsodR03', 'rawIsodR03', 20, 0, 200, 'combined isolation (deltaBeta corrections, dR=0.3)'), - Plot1D('ptCorrPNet', 'ptCorrPNet', 20, 0, 2, 'pt correction (PNet 2023)'), - Plot1D('qConfPNet', 'qConfPNet', 20, -0.5, 0.5, 'signed charge confidence (PNet 2023)'), - Plot1D('probDM0PNet', 'probDM0PNet', 20, 0, 1, 'normalised probablity of decayMode 0, 1h+0pi0 (PNet 2023)'), - Plot1D('probDM1PNet', 'probDM1PNet', 20, 0, 1, 'normalised probablity of decayMode 1, 1h+1pi0 (PNet 2023)'), - Plot1D('probDM2PNet', 'probDM2PNet', 20, 0, 1, 'normalised probablity of decayMode 2, 1h+2pi0 (PNet 2023)'), - Plot1D('probDM10PNet', 'probDM10PNet', 20, 0, 1, 'normalised probablity of decayMode 10, 3h+0pi0 (PNet 2023)'), - Plot1D('probDM11PNet', 'probDM11PNet', 20, 0, 1, 'normalised probablity of decayMode 11, 3h+1pi0 (PNet 2023)'), + Plot1D('ptCorrPNet', 'ptCorrPNet', 20, 0, 2, 'pt correction (PNet 2023 - CHS Jets)'), + Plot1D('qConfPNet', 'qConfPNet', 20, -0.5, 0.5, 'signed charge confidence (PNet 2023 - CHS Jets)'), + Plot1D('probDM0PNet', 'probDM0PNet', 20, 0, 1, 'normalised probablity of decayMode 0, 1h+0pi0 (PNet 2023 - CHS Jets)'), + Plot1D('probDM1PNet', 'probDM1PNet', 20, 0, 1, 'normalised probablity of decayMode 1, 1h+1pi0 (PNet 2023 - CHS Jets)'), + Plot1D('probDM2PNet', 'probDM2PNet', 20, 0, 1, 'normalised probablity of decayMode 2, 1h+2pi0 (PNet 2023 - CHS Jets)'), + Plot1D('probDM10PNet', 'probDM10PNet', 20, 0, 1, 'normalised probablity of decayMode 10, 3h+0pi0 (PNet 2023 - CHS Jets)'), + Plot1D('probDM11PNet', 'probDM11PNet', 20, 0, 1, 'normalised probablity of decayMode 11, 3h+1pi0 (PNet 2023 - CHS Jets)'), + Plot1D('ptCorrUParT', 'ptCorrUParT', 20, 0, 2, 'pt correction (UParT 2024 - PUPPI Jets)'), + Plot1D('qConfUParT', 'qConfUUParT', 20, -0.5, 0.5, 'signed charge confidence (UParT 2024 - PUPPI Jets)'), + Plot1D('probDM0UParT', 'probDM0UParT', 20, 0, 1, 'normalised probablity of decayMode 0, 1h+0pi0 (UParT 2024 - PUPPI Jets)'), + Plot1D('probDM1UParT', 'probDM1UParT', 20, 0, 1, 'normalised probablity of decayMode 1, 1h+1pi0 (UParT 2024 - PUPPI Jets)'), + Plot1D('probDM2UParT', 'probDM2UParT', 20, 0, 1, 'normalised probablity of decayMode 2, 1h+2pi0 (UParT 2024 - PUPPI Jets)'), + Plot1D('probDM10UParT', 'probDM10UParT', 20, 0, 1, 'normalised probablity of decayMode 10, 3h+0pi0 (UParT 2024 - PUPPI Jets)'), + Plot1D('probDM11UParT', 'probDM11UParT', 20, 0, 1, 'normalised probablity of decayMode 11, 3h+1pi0 (UParT 2024 - PUPPI Jets)'), ) ), TauProd = cms.PSet( diff --git a/PhysicsTools/NanoAOD/python/nano_cff.py b/PhysicsTools/NanoAOD/python/nano_cff.py index 515c0c75d066a..ec54b3ddc96a3 100644 --- a/PhysicsTools/NanoAOD/python/nano_cff.py +++ b/PhysicsTools/NanoAOD/python/nano_cff.py @@ -139,16 +139,27 @@ def nanoAOD_addBoostedTauIds(process, idsToRun=[]): return process -def nanoAOD_addPNetToTaus(process, addPNetInfo=False, runPNetCHSAK4=False): - if addPNetInfo: +def nanoAOD_addUTagToTaus(process, addUTagInfo=False, usePUPPIjets=False): + + if addUTagInfo: originalTauName = process.finalTaus.src.value() - updatedTauName = originalTauName+'WithPNet' - jetCollection = "updatedJets" - process.load('RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK4_cff') - pnetTagName = "pfParticleNetFromMiniAODAK4CHSCentralJetTag" - pnetDiscriminators = []; - for tag in getattr(process,pnetTagName+"s").flav_names.value(): - pnetDiscriminators.append(pnetTagName+"s:"+tag) + + if usePUPPIjets: # option to use PUPPI jets + jetCollection = "updatedJetsPuppi" + TagName = "pfUnifiedParticleTransformerAK4JetTags" + tag_prefix = "byUTagPUPPI" + updatedTauName = originalTauName+'WithUTagPUPPI' + # Unified ParT Tagger used for PUPPI jets + from RecoBTag.ONNXRuntime.pfUnifiedParticleTransformerAK4JetTags_cfi import pfUnifiedParticleTransformerAK4JetTags + Discriminators = [TagName+":"+tag for tag in pfUnifiedParticleTransformerAK4JetTags.flav_names.value()] + else: # use CHS jets by default + jetCollection = "updatedJets" + TagName = "pfParticleNetFromMiniAODAK4CHSCentralJetTags" + tag_prefix = "byUTagCHS" + updatedTauName = originalTauName+'WithUTagCHS' + # PNet tagger used for CHS jets + from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK4_cff import pfParticleNetFromMiniAODAK4CHSCentralJetTags + Discriminators = [TagName+":"+tag for tag in pfParticleNetFromMiniAODAK4CHSCentralJetTags.flav_names.value()] # Define "hybridTau" producer from PhysicsTools.PatAlgos.patTauHybridProducer_cfi import patTauHybridProducer @@ -158,8 +169,9 @@ def nanoAOD_addPNetToTaus(process, addPNetInfo=False, runPNetCHSAK4=False): dRMax = 0.4, jetPtMin = 15, jetEtaMax = 2.5, - pnetLabel = pnetTagName+"s", - pnetScoreNames = pnetDiscriminators, + UTagLabel = TagName, + UTagScoreNames = Discriminators, + tagPrefix = tag_prefix, tauScoreMin = -1, vsJetMin = 0.05, checkTauScoreIsBest = False, @@ -169,15 +181,6 @@ def nanoAOD_addPNetToTaus(process, addPNetInfo=False, runPNetCHSAK4=False): )) process.finalTaus.src = updatedTauName - # run PNet for CHS AK4 jets if requested - if runPNetCHSAK4: - from PhysicsTools.NanoAOD.jetsAK4_CHS_cff import nanoAOD_addDeepInfoAK4CHS - process = nanoAOD_addDeepInfoAK4CHS(process, - addDeepBTag = False, - addDeepFlavour = False, - addParticleNet = True - ) - #remember to adjust the selection and tables with added IDs process.tauTask.add(process.jetTask, getattr(process, updatedTauName)) @@ -209,7 +212,14 @@ def nanoAOD_customizeCommon(process): nanoAOD_addDeepInfoAK4CHS_switch, nanoAOD_addParticleNet_switch=True, nanoAOD_addRobustParTAK4Tag_switch=True, ) - + + # enable rerun of PNet for CHS jets for early run3 eras + # (it is rerun for run2 within jet tasks while is not needed for newer + # run3 eras as it is present in miniAOD) + (run3_nanoAOD_122 | run3_nanoAOD_124).toModify( + nanoAOD_addDeepInfoAK4CHS_switch, nanoAOD_addParticleNet_switch = True + ) + # This function is defined in jetsAK4_Puppi_cff.py process = nanoAOD_addDeepInfoAK4(process, addParticleNet=nanoAOD_addDeepInfoAK4_switch.nanoAOD_addParticleNet_switch, @@ -237,7 +247,7 @@ def nanoAOD_customizeCommon(process): nanoAOD_tau_switch = cms.PSet( idsToAdd = cms.vstring(), - runPNetAK4 = cms.bool(False), + addUParTInfo = cms.bool(True), addPNet = cms.bool(True) ) (run2_nanoAOD_106Xv2 | run3_nanoAOD_122).toModify( @@ -245,17 +255,25 @@ def nanoAOD_customizeCommon(process): ).toModify( process, lambda p : nanoAOD_addTauIds(p, nanoAOD_tau_switch.idsToAdd.value()) ) - # Add PNet info to taus - # enable rerun of PNet for CHS jets for early run3 eras - # (it is rerun for run2 within jet tasks while is not needed for newer - # run3 eras as it is present in miniAOD) - (run3_nanoAOD_122 | run3_nanoAOD_124).toModify( - nanoAOD_tau_switch, runPNetAK4 = True + + # Don't add Unified Tagger for PUPPI jets for Run 2 (as different PUPPI tune + # and base jet algorithm) or early Run 3 eras + (run3_nanoAOD_122 | run3_nanoAOD_124 | run2_nanoAOD_106Xv2).toModify( + nanoAOD_tau_switch, addUParTInfo = False + ) + + # Add Unified Tagger For CHS Jets (PNet 2023) + nanoAOD_addUTagToTaus(process, + addUTagInfo = nanoAOD_tau_switch.addPNet.value(), + usePUPPIjets = False ) - nanoAOD_addPNetToTaus(process, - addPNetInfo = nanoAOD_tau_switch.addPNet.value(), - runPNetCHSAK4 = nanoAOD_tau_switch.runPNetAK4.value() + + # Add Unified Tagger For PUPPI Jets (UParT 2024) + nanoAOD_addUTagToTaus(process, + addUTagInfo = nanoAOD_tau_switch.addUParTInfo.value(), + usePUPPIjets = True ) + nanoAOD_boostedTau_switch = cms.PSet( idsToAdd = cms.vstring() ) diff --git a/PhysicsTools/NanoAOD/python/taus_cff.py b/PhysicsTools/NanoAOD/python/taus_cff.py index d9586ed72a404..ef1b77a23969d 100644 --- a/PhysicsTools/NanoAOD/python/taus_cff.py +++ b/PhysicsTools/NanoAOD/python/taus_cff.py @@ -20,12 +20,12 @@ finalTaus = cms.EDFilter("PATTauRefSelector", src = cms.InputTag("slimmedTaus"), - cut = cms.string("pt > 18 && ((tauID('decayModeFindingNewDMs') > 0.5 && (tauID('byLooseCombinedIsolationDeltaBetaCorr3Hits') || (tauID('chargedIsoPtSumdR03')+max(0.,tauID('neutralIsoPtSumdR03')-0.072*tauID('puCorrPtSum'))<2.5) || tauID('byVVVLooseDeepTau2017v2p1VSjet') || tauID('byVVVLooseDeepTau2018v2p5VSjet'))) || (?isTauIDAvailable('byPNetVSjetraw')?tauID('byPNetVSjetraw'):-1) > {})".format(0.05)) + cut = cms.string("pt > 18 && ((tauID('decayModeFindingNewDMs') > 0.5 && (tauID('byLooseCombinedIsolationDeltaBetaCorr3Hits') || (tauID('chargedIsoPtSumdR03')+max(0.,tauID('neutralIsoPtSumdR03')-0.072*tauID('puCorrPtSum'))<2.5) || tauID('byVVVLooseDeepTau2017v2p1VSjet') || tauID('byVVVLooseDeepTau2018v2p5VSjet'))) || (?isTauIDAvailable('byUTagCHSVSjetraw')?tauID('byUTagCHSVSjetraw'):-1) > {} || (?isTauIDAvailable('byUTagPUPPIVSjetraw')?tauID('byUTagPUPPIVSjetraw'):-1) > {})".format(0.05, 0.05)) ) run3_nanoAOD_124.toModify( finalTaus, - cut = cms.string("pt > 18 && ((tauID('decayModeFindingNewDMs') > 0.5 && (tauID('byLooseCombinedIsolationDeltaBetaCorr3Hits') || (tauID('chargedIsoPtSumdR03')+max(0.,tauID('neutralIsoPtSumdR03')-0.072*tauID('puCorrPtSum'))<2.5) || tauID('byVVVLooseDeepTau2017v2p1VSjet') || (tauID('byDeepTau2018v2p5VSjetraw') > {}))) || (?isTauIDAvailable('byPNetVSjetraw')?tauID('byPNetVSjetraw'):-1) > {})".format(WORKING_POINTS_v2p5["jet"]["VVVLoose"],0.05)) + cut = cms.string("pt > 18 && ((tauID('decayModeFindingNewDMs') > 0.5 && (tauID('byLooseCombinedIsolationDeltaBetaCorr3Hits') || (tauID('chargedIsoPtSumdR03')+max(0.,tauID('neutralIsoPtSumdR03')-0.072*tauID('puCorrPtSum'))<2.5) || tauID('byVVVLooseDeepTau2017v2p1VSjet') || (tauID('byDeepTau2018v2p5VSjetraw') > {}))) || (?isTauIDAvailable('byUTagCHSVSjetraw')?tauID('byUTagCHSVSjetraw'):-1) > {} || (?isTauIDAvailable('byUTagPUPPIVSjetraw')?tauID('byUTagPUPPIVSjetraw'):-1) > {})".format(WORKING_POINTS_v2p5["jet"]["VVVLoose"], 0.05, 0.05)) ) ##################### Tables for final output and docs ########################## @@ -115,25 +115,40 @@ def _tauIdWPMask(pattern, choices, doc="", from_raw=False, wp_thrs=None): doc="byDeepTau2018v2p5VSjet ID working points (deepTau2018v2p5)"), ) -_pnet2023 = cms.PSet( - decayModePNet = Var("?isTauIDAvailable('byPNetDecayMode')?tauID('byPNetDecayMode'):-1", "int16",doc="decay mode of the highest tau score of ParticleNet"), - rawPNetVSe = Var("?isTauIDAvailable('byPNetVSeraw')?tauID('byPNetVSeraw'):-1", float, doc="raw output of ParticleNetVsE discriminator (PNet 2023)", precision=10), - rawPNetVSmu = Var("?isTauIDAvailable('byPNetVSmuraw')?tauID('byPNetVSmuraw'):-1", float, doc="raw output of ParticleNetVsMu discriminator (PNet 2023)", precision=10), - rawPNetVSjet = Var("?isTauIDAvailable('byPNetVSjetraw')?tauID('byPNetVSjetraw'):-1", float, doc="raw output of ParticleNetVsJet discriminator (PNet 2023)", precision=10), - ptCorrPNet = Var("?isTauIDAvailable('byPNetPtCorr')?tauID('byPNetPtCorr'):1", float, doc="pt correction (PNet 2023)", precision=10), - qConfPNet = Var("?isTauIDAvailable('byPNetQConf')?tauID('byPNetQConf'):0", float, doc="signed charge confidence (PNet 2023)", precision=10), - probDM0PNet = Var("?isTauIDAvailable('byPNetProb1h0pi0')?tauID('byPNetProb1h0pi0'):-1", float, doc="normalised probablity of decayMode 0, 1h+0pi0 (PNet 2023)", precision=10), - probDM1PNet = Var("?isTauIDAvailable('byPNetProb1h1pi0')?tauID('byPNetProb1h1pi0'):-1", float, doc="normalised probablity of decayMode 1, 1h+1pi0 (PNet 2023)", precision=10), - probDM2PNet = Var("?isTauIDAvailable('byPNetProb1h2pi0')?tauID('byPNetProb1h2pi0'):-1", float, doc="normalised probablity of decayMode 2, 1h+2pi0 (PNet 2023)", precision=10), - probDM10PNet = Var("?isTauIDAvailable('byPNetProb3h0pi0')?tauID('byPNetProb3h0pi0'):-1", float, doc="normalised probablity of decayMode 10, 3h+0pi0 (PNet 2023)", precision=10), - probDM11PNet = Var("?isTauIDAvailable('byPNetProb3h1pi0')?tauID('byPNetProb3h1pi0'):-1", float, doc="normalised probablity of decayMode 11, 3h+1pi0 (PNet 2023)", precision=10), +_UTagCHS = cms.PSet( + decayModePNet = Var("?isTauIDAvailable('byUTagCHSDecayMode')?tauID('byUTagCHSDecayMode'):-1", "int16",doc="decay mode of the highest tau score of ParticleNet (CHS Jets)"), + rawPNetVSe = Var("?isTauIDAvailable('byUTagCHSVSeraw')?tauID('byUTagCHSVSeraw'):-1", float, doc="raw output of ParticleNetVsE discriminator (PNet 2023 - CHS Jets)", precision=10), + rawPNetVSmu = Var("?isTauIDAvailable('byUTagCHSVSmuraw')?tauID('byUTagCHSVSmuraw'):-1", float, doc="raw output of ParticleNetVsMu discriminator (PNet 2023 - CHS Jets)", precision=10), + rawPNetVSjet = Var("?isTauIDAvailable('byUTagCHSVSjetraw')?tauID('byUTagCHSVSjetraw'):-1", float, doc="raw output of ParticleNetVsJet discriminator (PNet 2023 - CHS Jets)", precision=10), + ptCorrPNet = Var("?isTauIDAvailable('byUTagCHSPtCorr')?tauID('byUTagCHSPtCorr'):1", float, doc="pt correction (PNet 2023 - CHS Jets)", precision=10), + qConfPNet = Var("?isTauIDAvailable('byUTagCHSQConf')?tauID('byUTagCHSQConf'):0", float, doc="signed charge confidence (PNet 2023 - CHS Jets)", precision=10), + probDM0PNet = Var("?isTauIDAvailable('byUTagCHSProb1h0pi0')?tauID('byUTagCHSProb1h0pi0'):-1", float, doc="normalised probablity of decayMode 0, 1h+0pi0 (PNet 2023 - CHS Jets)", precision=10), + probDM1PNet = Var("?isTauIDAvailable('byUTagCHSProb1h1pi0')?tauID('byUTagCHSProb1h1pi0'):-1", float, doc="normalised probablity of decayMode 1, 1h+1pi0 (PNet 2023 - CHS Jets)", precision=10), + probDM2PNet = Var("?isTauIDAvailable('byUTagCHSProb1h2pi0')?tauID('byUTagCHSProb1h2pi0'):-1", float, doc="normalised probablity of decayMode 2, 1h+2pi0 (PNet 2023 - CHS Jets)", precision=10), + probDM10PNet = Var("?isTauIDAvailable('byUTagCHSProb3h0pi0')?tauID('byUTagCHSProb3h0pi0'):-1", float, doc="normalised probablity of decayMode 10, 3h+0pi0 (PNet 2023 - CHS Jets)", precision=10), + probDM11PNet = Var("?isTauIDAvailable('byUTagCHSProb3h1pi0')?tauID('byUTagCHSProb3h1pi0'):-1", float, doc="normalised probablity of decayMode 11, 3h+1pi0 (PNet 2023 - CHS Jets)", precision=10), +) + +_UTagPUPPI = cms.PSet( + decayModeUParT= Var("?isTauIDAvailable('byUTagPUPPIDecayMode')?tauID('byUTagPUPPIDecayMode'):-1", "int16",doc="decay mode of the highest tau score of Unified ParT 2024 (PUPPI Jets)"), + rawUParTVSe = Var("?isTauIDAvailable('byUTagPUPPIVSeraw')?tauID('byUTagPUPPIVSeraw'):-1", float, doc="raw output of UParTVsE discriminator (Unified ParT 2024 - PUPPI Jets)", precision=10), + rawUParTVSmu = Var("?isTauIDAvailable('byUTagPUPPIVSmuraw')?tauID('byUTagPUPPIVSmuraw'):-1", float, doc="raw output of UParTVsMu discriminator (Unified ParT 2024 - PUPPI Jets)", precision=10), + rawUParTVSjet = Var("?isTauIDAvailable('byUTagPUPPIVSjetraw')?tauID('byUTagPUPPIVSjetraw'):-1", float, doc="raw output of UParTVsJet discriminator (Unified ParT 2024 - PUPPI Jets)", precision=10), + ptCorrUParT= Var("?isTauIDAvailable('byUTagPUPPIPtCorr')?tauID('byUTagPUPPIPtCorr'):1", float, doc="pt correction (Unified ParT 2024 - PUPPI Jets)", precision=10), + qConfUParT= Var("?isTauIDAvailable('byUTagPUPPIQConf')?tauID('byUTagPUPPIQConf'):0", float, doc="signed charge confidence (Unified ParT 2024 - PUPPI Jets)", precision=10), + probDM0UParT= Var("?isTauIDAvailable('byUTagPUPPIProb1h0pi0')?tauID('byUTagPUPPIProb1h0pi0'):-1", float, doc="normalised probablity of decayMode 0, 1h+0pi0 (Unified ParT 2024 - PUPPI Jets)", precision=10), + probDM1UParT= Var("?isTauIDAvailable('byUTagPUPPIProb1h1pi0')?tauID('byUTagPUPPIProb1h1pi0'):-1", float, doc="normalised probablity of decayMode 1, 1h+1pi0 (Unified ParT 2024 - PUPPI Jets)", precision=10), + probDM2UParT= Var("?isTauIDAvailable('byUTagPUPPIProb1h2pi0')?tauID('byUTagPUPPIProb1h2pi0'):-1", float, doc="normalised probablity of decayMode 2, 1h+2pi0 (Unified ParT 2024 - PUPPI Jets)", precision=10), + probDM10UParT= Var("?isTauIDAvailable('byUTagPUPPIProb3h0pi0')?tauID('byUTagPUPPIProb3h0pi0'):-1", float, doc="normalised probablity of decayMode 10, 3h+0pi0 (Unified ParT 2024 - PUPPI Jets)", precision=10), + probDM11UParT= Var("?isTauIDAvailable('byUTagPUPPIProb3h1pi0')?tauID('byUTagPUPPIProb3h1pi0'):-1", float, doc="normalised probablity of decayMode 11, 3h+1pi0 (Unified ParT 2024 - PUPPI Jets)", precision=10), ) _variablesMiniV2 = cms.PSet( _tauVarsBase, _deepTauVars2017v2p1, _deepTauVars2018v2p5, - _pnet2023 + _UTagCHS, + _UTagPUPPI ) tauTable.variables = _variablesMiniV2 diff --git a/PhysicsTools/PatAlgos/plugins/PATTauHybridProducer.cc b/PhysicsTools/PatAlgos/plugins/PATTauHybridProducer.cc index e3172d01e870d..b23824ed88310 100644 --- a/PhysicsTools/PatAlgos/plugins/PATTauHybridProducer.cc +++ b/PhysicsTools/PatAlgos/plugins/PATTauHybridProducer.cc @@ -27,20 +27,20 @@ class PATTauHybridProducer : public edm::stream::EDProducer<> { bool addGenJetMatch_; edm::EDGetTokenT> genJetMatchToken_; const float dR2Max_, jetPtMin_, jetEtaMax_; - const std::string pnetLabel_; - std::vector pnetTauScoreNames_; - std::vector pnetJetScoreNames_; - std::vector pnetLepScoreNames_; - std::string pnetPtCorrName_; + const std::string UTagLabel_; + const std::string tagPrefix_; + std::vector utagTauScoreNames_; + std::vector utagJetScoreNames_; + std::vector utagLepScoreNames_; + std::string UtagPtCorrName_; const float tauScoreMin_, vsJetMin_, chargeAssignmentProbMin_; const bool checkTauScoreIsBest_; const bool usePFLeptonsAsChargedHadrons_; const std::map tagToDM_; - enum class tauId_pnet_idx : size_t { dm = 0, vsjet, vse, vsmu, ptcorr, qconf, pdm0, pdm1, pdm2, pdm10, pdm11, last }; + enum class tauId_utag_idx : size_t { dm = 0, vsjet, vse, vsmu, ptcorr, qconf, pdm0, pdm1, pdm2, pdm10, pdm11, last }; enum class tauId_min_idx : size_t { hpsnew = 0, last }; }; - PATTauHybridProducer::PATTauHybridProducer(const edm::ParameterSet& cfg) : tausToken_(consumes(cfg.getParameter("src"))), jetsToken_(consumes(cfg.getParameter("jetSource"))), @@ -48,29 +48,33 @@ PATTauHybridProducer::PATTauHybridProducer(const edm::ParameterSet& cfg) dR2Max_(std::pow(cfg.getParameter("dRMax"), 2)), jetPtMin_(cfg.getParameter("jetPtMin")), jetEtaMax_(cfg.getParameter("jetEtaMax")), - pnetLabel_(cfg.getParameter("pnetLabel")), - pnetPtCorrName_(cfg.getParameter("pnetPtCorrName")), + UTagLabel_(cfg.getParameter("UTagLabel")), + tagPrefix_(cfg.getParameter("tagPrefix")), + UtagPtCorrName_(cfg.getParameter("UtagPtCorrName")), tauScoreMin_(cfg.getParameter("tauScoreMin")), vsJetMin_(cfg.getParameter("vsJetMin")), chargeAssignmentProbMin_(cfg.getParameter("chargeAssignmentProbMin")), checkTauScoreIsBest_(cfg.getParameter("checkTauScoreIsBest")), usePFLeptonsAsChargedHadrons_(cfg.getParameter("usePFLeptonsAsChargedHadrons")), tagToDM_({{"1h0p", 0}, {"1h1or2p", 1}, {"1h1p", 1}, {"1h2p", 2}, {"3h0p", 10}, {"3h1p", 11}}) { - // Read the different PNet score names - std::vector pnetScoreNames = cfg.getParameter>("pnetScoreNames"); - for (const auto& scoreName : pnetScoreNames) { - size_t labelLenght = scoreName.find(':') == std::string::npos ? 0 : scoreName.find(':') + 1; - std::string name = scoreName.substr(labelLenght); + // Read the different Unified Tagger score names + std::vector UTagScoreNames = cfg.getParameter>("UTagScoreNames"); + for (const auto& scoreName : UTagScoreNames) { + // Check that discriminator matches tagger specified + if (scoreName.find(UTagLabel_) == std::string::npos) + continue; + size_t labelLength = scoreName.find(':') == std::string::npos ? 0 : scoreName.find(':') + 1; + std::string name = scoreName.substr(labelLength); if (name.find("prob") == std::string::npos) continue; - if (name.find("tau") != std::string::npos) - pnetTauScoreNames_.push_back(name); - else if (name.find("ele") != std::string::npos || name.find("mu") != std::string::npos) - pnetLepScoreNames_.push_back(name); - else - pnetJetScoreNames_.push_back(name); - if (pnetPtCorrName_.find(':') != std::string::npos) - pnetPtCorrName_ = pnetPtCorrName_.substr(pnetPtCorrName_.find(':') + 1); + if (name.find("probtau") != std::string::npos) + utagTauScoreNames_.push_back(name); + else if (name == "probele" || name == "probmu") + utagLepScoreNames_.push_back(name); + else if (name.find("data") == std::string::npos && name.find("mc") == std::string::npos) + utagJetScoreNames_.push_back(name); + if (UtagPtCorrName_.find(':') != std::string::npos) + UtagPtCorrName_ = UtagPtCorrName_.substr(UtagPtCorrName_.find(':') + 1); // GenJet matching if (addGenJetMatch_) { genJetMatchToken_ = @@ -106,19 +110,19 @@ void PATTauHybridProducer::produce(edm::Event& evt, const edm::EventSetup& es) { std::vector tauIds_minimal((size_t)tauId_min_idx::last); tauIds_minimal[(size_t)tauId_min_idx::hpsnew] = std::make_pair("decayModeFindingNewDMs", -1); - // PNet tauID list - std::vector tauIds_pnet((size_t)tauId_pnet_idx::last); - tauIds_pnet[(size_t)tauId_pnet_idx::dm] = std::make_pair("byPNetDecayMode", reco::PFTau::kNull); - tauIds_pnet[(size_t)tauId_pnet_idx::vsjet] = std::make_pair("byPNetVSjetraw", -1); - tauIds_pnet[(size_t)tauId_pnet_idx::vse] = std::make_pair("byPNetVSeraw", -1); - tauIds_pnet[(size_t)tauId_pnet_idx::vsmu] = std::make_pair("byPNetVSmuraw", -1); - tauIds_pnet[(size_t)tauId_pnet_idx::ptcorr] = std::make_pair("byPNetPtCorr", 1); - tauIds_pnet[(size_t)tauId_pnet_idx::qconf] = std::make_pair("byPNetQConf", 0); - tauIds_pnet[(size_t)tauId_pnet_idx::pdm0] = std::make_pair("byPNetProb1h0pi0", -1); - tauIds_pnet[(size_t)tauId_pnet_idx::pdm1] = std::make_pair("byPNetProb1h1pi0", -1); - tauIds_pnet[(size_t)tauId_pnet_idx::pdm2] = std::make_pair("byPNetProb1h2pi0", -1); - tauIds_pnet[(size_t)tauId_pnet_idx::pdm10] = std::make_pair("byPNetProb3h0pi0", -1); - tauIds_pnet[(size_t)tauId_pnet_idx::pdm11] = std::make_pair("byPNetProb3h1pi0", -1); + // Unified Tagger tauID list + std::vector tauIds_utag((size_t)tauId_utag_idx::last); + tauIds_utag[(size_t)tauId_utag_idx::dm] = std::make_pair(tagPrefix_ + "DecayMode", reco::PFTau::kNull); + tauIds_utag[(size_t)tauId_utag_idx::vsjet] = std::make_pair(tagPrefix_ + "VSjetraw", -1); + tauIds_utag[(size_t)tauId_utag_idx::vse] = std::make_pair(tagPrefix_ + "VSeraw", -1); + tauIds_utag[(size_t)tauId_utag_idx::vsmu] = std::make_pair(tagPrefix_ + "VSmuraw", -1); + tauIds_utag[(size_t)tauId_utag_idx::ptcorr] = std::make_pair(tagPrefix_ + "PtCorr", 1); + tauIds_utag[(size_t)tauId_utag_idx::qconf] = std::make_pair(tagPrefix_ + "QConf", 0); + tauIds_utag[(size_t)tauId_utag_idx::pdm0] = std::make_pair(tagPrefix_ + "Prob1h0pi0", -1); + tauIds_utag[(size_t)tauId_utag_idx::pdm1] = std::make_pair(tagPrefix_ + "Prob1h1pi0", -1); + tauIds_utag[(size_t)tauId_utag_idx::pdm2] = std::make_pair(tagPrefix_ + "Prob1h2pi0", -1); + tauIds_utag[(size_t)tauId_utag_idx::pdm10] = std::make_pair(tagPrefix_ + "Prob3h0pi0", -1); + tauIds_utag[(size_t)tauId_utag_idx::pdm11] = std::make_pair(tagPrefix_ + "Prob3h1pi0", -1); std::set matched_taus; size_t jet_idx = 0; @@ -131,19 +135,19 @@ void PATTauHybridProducer::produce(edm::Event& evt, const edm::EventSetup& es) { size_t tau_idx = 0; bool matched = false; - // Analyse PNet scores - std::pair bestPnetTauScore("probtauundef", -1); - float sumOfPnetTauScores = 0; + // Analyse Tagger scores + std::pair bestUtagTauScore("probtauundef", -1); + float sumOfUtagTauScores = 0; std::vector tauPerDMScores(5); float plusChargeProb = 0; - for (const auto& scoreName : pnetTauScoreNames_) { - float score = jet.bDiscriminator(pnetLabel_ + ":" + scoreName); - sumOfPnetTauScores += score; + for (const auto& scoreName : utagTauScoreNames_) { + float score = jet.bDiscriminator(UTagLabel_ + ":" + scoreName); + sumOfUtagTauScores += score; if (scoreName.find("taup") != std::string::npos) plusChargeProb += score; - if (score > bestPnetTauScore.second) { - bestPnetTauScore.second = score; - bestPnetTauScore.first = scoreName; + if (score > bestUtagTauScore.second) { + bestUtagTauScore.second = score; + bestUtagTauScore.first = scoreName; } if (scoreName.find("1h0p") != std::string::npos) tauPerDMScores[0] += score; @@ -158,42 +162,42 @@ void PATTauHybridProducer::produce(edm::Event& evt, const edm::EventSetup& es) { else if (scoreName.find("3h1p") != std::string::npos) tauPerDMScores[4] += score; } - if (sumOfPnetTauScores > 0) - plusChargeProb /= sumOfPnetTauScores; + if (sumOfUtagTauScores > 0) + plusChargeProb /= sumOfUtagTauScores; - float sumOfPnetEleScores = 0, sumOfPnetMuScores = 0; - bool isTauScoreBest = (sumOfPnetTauScores > 0); - for (const auto& scoreName : pnetLepScoreNames_) { - float score = jet.bDiscriminator(pnetLabel_ + ":" + scoreName); + float sumOfUtagEleScores = 0, sumOfUtagMuScores = 0; + bool isTauScoreBest = (sumOfUtagTauScores > 0); + for (const auto& scoreName : utagLepScoreNames_) { + float score = jet.bDiscriminator(UTagLabel_ + ":" + scoreName); if (scoreName.find("ele") != std::string::npos) - sumOfPnetEleScores += score; + sumOfUtagEleScores += score; else if (scoreName.find("mu") != std::string::npos) - sumOfPnetMuScores += score; - if (score > bestPnetTauScore.second) + sumOfUtagMuScores += score; + if (score > bestUtagTauScore.second) isTauScoreBest = false; } if (checkTauScoreIsBest_ && isTauScoreBest) { //if needed iterate over jet scores - for (const auto& scoreName : pnetJetScoreNames_) - if (jet.bDiscriminator(pnetLabel_ + ":" + scoreName) > bestPnetTauScore.second) + for (const auto& scoreName : utagJetScoreNames_) + if (jet.bDiscriminator(UTagLabel_ + ":" + scoreName) > bestUtagTauScore.second) isTauScoreBest = false; } - // PNet discriminants vs jets, electrons and muons - tauIds_pnet[(size_t)tauId_pnet_idx::vsjet].second = - sumOfPnetTauScores / - (1. - sumOfPnetEleScores - - sumOfPnetMuScores); //vsJet: tau scores by sum of tau and jet scores or equally by 1 - sum of lepton scores - tauIds_pnet[(size_t)tauId_pnet_idx::vse].second = - sumOfPnetTauScores / - (sumOfPnetTauScores + sumOfPnetEleScores); //vsEle: tau scores by sum of tau and ele scores - tauIds_pnet[(size_t)tauId_pnet_idx::vsmu].second = - sumOfPnetTauScores / (sumOfPnetTauScores + sumOfPnetMuScores); //vsMu: tau scores by sum of tau and mu scores + // Unified Tagger discriminants vs jets, electrons and muons + tauIds_utag[(size_t)tauId_utag_idx::vsjet].second = + sumOfUtagTauScores / + (1. - sumOfUtagEleScores - + sumOfUtagMuScores); //vsJet: tau scores by sum of tau and jet scores or equally by 1 - sum of lepton scores + tauIds_utag[(size_t)tauId_utag_idx::vse].second = + sumOfUtagTauScores / + (sumOfUtagTauScores + sumOfUtagEleScores); //vsEle: tau scores by sum of tau and ele scores + tauIds_utag[(size_t)tauId_utag_idx::vsmu].second = + sumOfUtagTauScores / (sumOfUtagTauScores + sumOfUtagMuScores); //vsMu: tau scores by sum of tau and mu scores // Decay mode and charge of the highest tau score int bestCharge = 0; size_t pos = - bestPnetTauScore.first.find("tau") + 3; //this is well defined by constraction as name is "probtauXXXX" - const char q = (pos < bestPnetTauScore.first.size()) ? bestPnetTauScore.first[pos] : 'u'; + bestUtagTauScore.first.find("tau") + 3; //this is well defined by constraction as name is "probtauXXXX" + const char q = (pos < bestUtagTauScore.first.size()) ? bestUtagTauScore.first[pos] : 'u'; if (q == 'm') { //minus pos++; bestCharge = -1; @@ -201,24 +205,24 @@ void PATTauHybridProducer::produce(edm::Event& evt, const edm::EventSetup& es) { pos++; bestCharge = 1; } - auto pNetDM = tagToDM_.find(bestPnetTauScore.first.substr(pos)); - if (pNetDM != tagToDM_.end()) - tauIds_pnet[(size_t)tauId_pnet_idx::dm].second = pNetDM->second; + auto UtagDM = tagToDM_.find(bestUtagTauScore.first.substr(pos)); + if (UtagDM != tagToDM_.end()) + tauIds_utag[(size_t)tauId_utag_idx::dm].second = UtagDM->second; - // PNet Pt correction - float ptcorr = jet.bDiscriminator(pnetLabel_ + ":" + pnetPtCorrName_); + // Unified tagger Pt correction + float ptcorr = jet.bDiscriminator(UTagLabel_ + ":" + UtagPtCorrName_); if (ptcorr > -1000.) // -1000. is default for not found discriminantor - tauIds_pnet[(size_t)tauId_pnet_idx::ptcorr].second = ptcorr; + tauIds_utag[(size_t)tauId_utag_idx::ptcorr].second = ptcorr; - // PNet charge confidence - tauIds_pnet[(size_t)tauId_pnet_idx::qconf].second = (plusChargeProb - 0.5); + // Unified Tagger charge confidence + tauIds_utag[(size_t)tauId_utag_idx::qconf].second = (plusChargeProb - 0.5); - // PNet per decay mode normalised score - tauIds_pnet[(size_t)tauId_pnet_idx::pdm0].second = tauPerDMScores[0] / sumOfPnetTauScores; - tauIds_pnet[(size_t)tauId_pnet_idx::pdm1].second = tauPerDMScores[1] / sumOfPnetTauScores; - tauIds_pnet[(size_t)tauId_pnet_idx::pdm2].second = tauPerDMScores[2] / sumOfPnetTauScores; - tauIds_pnet[(size_t)tauId_pnet_idx::pdm10].second = tauPerDMScores[3] / sumOfPnetTauScores; - tauIds_pnet[(size_t)tauId_pnet_idx::pdm11].second = tauPerDMScores[4] / sumOfPnetTauScores; + // Unified Tagger per decay mode normalised score + tauIds_utag[(size_t)tauId_utag_idx::pdm0].second = tauPerDMScores[0] / sumOfUtagTauScores; + tauIds_utag[(size_t)tauId_utag_idx::pdm1].second = tauPerDMScores[1] / sumOfUtagTauScores; + tauIds_utag[(size_t)tauId_utag_idx::pdm2].second = tauPerDMScores[2] / sumOfUtagTauScores; + tauIds_utag[(size_t)tauId_utag_idx::pdm10].second = tauPerDMScores[3] / sumOfUtagTauScores; + tauIds_utag[(size_t)tauId_utag_idx::pdm11].second = tauPerDMScores[4] / sumOfUtagTauScores; // Search for matching tau for (const auto& inputTau : *inputTaus) { @@ -231,11 +235,23 @@ void PATTauHybridProducer::produce(edm::Event& evt, const edm::EventSetup& es) { matched_taus.insert(tau_idx - 1); pat::Tau outputTau(inputTau); const size_t nTauIds = inputTau.tauIDs().size(); - std::vector tauIds(nTauIds + tauIds_pnet.size()); + std::vector tauIds(nTauIds + tauIds_utag.size()); for (size_t i = 0; i < nTauIds; ++i) tauIds[i] = inputTau.tauIDs()[i]; - for (size_t i = 0; i < tauIds_pnet.size(); ++i) - tauIds[nTauIds + i] = tauIds_pnet[i]; + for (size_t i = 0; i < tauIds_utag.size(); ++i) { + if ((tauIds_utag[i].first.find("PtCorr") != std::string::npos) && + (inputTau.tauID("decayModeFindingNewDMs") == -1)) { + // if jet is matched to a recovered tau (i.e. non-HPS) then the Pt Correction + // should be adjusted so that it can still be applied as PtCorr * TauPt + // (as the original PtCorr will be w.r.t the jet pT, but recovered tau + // pT is not necessarily set by same jet algorithm if adding both CHS + // and PUPPI based taggers) + tauIds[nTauIds + i].first = tauIds_utag[i].first; + tauIds[nTauIds + i].second = tauIds_utag[i].second * jet.correctedP4("Uncorrected").pt() / inputTau.pt(); + } else { + tauIds[nTauIds + i] = tauIds_utag[i]; + } + } outputTau.setTauIDs(tauIds); matched = true; outputTaus->push_back(outputTau); @@ -247,8 +263,8 @@ void PATTauHybridProducer::produce(edm::Event& evt, const edm::EventSetup& es) { continue; // Accept only jets passing minimal tau-like selection, i.e. with one of the tau score being globally the best and above some threshold, and with good quality of charge assignment - if ((checkTauScoreIsBest_ && !isTauScoreBest) || bestPnetTauScore.second < tauScoreMin_ || - tauIds_pnet[(size_t)tauId_pnet_idx::vsjet].second < vsJetMin_ || + if ((checkTauScoreIsBest_ && !isTauScoreBest) || bestUtagTauScore.second < tauScoreMin_ || + tauIds_utag[(size_t)tauId_utag_idx::vsjet].second < vsJetMin_ || std::abs(0.5 - plusChargeProb) < chargeAssignmentProbMin_) continue; @@ -257,9 +273,9 @@ void PATTauHybridProducer::produce(edm::Event& evt, const edm::EventSetup& es) { reco::PFTau pfTauFromJet(bestCharge, jet.correctedP4("Uncorrected")); // Set PDGid pfTauFromJet.setPdgId(bestCharge < 0 ? 15 : -15); - // and decay mode predicted by PNet + // and decay mode predicted by unified Tagger pfTauFromJet.setDecayMode( - static_cast(int(tauIds_pnet[(size_t)tauId_pnet_idx::dm].second))); + static_cast(int(tauIds_utag[(size_t)tauId_utag_idx::dm].second))); // Fill tau content using only jet consistunets within cone around leading // charged particle // FIXME: more sophisticated finding of tau constituents will be considered later @@ -271,11 +287,11 @@ void PATTauHybridProducer::produce(edm::Event& evt, const edm::EventSetup& es) { // PATTau pat::Tau outputTauFromJet(pfTauFromJet); // Add tauIDs - std::vector newtauIds(tauIds_minimal.size() + tauIds_pnet.size()); + std::vector newtauIds(tauIds_minimal.size() + tauIds_utag.size()); for (size_t i = 0; i < tauIds_minimal.size(); ++i) newtauIds[i] = tauIds_minimal[i]; - for (size_t i = 0; i < tauIds_pnet.size(); ++i) - newtauIds[tauIds_minimal.size() + i] = tauIds_pnet[i]; + for (size_t i = 0; i < tauIds_utag.size(); ++i) + newtauIds[tauIds_minimal.size() + i] = tauIds_utag[i]; outputTauFromJet.setTauIDs(newtauIds); // Add genTauJet match if (addGenJetMatch_) { @@ -296,13 +312,13 @@ void PATTauHybridProducer::produce(edm::Event& evt, const edm::EventSetup& es) { const pat::Tau& inputTau = inputTaus->at(iTau); pat::Tau outputTau(inputTau); const size_t nTauIds = inputTau.tauIDs().size(); - std::vector tauIds(nTauIds + tauIds_pnet.size()); + std::vector tauIds(nTauIds + tauIds_utag.size()); for (size_t i = 0; i < nTauIds; ++i) tauIds[i] = inputTau.tauIDs()[i]; - for (size_t i = 0; i < tauIds_pnet.size(); ++i) { - tauIds[nTauIds + i] = tauIds_pnet[i]; + for (size_t i = 0; i < tauIds_utag.size(); ++i) { + tauIds[nTauIds + i] = tauIds_utag[i]; tauIds[nTauIds + i].second = - (i != (size_t)tauId_pnet_idx::ptcorr ? (i != (size_t)tauId_pnet_idx::qconf ? -1 : 0) : 1); + (i != (size_t)tauId_utag_idx::ptcorr ? (i != (size_t)tauId_utag_idx::qconf ? -1 : 0) : 1); } outputTau.setTauIDs(tauIds); outputTaus->push_back(outputTau); @@ -412,19 +428,17 @@ void PATTauHybridProducer::fillDescriptions(edm::ConfigurationDescriptions& desc edm::ParameterSetDescription desc; desc.add("src", edm::InputTag("slimmedTaus")); - desc.add("jetSource", edm::InputTag("slimmedJetsUpadted")); + desc.add("jetSource", edm::InputTag("slimmedJetsUpdated")); desc.add("dRMax", 0.4); desc.add("jetPtMin", 20.0); desc.add("jetEtaMax", 2.5); - desc.add("pnetLabel", "pfParticleNetAK4JetTags"); - desc.add>( - "pnetScoreNames", - {"probmu", "probele", "probtaup1h0p", "probtaup1h1p", "probtaup1h2p", "probtaup3h0p", "probtaup3h1p", - "probtaum1h0p", "probtaum1h1p", "probtaum1h2p", "probtaum3h0p", "probtaum3h1p", "probb", "probc", - "probuds", "probg", "ptcorr", "ptreshigh", "ptreslow", "ptnu"}); - desc.add("pnetPtCorrName", "ptcorr"); + desc.add("UTagLabel", "pfParticleNetAK4JetTags"); + desc.add("tagPrefix", "byUTag")->setComment("Prefix to be set for PUPPI or CHS tagger"); + desc.add>("UTagScoreNames", {}) + ->setComment("Output nodes for Unified Tagger (different for PNet vs UParT)"); + desc.add("UtagPtCorrName", "ptcorr"); desc.add("tauScoreMin", -1)->setComment("Minimal value of the best tau score to built recovery tau"); - desc.add("vsJetMin", -1)->setComment("Minimal value of PNet tau-vs-jet discriminant to built recovery tau"); + desc.add("vsJetMin", -1)->setComment("Minimal value of UTag tau-vs-jet discriminant to built recovery tau"); desc.add("checkTauScoreIsBest", false) ->setComment("If true, recovery tau is built only if one of tau scores is the highest"); desc.add("chargeAssignmentProbMin", 0.2)