From 311adb94a63fdbaa25ca9e90ee8f32a5e63ef573 Mon Sep 17 00:00:00 2001 From: cmsbuild Date: Mon, 22 Apr 2024 19:52:23 +0200 Subject: [PATCH] Merge pull request #44660 from AlexDeMoor/from-CMSSW_14_0_X_2024-04-07-2300 [14_0_X] Introduce Unified Particle Transformer AK4 jet tagger (Backport) --- .../interface/ChargedCandidateFeatures.h | 10 +- .../BTauReco/interface/LostTracksFeatures.h | 34 + .../UnifiedParticleTransformerAK4Features.h | 25 + .../UnifiedParticleTransformerAK4TagInfo.h | 15 + DataFormats/BTauReco/src/classes.h | 2 + DataFormats/BTauReco/src/classes_def.xml | 16 +- PhysicsTools/NanoAOD/python/custom_btv_cff.py | 678 ++++++++++++++++++ PhysicsTools/NanoAOD/python/custom_jme_cff.py | 42 +- .../NanoAOD/python/jetsAK4_CHS_cff.py | 35 +- .../NanoAOD/python/jetsAK4_Puppi_cff.py | 23 +- PhysicsTools/NanoAOD/python/nanoDQM_cfi.py | 10 +- PhysicsTools/NanoAOD/python/nano_cff.py | 9 +- .../python/recoLayer0/bTagging_cff.py | 20 + .../python/slimming/applyDeepBtagging_cff.py | 3 +- .../PatAlgos/python/tools/jetTools.py | 34 +- RecoBTag/Configuration/python/RecoBTag_cff.py | 1 + .../interface/ChargedCandidateConverter.h | 1 + .../interface/LostTracksConverter.h | 81 +++ .../FeatureTools/interface/TrackInfoBuilder.h | 2 + ...edParticleTransformerAK4TagInfoProducer.cc | 530 ++++++++++++++ .../src/ChargedCandidateConverter.cc | 28 + .../FeatureTools/src/LostTracksConverter.cc | 60 ++ RecoBTag/FeatureTools/src/TrackInfoBuilder.cc | 7 +- ...rticleTransformerAK4ONNXJetTagsProducer.cc | 358 +++++++++ ...TransformerAK4DiscriminatorsJetTags_cfi.py | 157 ++++ .../pfUnifiedParticleTransformerAK4_cff.py | 29 + .../ONNXRuntime/test/test_deep_flavour_cfg.py | 2 +- .../test/test_unifiedpartak4_cfg.py | 88 +++ 28 files changed, 2260 insertions(+), 40 deletions(-) create mode 100644 DataFormats/BTauReco/interface/LostTracksFeatures.h create mode 100644 DataFormats/BTauReco/interface/UnifiedParticleTransformerAK4Features.h create mode 100644 DataFormats/BTauReco/interface/UnifiedParticleTransformerAK4TagInfo.h create mode 100644 PhysicsTools/NanoAOD/python/custom_btv_cff.py create mode 100644 RecoBTag/FeatureTools/interface/LostTracksConverter.h create mode 100644 RecoBTag/FeatureTools/plugins/UnifiedParticleTransformerAK4TagInfoProducer.cc create mode 100644 RecoBTag/FeatureTools/src/LostTracksConverter.cc create mode 100644 RecoBTag/ONNXRuntime/plugins/UnifiedParticleTransformerAK4ONNXJetTagsProducer.cc create mode 100644 RecoBTag/ONNXRuntime/python/pfUnifiedParticleTransformerAK4DiscriminatorsJetTags_cfi.py create mode 100644 RecoBTag/ONNXRuntime/python/pfUnifiedParticleTransformerAK4_cff.py create mode 100644 RecoBTag/ONNXRuntime/test/test_unifiedpartak4_cfg.py diff --git a/DataFormats/BTauReco/interface/ChargedCandidateFeatures.h b/DataFormats/BTauReco/interface/ChargedCandidateFeatures.h index 74a11fe2342c3..aae6c350a1a6c 100644 --- a/DataFormats/BTauReco/interface/ChargedCandidateFeatures.h +++ b/DataFormats/BTauReco/interface/ChargedCandidateFeatures.h @@ -22,7 +22,6 @@ namespace btagbtvdeep { float btagPf_trackSip3dSig; float btagPf_trackSip2dVal; float btagPf_trackSip2dSig; - float btagPf_trackJetDistVal; float drsubjet1; @@ -39,6 +38,15 @@ namespace btagbtvdeep { float drminsv; float distminsv; + float charge; + float btagPf_trackDecayLen; + float HadFrac; + float CaloFrac; + float pdgID; + float lostInnerHits; + float numberOfPixelHits; + float numberOfStripHits; + float pt; float px; float py; diff --git a/DataFormats/BTauReco/interface/LostTracksFeatures.h b/DataFormats/BTauReco/interface/LostTracksFeatures.h new file mode 100644 index 0000000000000..06368eb21bd68 --- /dev/null +++ b/DataFormats/BTauReco/interface/LostTracksFeatures.h @@ -0,0 +1,34 @@ +#ifndef DataFormats_BTauReco_LostTracksFeatures_h +#define DataFormats_BTauReco_LostTracksFeatures_h + +namespace btagbtvdeep { + + class LostTracksFeatures { + public: + float btagPf_trackEtaRel; + float btagPf_trackPtRel; + float btagPf_trackPPar; + float btagPf_trackDeltaR; + float btagPf_trackPParRatio; + float btagPf_trackSip2dVal; + float btagPf_trackSip2dSig; + float btagPf_trackSip3dVal; + float btagPf_trackSip3dSig; + float btagPf_trackJetDistVal; + float drminsv; + float charge; + float puppiw; + float chi2; + float quality; + float lostInnerHits; + float numberOfPixelHits; + float numberOfStripHits; + float pt; + float eta; + float phi; + float e; + }; + +} // namespace btagbtvdeep + +#endif //DataFormats_BTauReco_LostTracksFeatures_h diff --git a/DataFormats/BTauReco/interface/UnifiedParticleTransformerAK4Features.h b/DataFormats/BTauReco/interface/UnifiedParticleTransformerAK4Features.h new file mode 100644 index 0000000000000..b52b107d6e673 --- /dev/null +++ b/DataFormats/BTauReco/interface/UnifiedParticleTransformerAK4Features.h @@ -0,0 +1,25 @@ +#ifndef DataFormats_BTauReco_UnifiedParticleTransformerAK4Features_h +#define DataFormats_BTauReco_UnifiedParticleTransformerAK4Features_h + +#include "DataFormats/BTauReco/interface/SecondaryVertexFeatures.h" +#include "DataFormats/BTauReco/interface/NeutralCandidateFeatures.h" +#include "DataFormats/BTauReco/interface/ChargedCandidateFeatures.h" +#include "DataFormats/BTauReco/interface/LostTracksFeatures.h" + +#include + +namespace btagbtvdeep { + + class UnifiedParticleTransformerAK4Features { + public: + bool is_filled = true; + std::vector sv_features; + + std::vector n_pf_features; + std::vector c_pf_features; + std::vector lt_features; + }; + +} // namespace btagbtvdeep + +#endif //DataFormats_BTauReco_UnifiedParticleTransformerAK4Features_h diff --git a/DataFormats/BTauReco/interface/UnifiedParticleTransformerAK4TagInfo.h b/DataFormats/BTauReco/interface/UnifiedParticleTransformerAK4TagInfo.h new file mode 100644 index 0000000000000..67c31ff91acd2 --- /dev/null +++ b/DataFormats/BTauReco/interface/UnifiedParticleTransformerAK4TagInfo.h @@ -0,0 +1,15 @@ +#ifndef DataFormats_BTauReco_UnifiedParticleTransformerAK4TagInfo_h +#define DataFormats_BTauReco_UnifiedParticleTransformerAK4TagInfo_h + +#include "DataFormats/BTauReco/interface/UnifiedParticleTransformerAK4Features.h" +#include "DataFormats/BTauReco/interface/FeaturesTagInfo.h" + +namespace reco { + + typedef FeaturesTagInfo UnifiedParticleTransformerAK4TagInfo; + + DECLARE_EDM_REFS(UnifiedParticleTransformerAK4TagInfo) + +} // namespace reco + +#endif // DataFormats_BTauReco_UnifiedParticleTransformerAK4TagInfo_h diff --git a/DataFormats/BTauReco/src/classes.h b/DataFormats/BTauReco/src/classes.h index 49f56a9762747..01025202de2df 100644 --- a/DataFormats/BTauReco/src/classes.h +++ b/DataFormats/BTauReco/src/classes.h @@ -65,6 +65,8 @@ #include "DataFormats/BTauReco/interface/DeepDoubleXTagInfo.h" #include "DataFormats/BTauReco/interface/ParticleTransformerAK4Features.h" #include "DataFormats/BTauReco/interface/ParticleTransformerAK4TagInfo.h" +#include "DataFormats/BTauReco/interface/UnifiedParticleTransformerAK4Features.h" +#include "DataFormats/BTauReco/interface/UnifiedParticleTransformerAK4TagInfo.h" #include "DataFormats/BTauReco/interface/DeepBoostedJetTagInfo.h" #include "DataFormats/BTauReco/interface/PixelClusterTagInfo.h" diff --git a/DataFormats/BTauReco/src/classes_def.xml b/DataFormats/BTauReco/src/classes_def.xml index 148a0bda78d20..f8349694c7b67 100644 --- a/DataFormats/BTauReco/src/classes_def.xml +++ b/DataFormats/BTauReco/src/classes_def.xml @@ -329,6 +329,8 @@ + + @@ -366,6 +368,8 @@ + + @@ -427,7 +431,8 @@ - + + @@ -467,6 +472,14 @@ + + + + + + + + @@ -477,6 +490,7 @@ + diff --git a/PhysicsTools/NanoAOD/python/custom_btv_cff.py b/PhysicsTools/NanoAOD/python/custom_btv_cff.py new file mode 100644 index 0000000000000..e446c6d5492c2 --- /dev/null +++ b/PhysicsTools/NanoAOD/python/custom_btv_cff.py @@ -0,0 +1,678 @@ +import FWCore.ParameterSet.Config as cms +from PhysicsTools.NanoAOD.common_cff import Var +from PhysicsTools.NanoAOD.jetsAK4_Puppi_cff import jetPuppiTable, jetPuppiCorrFactorsNano, updatedJetsPuppi, updatedJetsPuppiWithUserData +from PhysicsTools.NanoAOD.jetsAK8_cff import fatJetTable, subJetTable +from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection +from PhysicsTools.PatAlgos.tools.helpers import addToProcessAndTask, getPatAlgosToolsTask +from PhysicsTools.NanoAOD.common_cff import Var, CandVars +from PhysicsTools.NanoAOD.simpleCandidateFlatTableProducer_cfi import simpleCandidateFlatTableProducer +from PhysicsTools.NanoAOD.btvMC_cff import allPFPFCandsMCSequence,ak4ak8PFCandsMCSequence,ak8onlyPFCandsMCSequence,ak4onlyPFCandsMCSequence +## Move PFNano (https://github.com/cms-jet/PFNano/) to NanoAOD + +## From: https://github.com/cms-jet/PFNano/blob/13_0_7_from124MiniAOD/python/addBTV.py +def update_jets_AK4(process): + # Based on ``nanoAOD_addDeepInfo`` + # in https://github.com/cms-sw/cmssw/blob/master/PhysicsTools/NanoAOD/python/nano_cff.py + # DeepJet flav_names as found in + # https://github.com/cms-sw/cmssw/blob/master/RecoBTag/ONNXRuntime/plugins/DeepFlavourONNXJetTagsProducer.cc#L86 + # and https://twiki.cern.ch/twiki/bin/view/CMS/DeepJet + from RecoBTag.ONNXRuntime.pfParticleTransformerAK4_cff import _pfParticleTransformerAK4JetTagsAll as pfParticleTransformerAK4JetTagsAll + from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK4_cff import _pfParticleNetFromMiniAODAK4PuppiCentralJetTagsAll as pfParticleNetFromMiniAODAK4PuppiCentralJetTagsAll + from RecoBTag.ONNXRuntime.pfParticleTransformerAK4_cff import _pfNegativeParticleTransformerAK4JetTagsProbs as pfNegativeParticleTransformerAK4JetTagsProbs + from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK4_cff import _pfNegativeParticleNetFromMiniAODAK4PuppiCentralJetTagsProbs as pfNegativeParticleNetFromMiniAODAK4PuppiCentralJetTagsProbs + + _btagDiscriminators = [ + 'pfJetProbabilityBJetTags', + 'pfJetBProbabilityBJetTags', + 'pfNegativeOnlyJetProbabilityBJetTags', + 'pfNegativeOnlyJetBProbabilityBJetTags', + 'pfDeepFlavourJetTags:probb', + 'pfDeepFlavourJetTags:probbb', + 'pfDeepFlavourJetTags:problepb', + 'pfDeepFlavourJetTags:probc', + 'pfDeepFlavourJetTags:probuds', + 'pfDeepFlavourJetTags:probg', + 'pfNegativeDeepFlavourJetTags:probb', + 'pfNegativeDeepFlavourJetTags:probbb', + 'pfNegativeDeepFlavourJetTags:problepb', + 'pfNegativeDeepFlavourJetTags:probc', + 'pfNegativeDeepFlavourJetTags:probuds', + 'pfNegativeDeepFlavourJetTags:probg', + ] + pfParticleNetFromMiniAODAK4PuppiCentralJetTagsAll + pfNegativeParticleNetFromMiniAODAK4PuppiCentralJetTagsProbs + # \ #+ pfParticleTransformerAK4JetTagsAll + pfNegativeParticleTransformerAK4JetTagsProbs \ + + updateJetCollection( + process, + jetSource=cms.InputTag('slimmedJetsPuppi'), + jetCorrections=('AK4PFPuppi', + cms.vstring( + ['L1FastJet', 'L2Relative', 'L3Absolute', + 'L2L3Residual']), 'None'), + btagDiscriminators=_btagDiscriminators, + postfix='PuppiWithDeepInfo', + ) + process.load("Configuration.StandardSequences.MagneticField_cff") + process.jetPuppiCorrFactorsNano.src = "selectedUpdatedPatJetsPuppiWithDeepInfo" + process.updatedJetsPuppi.jetSource = "selectedUpdatedPatJetsPuppiWithDeepInfo" + + + process.updatedPatJetsTransientCorrectedPuppiWithDeepInfo.tagInfoSources.append(cms.InputTag("pfDeepFlavourTagInfosPuppiWithDeepInfo")) + process.updatedPatJetsTransientCorrectedPuppiWithDeepInfo.addTagInfos = cms.bool(True) + + + + return process + +def update_jets_AK8(process): + # Based on ``nanoAOD_addDeepInfoAK8`` + # in https://github.com/cms-sw/cmssw/blob/master/PhysicsTools/NanoAOD/python/nano_cff.py + # Care needs to be taken to make sure no discriminators from stock Nano are excluded -> would results in unfilled vars + _btagDiscriminators = [ + 'pfMassIndependentDeepDoubleBvLV2JetTags:probHbb', + 'pfMassIndependentDeepDoubleCvLV2JetTags:probHcc', + 'pfMassIndependentDeepDoubleCvBV2JetTags:probHcc', + ] + from RecoBTag.ONNXRuntime.pfParticleNet_cff import _pfParticleNetJetTagsAll as pfParticleNetJetTagsAll + _btagDiscriminators += pfParticleNetJetTagsAll + updateJetCollection( + process, + jetSource=cms.InputTag('slimmedJetsAK8'), + pvSource=cms.InputTag('offlineSlimmedPrimaryVertices'), + svSource=cms.InputTag('slimmedSecondaryVertices'), + rParam=0.8, + jetCorrections=('AK8PFPuppi', + cms.vstring([ + 'L1FastJet', 'L2Relative', 'L3Absolute', + 'L2L3Residual' + ]), 'None'), + btagDiscriminators=_btagDiscriminators, + postfix='AK8WithDeepInfo', + # this should work but doesn't seem to enable the tag info with addTagInfos + # btagInfos=['pfDeepDoubleXTagInfos'], + printWarning=False) + process.jetCorrFactorsAK8.src = "selectedUpdatedPatJetsAK8WithDeepInfo" + process.updatedJetsAK8.jetSource = "selectedUpdatedPatJetsAK8WithDeepInfo" + # add DeepDoubleX taginfos + process.updatedPatJetsTransientCorrectedAK8WithDeepInfo.tagInfoSources.append(cms.InputTag("pfDeepDoubleXTagInfosAK8WithDeepInfo")) + process.updatedPatJetsTransientCorrectedAK8WithDeepInfo.addTagInfos = cms.bool(True) + return process + +def update_jets_AK8_subjet(process): + # Based on ``nanoAOD_addDeepInfoAK8`` + # in https://github.com/cms-sw/cmssw/blob/master/PhysicsTools/NanoAOD/python/nano_cff.py + # and https://github.com/alefisico/RecoBTag-PerformanceMeasurements/blob/10_2_X_boostedCommissioning/test/runBTagAnalyzer_cfg.py + _btagDiscriminators = [ + 'pfJetProbabilityBJetTags', + 'pfDeepCSVJetTags:probb', + 'pfDeepCSVJetTags:probc', + 'pfDeepCSVJetTags:probbb', + 'pfDeepCSVJetTags:probudsg', + ] + updateJetCollection( + process, + labelName='SoftDropSubjetsPF', + jetSource=cms.InputTag("slimmedJetsAK8PFPuppiSoftDropPacked", "SubJets"), + jetCorrections=('AK4PFPuppi', + ['L2Relative', 'L3Absolute'], 'None'), + btagDiscriminators=list(_btagDiscriminators), + explicitJTA=True, # needed for subjet b tagging + svClustering=False, # needed for subjet b tagging (IMPORTANT: Needs to be set to False to disable ghost-association which does not work with slimmed jets) + fatJets=cms.InputTag('slimmedJetsAK8'), # needed for subjet b tagging + rParam=0.8, # needed for subjet b tagging + sortByPt=False, # Don't change order (would mess with subJetIdx for FatJets) + postfix='AK8SubjetsWithDeepInfo') + + process.subJetTable.src = 'selectedUpdatedPatJetsSoftDropSubjetsPFAK8SubjetsWithDeepInfo' + + + return process + +def get_DDX_vars(): + # retreive 27 jet-level features used in double-b and deep double-x taggers + # defined in arXiv:1712.07158 + DDXVars = cms.PSet( + DDX_jetNTracks = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.jetNTracks", int, doc="number of tracks associated with the jet"), + DDX_jetNSecondaryVertices = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.jetNSecondaryVertices", int, doc="number of SVs associated with the jet"), + DDX_tau1_trackEtaRel_0 = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.tau1_trackEtaRel_0", float, doc="1st smallest track pseudorapidity, relative to the jet axis, associated to the 1st N-subjettiness axis", precision=10), + DDX_tau1_trackEtaRel_1 = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.tau1_trackEtaRel_1", float, doc="2nd smallest track pseudorapidity, relative to the jet axis, associated to the 1st N-subjettiness axis", precision=10), + DDX_tau1_trackEtaRel_2 = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.tau1_trackEtaRel_2", float, doc="3rd smallest track pseudorapidity, relative to the jet axis, associated to the 1st N-subjettiness axis", precision=10), + DDX_tau2_trackEtaRel_0 = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.tau2_trackEtaRel_0", float, doc="1st smallest track pseudorapidity, relative to the jet axis, associated to the 2nd N-subjettiness axis", precision=10), + DDX_tau2_trackEtaRel_1 = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.tau2_trackEtaRel_1", float, doc="2nd smallest track pseudorapidity, relative to the jet axis, associated to the 2nd N-subjettiness axis", precision=10), + DDX_tau2_trackEtaRel_3 = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.tau2_trackEtaRel_2", float, doc="3rd smallest track pseudorapidity, relative to the jet axis, associated to the 2nd N-subjettiness axis", precision=10), + DDX_tau1_flightDistance2dSig = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.tau1_flightDistance2dSig", float, doc="transverse distance significance between primary and secondary vertex associated to the 1st N-subjettiness axis", precision=10), + DDX_tau2_flightDistance2dSig = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.tau2_flightDistance2dSig", float, doc="transverse distance significance between primary and secondary vertex associated to the 2nd N-subjettiness axis", precision=10), + DDX_tau1_vertexDeltaR = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.tau1_vertexDeltaR", float, doc="deltaR between the 1st N-subjettiness axis and secondary vertex direction", precision=10), + DDX_tau1_vertexEnergyRatio = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.tau1_vertexEnergyRatio", float, doc="ratio of energy at secondary vertex over total energy associated to the 1st N-subjettiness axis", precision=10), + DDX_tau2_vertexEnergyRatio = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.tau2_vertexEnergyRatio", float, doc="ratio of energy at secondary vertex over total energy associated to the 2nd N-subjettiness axis", precision=10), + DDX_tau1_vertexMass = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.tau1_vertexMass", float, doc="mass of track sum at secondary vertex associated to the 1st N-subjettiness axis", precision=10), + DDX_tau2_vertexMass = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.tau2_vertexMass", float, doc="mass of track sum at secondary vertex associated to the 2nd N-subjettiness axis", precision=10), + DDX_trackSip2dSigAboveBottom_0 = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.trackSip2dSigAboveBottom_0", float, doc="track 2D signed impact parameter significance of 1st track lifting mass above bottom", precision=10), + DDX_trackSip2dSigAboveBottom_1 = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.trackSip2dSigAboveBottom_1", float, doc="track 2D signed impact parameter significance of 2nd track lifting mass above bottom", precision=10), + DDX_trackSip2dSigAboveCharm = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.trackSip2dSigAboveCharm", float, doc="track 2D signed impact parameter significance of 1st track lifting mass above charm", precision=10), + DDX_trackSip3dSig_0 = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.trackSip3dSig_0", float, doc="1st largest track 3D signed impact parameter significance", precision=10), + DDX_tau1_trackSip3dSig_0 = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.tau1_trackSip3dSig_0", float, doc="1st largest track 3D signed impact parameter significance associated to the 1st N-subjettiness axis", precision=10), + DDX_tau1_trackSip3dSig_1 = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.tau1_trackSip3dSig_1", float, doc="2nd largest track 3D signed impact parameter significance associated to the 1st N-subjettiness axis", precision=10), + DDX_trackSip3dSig_1 = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.trackSip3dSig_1", float, doc="2nd largest track 3D signed impact parameter significance", precision=10), + DDX_tau2_trackSip3dSig_0 = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.tau2_trackSip3dSig_0", float, doc="1st largest track 3D signed impact parameter significance associated to the 2nd N-subjettiness axis", precision=10), + DDX_tau2_trackSip3dSig_1 = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.tau2_trackSip3dSig_1", float, doc="2nd largest track 3D signed impact parameter significance associated to the 2nd N-subjettiness axis", precision=10), + DDX_trackSip3dSig_2 = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.trackSip3dSig_2", float, doc="3rd largest track 3D signed impact parameter significance", precision=10), + DDX_trackSip3dSig_3 = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.trackSip3dSig_3", float, doc="4th largest track 3D signed impact parameter significance", precision=10), + DDX_z_ratio = Var("tagInfo(\'pfDeepDoubleX\').features().tag_info_features.z_ratio", float, doc="z = deltaR(SV0,SV1)*pT(SV1)/m(SV0,SV1), defined in Eq. 7 of arXiv:1712.07158", precision=10) + ) + return DDXVars + +def get_DeepCSV_vars(): + DeepCSVVars = cms.PSet( + # Tagger inputs also include jet pt and eta + # Track based (keep only jet-based features for DeepCSV from Run 3 commissioning) + # DeepCSV_trackPtRel_0 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackPtRel\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackPtRel\')[0]:-999", float, doc="track transverse momentum, relative to the jet axis", precision=10), + # DeepCSV_trackPtRel_1 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackPtRel\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackPtRel\')[1]:-999", float, doc="track transverse momentum, relative to the jet axis", precision=10), + # DeepCSV_trackPtRel_2 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackPtRel\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackPtRel\')[2]:-999", float, doc="track transverse momentum, relative to the jet axis", precision=10), + # DeepCSV_trackPtRel_3 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackPtRel\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackPtRel\')[3]:-999", float, doc="track transverse momentum, relative to the jet axis", precision=10), + # DeepCSV_trackPtRel_4 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackPtRel\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackPtRel\')[4]:-999", float, doc="track transverse momentum, relative to the jet axis", precision=10), + # DeepCSV_trackPtRel_5 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackPtRel\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackPtRel\')[5]:-999", float, doc="track transverse momentum, relative to the jet axis", precision=10), + # DeepCSV_trackJetDistVal_0 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackJetDistVal\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackJetDistVal\')[0]:-999", float, doc="minimum track approach distance to jet axis", precision=10), + # DeepCSV_trackJetDistVal_1 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackJetDistVal\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackJetDistVal\')[1]:-999", float, doc="minimum track approach distance to jet axis", precision=10), + # DeepCSV_trackJetDistVal_2 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackJetDistVal\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackJetDistVal\')[2]:-999", float, doc="minimum track approach distance to jet axis", precision=10), + # DeepCSV_trackJetDistVal_3 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackJetDistVal\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackJetDistVal\')[3]:-999", float, doc="minimum track approach distance to jet axis", precision=10), + # DeepCSV_trackJetDistVal_4 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackJetDistVal\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackJetDistVal\')[4]:-999", float, doc="minimum track approach distance to jet axis", precision=10), + # DeepCSV_trackJetDistVal_5 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackJetDistVal\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackJetDistVal\')[5]:-999", float, doc="minimum track approach distance to jet axis", precision=10), + # DeepCSV_trackDeltaR_0 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackDeltaR\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackDeltaR\')[0]:-999", float, doc="track pseudoangular distance from the jet axis", precision=10), + # DeepCSV_trackDeltaR_1 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackDeltaR\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackDeltaR\')[1]:-999", float, doc="track pseudoangular distance from the jet axis", precision=10), + # DeepCSV_trackDeltaR_2 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackDeltaR\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackDeltaR\')[2]:-999", float, doc="track pseudoangular distance from the jet axis", precision=10), + # DeepCSV_trackDeltaR_3 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackDeltaR\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackDeltaR\')[3]:-999", float, doc="track pseudoangular distance from the jet axis", precision=10), + # DeepCSV_trackDeltaR_4 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackDeltaR\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackDeltaR\')[4]:-999", float, doc="track pseudoangular distance from the jet axis", precision=10), + # DeepCSV_trackDeltaR_5 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackDeltaR\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackDeltaR\')[5]:-999", float, doc="track pseudoangular distance from the jet axis", precision=10), + # DeepCSV_trackPtRatio_0 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackPtRatio\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackPtRatio\')[0]:-999", float, doc="track transverse momentum, relative to the jet axis, normalized to its energy", precision=10), + # DeepCSV_trackPtRatio_1 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackPtRatio\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackPtRatio\')[1]:-999", float, doc="track transverse momentum, relative to the jet axis, normalized to its energy", precision=10), + # DeepCSV_trackPtRatio_2 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackPtRatio\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackPtRatio\')[2]:-999", float, doc="track transverse momentum, relative to the jet axis, normalized to its energy", precision=10), + # DeepCSV_trackPtRatio_3 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackPtRatio\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackPtRatio\')[3]:-999", float, doc="track transverse momentum, relative to the jet axis, normalized to its energy", precision=10), + # DeepCSV_trackPtRatio_4 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackPtRatio\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackPtRatio\')[4]:-999", float, doc="track transverse momentum, relative to the jet axis, normalized to its energy", precision=10), + # DeepCSV_trackPtRatio_5 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackPtRatio\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackPtRatio\')[5]:-999", float, doc="track transverse momentum, relative to the jet axis, normalized to its energy", precision=10), + # DeepCSV_trackSip3dSig_0 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackSip3dSig\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackSip3dSig\')[0]:-999", float, doc="track 3D signed impact parameter significance", precision=10), + # DeepCSV_trackSip3dSig_1 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackSip3dSig\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackSip3dSig\')[1]:-999", float, doc="track 3D signed impact parameter significance", precision=10), + # DeepCSV_trackSip3dSig_2 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackSip3dSig\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackSip3dSig\')[2]:-999", float, doc="track 3D signed impact parameter significance", precision=10), + # DeepCSV_trackSip3dSig_3 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackSip3dSig\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackSip3dSig\')[3]:-999", float, doc="track 3D signed impact parameter significance", precision=10), + # DeepCSV_trackSip3dSig_4 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackSip3dSig\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackSip3dSig\')[4]:-999", float, doc="track 3D signed impact parameter significance", precision=10), + # DeepCSV_trackSip3dSig_5 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackSip3dSig\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackSip3dSig\')[5]:-999", float, doc="track 3D signed impact parameter significance", precision=10), + # DeepCSV_trackSip2dSig_0 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackSip2dSig\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackSip2dSig\')[0]:-999", float, doc="track 2D signed impact parameter significance", precision=10), + # DeepCSV_trackSip2dSig_1 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackSip2dSig\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackSip2dSig\')[1]:-999", float, doc="track 2D signed impact parameter significance", precision=10), + # DeepCSV_trackSip2dSig_2 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackSip2dSig\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackSip2dSig\')[2]:-999", float, doc="track 2D signed impact parameter significance", precision=10), + # DeepCSV_trackSip2dSig_3 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackSip2dSig\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackSip2dSig\')[3]:-999", float, doc="track 2D signed impact parameter significance", precision=10), + # DeepCSV_trackSip2dSig_4 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackSip2dSig\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackSip2dSig\')[4]:-999", float, doc="track 2D signed impact parameter significance", precision=10), + # DeepCSV_trackSip2dSig_5 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackSip2dSig\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackSip2dSig\')[5]:-999", float, doc="track 2D signed impact parameter significance", precision=10), + # DeepCSV_trackDecayLenVal_0 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackDecayLenVal\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackDecayLenVal\')[0]:-999", float, doc="track decay length", precision=10), + # DeepCSV_trackDecayLenVal_1 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackDecayLenVal\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackDecayLenVal\')[1]:-999", float, doc="track decay length", precision=10), + # DeepCSV_trackDecayLenVal_2 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackDecayLenVal\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackDecayLenVal\')[2]:-999", float, doc="track decay length", precision=10), + # DeepCSV_trackDecayLenVal_3 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackDecayLenVal\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackDecayLenVal\')[3]:-999", float, doc="track decay length", precision=10), + # DeepCSV_trackDecayLenVal_4 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackDecayLenVal\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackDecayLenVal\')[4]:-999", float, doc="track decay length", precision=10), + # DeepCSV_trackDecayLenVal_5 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackDecayLenVal\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackDecayLenVal\')[5]:-999", float, doc="track decay length", precision=10), + # DeepCSV_trackEtaRel_0 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackEtaRel\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackEtaRel\')[0]:-999", float, doc="track pseudorapidity, relative to the jet axis", precision=10), + # DeepCSV_trackEtaRel_1 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackEtaRel\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackEtaRel\')[1]:-999", float, doc="track pseudorapidity, relative to the jet axis", precision=10), + # DeepCSV_trackEtaRel_2 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackEtaRel\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackEtaRel\')[2]:-999", float, doc="track pseudorapidity, relative to the jet axis", precision=10), + # DeepCSV_trackEtaRel_3 = Var("?tagInfo(\'pfDeepCSV\').taggingVariables.checkTag(\'trackEtaRel\')?tagInfo(\'pfDeepCSV\').taggingVariables.getList(\'trackEtaRel\')[3]:-999", float, doc="track pseudorapidity, relative to the jet axis", precision=10), + # Jet based + DeepCSV_trackJetPt = Var("tagInfo(\'pfDeepCSV\').taggingVariables.get(\'trackJetPt\', -999)", float, doc="track-based jet transverse momentum", precision=10), + DeepCSV_vertexCategory = Var("tagInfo(\'pfDeepCSV\').taggingVariables.get(\'vertexCategory\', -999)", float, doc="category of secondary vertex (Reco, Pseudo, No)", precision=10), + DeepCSV_jetNSecondaryVertices = Var("tagInfo(\'pfDeepCSV\').taggingVariables.get(\'jetNSecondaryVertices\', -999)", int, doc="number of reconstructed possible secondary vertices in jet"), + DeepCSV_jetNSelectedTracks = Var("tagInfo(\'pfDeepCSV\').taggingVariables.get(\'jetNSelectedTracks\', -999)", int, doc="selected tracks in the jet"), + DeepCSV_jetNTracksEtaRel = Var("tagInfo(\'pfDeepCSV\').taggingVariables.get(\'jetNTracksEtaRel\', -999)", int, doc="number of tracks for which etaRel is computed"), + DeepCSV_trackSumJetEtRatio = Var("tagInfo(\'pfDeepCSV\').taggingVariables.get(\'trackSumJetEtRatio\', -999)", float, doc="ratio of track sum transverse energy over jet energy", precision=10), + DeepCSV_trackSumJetDeltaR = Var("tagInfo(\'pfDeepCSV\').taggingVariables.get(\'trackSumJetDeltaR\', -999)", float, doc="pseudoangular distance between jet axis and track fourvector sum", precision=10), + DeepCSV_trackSip2dValAboveCharm = Var("tagInfo(\'pfDeepCSV\').taggingVariables.get(\'trackSip2dValAboveCharm\', -999)", float, doc="track 2D signed impact parameter of first track lifting mass above charm", precision=10), + DeepCSV_trackSip2dSigAboveCharm = Var("tagInfo(\'pfDeepCSV\').taggingVariables.get(\'trackSip2dSigAboveCharm\', -999)", float, doc="track 2D signed impact parameter significance of first track lifting mass above charm", precision=10), + DeepCSV_trackSip3dValAboveCharm = Var("tagInfo(\'pfDeepCSV\').taggingVariables.get(\'trackSip3dValAboveCharm\', -999)", float, doc="track 3D signed impact parameter of first track lifting mass above charm", precision=10), + DeepCSV_trackSip3dSigAboveCharm = Var("tagInfo(\'pfDeepCSV\').taggingVariables.get(\'trackSip3dSigAboveCharm\', -999)", float, doc="track 3D signed impact parameter significance of first track lifting mass above charm", precision=10), + DeepCSV_vertexMass = Var("tagInfo(\'pfDeepCSV\').taggingVariables.get(\'vertexMass\', -999)", float, doc="mass of track sum at secondary vertex", precision=10), + DeepCSV_vertexNTracks = Var("tagInfo(\'pfDeepCSV\').taggingVariables.get(\'vertexNTracks\', -999)", int, doc="number of tracks at secondary vertex"), + DeepCSV_vertexEnergyRatio = Var("tagInfo(\'pfDeepCSV\').taggingVariables.get(\'vertexEnergyRatio\', -999)", float, doc="ratio of energy at secondary vertex over total energy", precision=10), + DeepCSV_vertexJetDeltaR = Var("tagInfo(\'pfDeepCSV\').taggingVariables.get(\'vertexJetDeltaR\', -999)", float, doc="pseudoangular distance between jet axis and secondary vertex direction", precision=10), + DeepCSV_flightDistance2dVal = Var("tagInfo(\'pfDeepCSV\').taggingVariables.get(\'flightDistance2dVal\', -999)", float, doc="transverse distance between primary and secondary vertex", precision=10), + DeepCSV_flightDistance2dSig = Var("tagInfo(\'pfDeepCSV\').taggingVariables.get(\'flightDistance2dSig\', -999)", float, doc="transverse distance significance between primary and secondary vertex", precision=10), + DeepCSV_flightDistance3dVal = Var("tagInfo(\'pfDeepCSV\').taggingVariables.get(\'flightDistance3dVal\', -999)", float, doc="distance between primary and secondary vertex", precision=10), + DeepCSV_flightDistance3dSig = Var("tagInfo(\'pfDeepCSV\').taggingVariables.get(\'flightDistance3dSig\', -999)", float, doc="distance significance between primary and secondary vertex", precision=10), + ) + return DeepCSVVars + +## Store all output nodes, negative tagger for SF +def get_DeepJet_outputs(): + DeepJetOutputVars = cms.PSet( + btagDeepFlavB_b=Var("bDiscriminator('pfDeepFlavourJetTags:probb')", + float, + doc="DeepJet b tag probability", + precision=10), + btagDeepFlavB_bb=Var("bDiscriminator('pfDeepFlavourJetTags:probbb')", + float, + doc="DeepJet bb tag probability", + precision=10), + btagDeepFlavB_lepb=Var("bDiscriminator('pfDeepFlavourJetTags:problepb')", + float, + doc="DeepJet lepb tag probability", + precision=10), + btagDeepFlavC=Var("bDiscriminator('pfDeepFlavourJetTags:probc')", + float, + doc="DeepJet c tag probability", + precision=10), + btagDeepFlavUDS=Var("bDiscriminator('pfDeepFlavourJetTags:probuds')", + float, + doc="DeepJet uds tag probability", + precision=10), + btagDeepFlavG=Var("bDiscriminator('pfDeepFlavourJetTags:probg')", + float, + doc="DeepJet gluon tag probability", + precision=10), + # discriminators are already part of jets_cff.py from NanoAOD and therefore not added here + + # negative taggers + btagNegDeepFlavB = Var("bDiscriminator('pfNegativeDeepFlavourJetTags:probb')+bDiscriminator('pfNegativeDeepFlavourJetTags:probbb')+bDiscriminator('pfNegativeDeepFlavourJetTags:problepb')", + float, + doc="Negative DeepJet b+bb+lepb tag discriminator", + precision=10), + btagNegDeepFlavCvL = Var("?(bDiscriminator('pfNegativeDeepFlavourJetTags:probc')+bDiscriminator('pfNegativeDeepFlavourJetTags:probuds')+bDiscriminator('pfNegativeDeepFlavourJetTags:probg'))>0?bDiscriminator('pfNegativeDeepFlavourJetTags:probc')/(bDiscriminator('pfNegativeDeepFlavourJetTags:probc')+bDiscriminator('pfNegativeDeepFlavourJetTags:probuds')+bDiscriminator('pfNegativeDeepFlavourJetTags:probg')):-1", + float, + doc="Negative DeepJet c vs uds+g discriminator", + precision=10), + btagNegDeepFlavCvB = Var("?(bDiscriminator('pfNegativeDeepFlavourJetTags:probc')+bDiscriminator('pfNegativeDeepFlavourJetTags:probb')+bDiscriminator('pfNegativeDeepFlavourJetTags:probbb')+bDiscriminator('pfNegativeDeepFlavourJetTags:problepb'))>0?bDiscriminator('pfNegativeDeepFlavourJetTags:probc')/(bDiscriminator('pfNegativeDeepFlavourJetTags:probc')+bDiscriminator('pfNegativeDeepFlavourJetTags:probb')+bDiscriminator('pfNegativeDeepFlavourJetTags:probbb')+bDiscriminator('pfNegativeDeepFlavourJetTags:problepb')):-1", + float, + doc="Negative DeepJet c vs b+bb+lepb discriminator", + precision=10), + btagNegDeepFlavQG = Var("?(bDiscriminator('pfNegativeDeepFlavourJetTags:probg')+bDiscriminator('pfNegativeDeepFlavourJetTags:probuds'))>0?bDiscriminator('pfNegativeDeepFlavourJetTags:probg')/(bDiscriminator('pfNegativeDeepFlavourJetTags:probg')+bDiscriminator('pfNegativeDeepFlavourJetTags:probuds')):-1", + float, + doc="Negative DeepJet g vs uds discriminator", + precision=10), + btagNegDeepFlavB_b = Var("bDiscriminator('pfNegativeDeepFlavourJetTags:probb')", + float, + doc="Negative DeepJet b tag probability", + precision=10), + btagNegDeepFlavB_bb = Var("bDiscriminator('pfNegativeDeepFlavourJetTags:probbb')", + float, + doc="Negative DeepJet bb tag probability", + precision=10), + btagNegDeepFlavB_lepb = Var("bDiscriminator('pfNegativeDeepFlavourJetTags:problepb')", + float, + doc="Negative DeepJet lepb tag probability", + precision=10), + btagNegDeepFlavC = Var("bDiscriminator('pfNegativeDeepFlavourJetTags:probc')", + float, + doc="Negative DeepJet c tag probability", + precision=10), + btagNegDeepFlavUDS = Var("bDiscriminator('pfNegativeDeepFlavourJetTags:probuds')", + float, + doc="Negative DeepJet uds tag probability", + precision=10), + btagNegDeepFlavG = Var("bDiscriminator('pfNegativeDeepFlavourJetTags:probg')", + float, + doc="Negative DeepJet gluon tag probability", + precision=10), + ) + return DeepJetOutputVars + +def get_ParticleNetAK4_outputs(): + ## default scores in jetAK4_Puppi_cff.py collections + ParticleNetAK4OutputVars = cms.PSet( + # raw scores + btagPNetProbB = Var("?bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralJetTags:probb')>0?bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralJetTags:probb'):-1", + float, + doc="ParticleNet b tag probability", + precision=10), + btagPNetProbC = Var("?bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralJetTags:probc')>0?bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralJetTags:probc'):-1", + float, + doc="ParticleNet c tag probability", + precision=10), + btagPNetProbUDS = Var("?bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralJetTags:probuds')>0?bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralJetTags:probuds'):-1", + float, + doc="ParticleNet uds tag probability", + precision=10), + btagPNetProbG = Var("?bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralJetTags:probg')>0?bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralJetTags:probg'):-1", + float, + doc="ParticleNet gluon tag probability", + precision=10), + + # negative taggers + btagNegPNetB = Var("?(bDiscriminator('pfNegativeParticleNetFromMiniAODAK4PuppiCentralJetTags:probb')+bDiscriminator('pfNegativeParticleNetFromMiniAODAK4PuppiCentralJetTags:probc')+bDiscriminator('pfNegativeParticleNetFromMiniAODAK4PuppiCentralJetTags:probuds')+bDiscriminator('pfNegativeParticleNetFromMiniAODAK4PuppiCentralJetTags:probg'))>0?(bDiscriminator('pfNegativeParticleNetFromMiniAODAK4PuppiCentralJetTags:probb'))/(bDiscriminator('pfNegativeParticleNetFromMiniAODAK4PuppiCentralJetTags:probb')+bDiscriminator('pfNegativeParticleNetFromMiniAODAK4PuppiCentralJetTags:probc')+bDiscriminator('pfNegativeParticleNetFromMiniAODAK4PuppiCentralJetTags:probuds')+bDiscriminator('pfNegativeParticleNetFromMiniAODAK4PuppiCentralJetTags:probg')):-1", + float, + doc="Negative ParticleNet b vs. udscg", + precision=10), + btagNegPNetCvL = Var("?(bDiscriminator('pfNegativeParticleNetFromMiniAODAK4PuppiCentralJetTags:probc')+bDiscriminator('pfNegativeParticleNetFromMiniAODAK4PuppiCentralJetTags:probuds')+bDiscriminator('pfNegativeParticleNetFromMiniAODAK4PuppiCentralJetTags:probg'))>0?(bDiscriminator('pfNegativeParticleNetFromMiniAODAK4PuppiCentralJetTags:probc'))/(bDiscriminator('pfNegativeParticleNetFromMiniAODAK4PuppiCentralJetTags:probc')+bDiscriminator('pfNegativeParticleNetFromMiniAODAK4PuppiCentralJetTags:probuds')+bDiscriminator('pfNegativeParticleNetFromMiniAODAK4PuppiCentralJetTags:probg')):-1", + float, + doc="Negative ParticleNet c vs. udsg", + precision=10), + btagNegPNetCvB = Var("?(bDiscriminator('pfNegativeParticleNetFromMiniAODAK4PuppiCentralJetTags:probc')+bDiscriminator('pfNegativeParticleNetFromMiniAODAK4PuppiCentralJetTags:probb'))>0?(bDiscriminator('pfNegativeParticleNetFromMiniAODAK4PuppiCentralJetTags:probc'))/(bDiscriminator('pfNegativeParticleNetFromMiniAODAK4PuppiCentralJetTags:probc')+bDiscriminator('pfNegativeParticleNetFromMiniAODAK4PuppiCentralJetTags:probb')):-1", + float, + doc="Negative ParticleNet c vs. b", + precision=10), + btagNegPNetProbB = Var("?bDiscriminator('pfNegativeParticleNetFromMiniAODAK4PuppiCentralJetTags:probb')>0?bDiscriminator('pfNegativeParticleNetFromMiniAODAK4PuppiCentralJetTags:probb'):-1", + float, + doc="Negative ParticleNet b tag probability", + precision=10), + btagNegPNetProbC = Var("?bDiscriminator('pfNegativeParticleNetFromMiniAODAK4PuppiCentralJetTags:probc')>0?bDiscriminator('pfNegativeParticleNetFromMiniAODAK4PuppiCentralJetTags:probc'):-1", + float, + doc="Negative ParticleNet c tag probability", + precision=10), + btagNegPNetProbUDS = Var("?bDiscriminator('pfNegativeParticleNetFromMiniAODAK4PuppiCentralJetTags:probuds')>0?bDiscriminator('pfNegativeParticleNetFromMiniAODAK4PuppiCentralJetTags:probuds'):-1", + float, + doc="Negative ParticleNet uds tag probability", + precision=10), + btagNegPNetProbG = Var("?bDiscriminator('pfNegativeParticleNetFromMiniAODAK4PuppiCentralJetTags:probg')>0?bDiscriminator('pfNegativeParticleNetFromMiniAODAK4PuppiCentralJetTags:probg'):-1", + float, + doc="Negative ParticleNet gluon tag probability", + precision=10), + ) + + return ParticleNetAK4OutputVars + +def get_ParticleTransformerAK4_outputs(): + ParticleTransformerAK4OutputVars = cms.PSet( + btagRobustParTAK4B_b=Var("bDiscriminator('pfParticleTransformerAK4JetTags:probb')", + float, + doc="RobustParTAK4 b tag probability", + precision=10), + btagRobustParTAK4B_bb=Var("bDiscriminator('pfParticleTransformerAK4JetTags:probbb')", + float, + doc="RobustParTAK4 bb tag probability", + precision=10), + btagRobustParTAK4B_lepb=Var("bDiscriminator('pfParticleTransformerAK4JetTags:problepb')", + float, + doc="RobustParTAK4 lepb tag probability", + precision=10), + btagRobustParTAK4C=Var("bDiscriminator('pfParticleTransformerAK4JetTags:probc')", + float, + doc="RobustParTAK4 c tag probability", + precision=10), + btagRobustParTAK4UDS=Var("bDiscriminator('pfParticleTransformerAK4JetTags:probuds')", + float, + doc="RobustParTAK4 uds tag probability", + precision=10), + btagRobustParTAK4G=Var("bDiscriminator('pfParticleTransformerAK4JetTags:probg')", + float, + doc="RobustParTAK4 gluon tag probability", + precision=10), + + # negative taggers + btagNegRobustParTAK4B = Var("bDiscriminator('pfNegativeParticleTransformerAK4JetTags:probb')+bDiscriminator('pfNegativeParticleTransformerAK4JetTags:probbb')+bDiscriminator('pfNegativeParticleTransformerAK4JetTags:problepb')", + float, + doc="Negative RobustParTAK4 b+bb+lepb tag discriminator", + precision=10), + btagNegRobustParTAK4CvL = Var("?(bDiscriminator('pfNegativeParticleTransformerAK4JetTags:probc')+bDiscriminator('pfNegativeParticleTransformerAK4JetTags:probuds')+bDiscriminator('pfNegativeParticleTransformerAK4JetTags:probg'))>0?bDiscriminator('pfNegativeParticleTransformerAK4JetTags:probc')/(bDiscriminator('pfNegativeParticleTransformerAK4JetTags:probc')+bDiscriminator('pfNegativeParticleTransformerAK4JetTags:probuds')+bDiscriminator('pfNegativeParticleTransformerAK4JetTags:probg')):-1", + float, + doc="Negative RobustParTAK4 c vs uds+g discriminator", + precision=10), + btagNegRobustParTAK4CvB = Var("?(bDiscriminator('pfNegativeParticleTransformerAK4JetTags:probc')+bDiscriminator('pfNegativeParticleTransformerAK4JetTags:probb')+bDiscriminator('pfNegativeParticleTransformerAK4JetTags:probbb')+bDiscriminator('pfNegativeParticleTransformerAK4JetTags:problepb'))>0?bDiscriminator('pfNegativeParticleTransformerAK4JetTags:probc')/(bDiscriminator('pfNegativeParticleTransformerAK4JetTags:probc')+bDiscriminator('pfNegativeParticleTransformerAK4JetTags:probb')+bDiscriminator('pfNegativeParticleTransformerAK4JetTags:probbb')+bDiscriminator('pfNegativeParticleTransformerAK4JetTags:problepb')):-1", + float, + doc="Negative RobustParTAK4 c vs b+bb+lepb discriminator", + precision=10), + btagNegRobustParTAK4QG = Var("?(bDiscriminator('pfNegativeParticleTransformerAK4JetTags:probg')+bDiscriminator('pfNegativeParticleTransformerAK4JetTags:probuds'))>0?bDiscriminator('pfNegativeParticleTransformerAK4JetTags:probg')/(bDiscriminator('pfNegativeParticleTransformerAK4JetTags:probg')+bDiscriminator('pfNegativeParticleTransformerAK4JetTags:probuds')):-1", + float, + doc="Negative RobustParTAK4 g vs uds discriminator", + precision=10), + btagNegRobustParTAK4B_b = Var("bDiscriminator('pfNegativeParticleTransformerAK4JetTags:probb')", + float, + doc="Negative RobustParTAK4 b tag probability", + precision=10), + btagNegRobustParTAK4B_bb = Var("bDiscriminator('pfNegativeParticleTransformerAK4JetTags:probbb')", + float, + doc="Negative RobustParTAK4 bb tag probability", + precision=10), + btagNegRobustParTAK4B_lepb = Var("bDiscriminator('pfNegativeParticleTransformerAK4JetTags:problepb')", + float, + doc="Negative RobustParTAK4 lepb tag probability", + precision=10), + btagNegRobustParTAK4C = Var("bDiscriminator('pfNegativeParticleTransformerAK4JetTags:probc')", + float, + doc="Negative RobustParTAK4 c tag probability", + precision=10), + btagNegRobustParTAK4UDS = Var("bDiscriminator('pfNegativeParticleTransformerAK4JetTags:probuds')", + float, + doc="Negative RobustParTAK4 uds tag probability", + precision=10), + btagNegRobustParTAK4G = Var("bDiscriminator('pfNegativeParticleTransformerAK4JetTags:probg')", + float, + doc="Negative RobustParTAK4 gluon tag probability", + precision=10), + ) + + return ParticleTransformerAK4OutputVars + +def add_BTV(process, addAK4=False, addAK8=False, scheme="btvSF"): + process.customizeJetTask = cms.Task() + process.schedule.associate(process.customizeJetTask) + + CommonVars = cms.PSet( + Proba=Var("bDiscriminator('pfJetProbabilityBJetTags')", + float, + doc="Jet Probability (Usage:BTV)", + precision=10), + ProbaN=Var("bDiscriminator('pfNegativeOnlyJetProbabilityBJetTags')", + float, + doc="Negative-only Jet Probability (Usage:BTV)", + precision=10), + Bprob=Var("bDiscriminator('pfJetBProbabilityBJetTags')", + float, + doc="Jet B Probability (Usage:BTV)", + precision=10), + BprobN=Var("bDiscriminator('pfNegativeOnlyJetBProbabilityBJetTags')", + float, + doc="Negative-only Jet B Probability (Usage:BTV)", + precision=10), + ) + + # decouple these from CommonVars, not relevant for data + HadronCountingVars = cms.PSet( + nBHadrons=Var("jetFlavourInfo().getbHadrons().size()", + int, + doc="number of b-hadrons"), + nCHadrons=Var("jetFlavourInfo().getcHadrons().size()", + int, + doc="number of c-hadrons") + ) + + # AK4 + if addAK4: + if scheme == "btvSF": + _n_cpf = 3 + _n_npf = 3 + _n_sv = 4 + elif scheme == "DeepJet": + _n_cpf = 25 + _n_npf = 25 + _n_sv = 4 + elif scheme == "RobustParTAK4": + _n_cpf = 25 + _n_npf = 25 + _n_sv = 12 + process = update_jets_AK4(process) + + process.customJetExtTable = cms.EDProducer( + "SimpleCandidateFlatTableProducer", + src=jetPuppiTable.src, + cut=jetPuppiTable.cut, + name=jetPuppiTable.name, + doc=jetPuppiTable.doc, + singleton=cms.bool(False), # the number of entries is variable + extension=cms.bool(True), # this is the extension table for Jets + variables=cms.PSet( + CommonVars, + get_DeepCSV_vars(), + get_DeepJet_outputs(), # outputs are added in any case, inputs only if requested + get_ParticleNetAK4_outputs(), + #get_ParticleTransformerAK4_outputs(),# removed in 2024 + )) + + # disable the ParT branches in default jetPuppi table + from PhysicsTools.NanoAOD.nano_eras_cff import run3_nanoAOD_122, run3_nanoAOD_124 + (run3_nanoAOD_122 | run3_nanoAOD_124).toModify( + process.jetPuppiTable.variables, + btagRobustParTAK4B = None, + btagRobustParTAK4CvL = None, + btagRobustParTAK4CvB = None, + btagRobustParTAK4QG = None, + ) + + + # from Run3 onwards, always set storeAK4Truth to True for MC + process.customAK4ConstituentsForDeepJetTable = cms.EDProducer("PatJetDeepJetTableProducer", + jets = cms.InputTag("linkedObjects","jets"), + n_cpf=cms.uint32(_n_cpf), + n_npf=cms.uint32(_n_npf), + n_sv=cms.uint32(_n_sv) + ) + process.customizeJetTask.add(process.customJetExtTable) + process.customizeJetTask.add(process.customAK4ConstituentsForDeepJetTable) + # AK8 + if addAK8: + process = update_jets_AK8(process) + process = update_jets_AK8_subjet(process) + process.customFatJetExtTable = cms.EDProducer( + "SimpleCandidateFlatTableProducer", + src=fatJetTable.src, + cut=fatJetTable.cut, + name=fatJetTable.name, + doc=fatJetTable.doc, + singleton=cms.bool(False), # the number of entries is variable + extension=cms.bool(True), # this is the extension table for FatJets + variables=cms.PSet( + CommonVars, + #HadronCountingVars if runOnMC else cms.PSet(), # only necessary before 106x + get_DDX_vars() , + )) + + + # Subjets + process.customSubJetExtTable = cms.EDProducer( + "SimpleCandidateFlatTableProducer", + src=subJetTable.src, + cut=subJetTable.cut, + name=subJetTable.name, + doc=subJetTable.doc, + singleton=cms.bool(False), # the number of entries is variable + extension=cms.bool(True), # this is the extension table for FatJets + variables=cms.PSet( + CommonVars, + #HadronCountingVars if runOnMC else cms.PSet(), # only necessary before 106x + )) + + process.customizeJetTask.add(process.customFatJetExtTable) + process.customizeJetTask.add(process.customSubJetExtTable) + + + +# From https://github.com/cms-jet/PFNano/blob/13_0_7_from124MiniAOD/python/addPFCands_cff.py +def addPFCands(process, allPF = False, addAK4=False, addAK8=False): + process.customizedPFCandsTask = cms.Task() + process.schedule.associate(process.customizedPFCandsTask) + + process.finalJetsAK8Constituents = cms.EDProducer("PatJetConstituentPtrSelector", + src = cms.InputTag("finalJetsAK8"), + cut = cms.string("") + ) + process.finalJetsAK4Constituents = cms.EDProducer("PatJetConstituentPtrSelector", + src = cms.InputTag("finalJetsPuppi"), + cut = cms.string("") + ) + if allPF: + candInput = cms.InputTag("packedPFCandidates") + elif not addAK8: + candList = cms.VInputTag(cms.InputTag("finalJetsAK4Constituents", "constituents")) + process.customizedPFCandsTask.add(process.finalJetsAK4Constituents) + process.finalJetsConstituentsTable = cms.EDProducer("PackedCandidatePtrMerger", src = candList, skipNulls = cms.bool(True), warnOnSkip = cms.bool(True)) + candInput = cms.InputTag("finalJetsConstituentsTable") + elif not addAK4: + candList = cms.VInputTag(cms.InputTag("finalJetsAK8Constituents", "constituents")) + process.customizedPFCandsTask.add(process.finalJetsAK8Constituents) + process.finalJetsConstituentsTable = cms.EDProducer("PackedCandidatePtrMerger", src = candList, skipNulls = cms.bool(True), warnOnSkip = cms.bool(True)) + candInput = cms.InputTag("finalJetsConstituentsTable") + else: + candList = cms.VInputTag(cms.InputTag("finalJetsAK4Constituents", "constituents"), cms.InputTag("finalJetsAK8Constituents", "constituents")) + process.customizedPFCandsTask.add(process.finalJetsAK4Constituents) + process.customizedPFCandsTask.add(process.finalJetsAK8Constituents) + process.finalJetsConstituentsTable = cms.EDProducer("PackedCandidatePtrMerger", src = candList, skipNulls = cms.bool(True), warnOnSkip = cms.bool(True)) + candInput = cms.InputTag("finalJetsConstituentsTable") + + process.customConstituentsExtTable = cms.EDProducer("SimpleCandidateFlatTableProducer", + src = candInput, + cut = cms.string(""), #we should not filter after pruning + name = cms.string("PFCands"), + doc = cms.string("interesting particles from AK4 and AK8 jets"), + singleton = cms.bool(False), # the number of entries is variable + extension = cms.bool(False), # this is the extension table for the AK8 constituents + variables = cms.PSet(CandVars, + puppiWeight = Var("puppiWeight()", float, doc="Puppi weight",precision=10), + puppiWeightNoLep = Var("puppiWeightNoLep()", float, doc="Puppi weight removing leptons",precision=10), + vtxChi2 = Var("?hasTrackDetails()?vertexChi2():-1", float, doc="vertex chi2",precision=10), + trkChi2 = Var("?hasTrackDetails()?pseudoTrack().normalizedChi2():-1", float, doc="normalized trk chi2", precision=10), + dz = Var("?hasTrackDetails()?dz():-1", float, doc="pf dz", precision=10), + dzErr = Var("?hasTrackDetails()?dzError():-1", float, doc="pf dz err", precision=10), + d0 = Var("?hasTrackDetails()?dxy():-1", float, doc="pf d0", precision=10), + d0Err = Var("?hasTrackDetails()?dxyError():-1", float, doc="pf d0 err", precision=10), + pvAssocQuality = Var("pvAssociationQuality()", int, doc="primary vertex association quality. 0: NotReconstructedPrimary, 1: OtherDeltaZ, 4: CompatibilityBTag, 5: CompatibilityDz, 6: UsedInFitLoose, 7: UsedInFitTight"), + lostInnerHits = Var("lostInnerHits()", int, doc="lost inner hits. -1: validHitInFirstPixelBarrelLayer, 0: noLostInnerHits, 1: oneLostInnerHit, 2: moreLostInnerHits"), + lostOuterHits = Var("?hasTrackDetails()?pseudoTrack().hitPattern().numberOfLostHits('MISSING_OUTER_HITS'):0", int, doc="lost outer hits"), + numberOfHits = Var("numberOfHits()", int, doc="number of hits"), + numberOfPixelHits = Var("numberOfPixelHits()", int, doc="number of pixel hits"), + trkQuality = Var("?hasTrackDetails()?pseudoTrack().qualityMask():0", int, doc="track quality mask"), + trkHighPurity = Var("?hasTrackDetails()?pseudoTrack().quality('highPurity'):0", bool, doc="track is high purity"), + trkAlgo = Var("?hasTrackDetails()?pseudoTrack().algo():-1", int, doc="track algorithm"), + trkP = Var("?hasTrackDetails()?pseudoTrack().p():-1", float, doc="track momemtum", precision=-1), + trkPt = Var("?hasTrackDetails()?pseudoTrack().pt():-1", float, doc="track pt", precision=-1), + trkEta = Var("?hasTrackDetails()?pseudoTrack().eta():-1", float, doc="track pt", precision=12), + trkPhi = Var("?hasTrackDetails()?pseudoTrack().phi():-1", float, doc="track phi", precision=12), + ) + ) + process.customAK8ConstituentsTable = cms.EDProducer("PatJetConstituentTableProducer", + candidates = candInput, + jets = cms.InputTag("finalJetsAK8"), + jet_radius = cms.double(0.8), + name = cms.string("FatJetPFCands"), + idx_name = cms.string("pFCandsIdx"), + nameSV = cms.string("FatJetSVs"), + idx_nameSV = cms.string("sVIdx"), + ) + process.customAK4ConstituentsTable = cms.EDProducer("PatJetConstituentTableProducer", + candidates = candInput, + jets = cms.InputTag("finalJetsPuppi"), # was finalJets before + jet_radius = cms.double(0.4), + name = cms.string("JetPFCands"), + idx_name = cms.string("pFCandsIdx"), + nameSV = cms.string("JetSVs"), + idx_nameSV = cms.string("sVIdx"), + ) + process.customizedPFCandsTask.add(process.customConstituentsExtTable) + + if not allPF: + process.customizedPFCandsTask.add(process.finalJetsConstituentsTable) + # linkedObjects are WIP for Run3 + if addAK8: + process.customizedPFCandsTask.add(process.customAK8ConstituentsTable) + if addAK4: + process.customizedPFCandsTask.add(process.customAK4ConstituentsTable) + + + return process + +## Switches for BTV nano +# Default(store SFs PFCands+TaggerInputs) for both AK4 & AK8 jets +# btvNano_addAK4_switch, btvNano_addAK8_switch True, btvNano_addPF_switch False, TaggerInput = "btvSF" + +btvNano_switch = cms.PSet( + btvNano_addAK4_switch = cms.untracked.bool(True), + btvNano_addAK8_switch = cms.untracked.bool(False), + btvNano_addallPF_switch = cms.untracked.bool(False), + TaggerInput = cms.string("btvSF") + ) + +def BTVCustomNanoAOD(process): + addPFCands(process,btvNano_switch.btvNano_addallPF_switch,btvNano_switch.btvNano_addAK4_switch,btvNano_switch.btvNano_addAK8_switch) + add_BTV(process, btvNano_switch.btvNano_addAK4_switch,btvNano_switch.btvNano_addAK8_switch,btvNano_switch.TaggerInput) + process.load("PhysicsTools.NanoAOD.btvMC_cff") + ### for MC + if btvNano_switch.btvNano_addallPF_switch: + process.nanoSequenceMC+=allPFPFCandsMCSequence + else: + if btvNano_switch.btvNano_addAK4_switch and btvNano_switch.btvNano_addAK8_switch : + process.nanoSequenceMC+=ak4ak8PFCandsMCSequence + elif btvNano_switch.btvNano_addAK4_switch and not btvNano_switch.btvNano_addAK8_switch : + process.nanoSequenceMC+=ak4onlyPFCandsMCSequence + elif not btvNano_switch.btvNano_addAK4_switch and btvNano_switch.btvNano_addAK8_switch: + process.nanoSequenceMC+=ak8onlyPFCandsMCSequence + + return process diff --git a/PhysicsTools/NanoAOD/python/custom_jme_cff.py b/PhysicsTools/NanoAOD/python/custom_jme_cff.py index fc86867237e44..b36bd3a70d631 100644 --- a/PhysicsTools/NanoAOD/python/custom_jme_cff.py +++ b/PhysicsTools/NanoAOD/python/custom_jme_cff.py @@ -26,10 +26,11 @@ from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK4_cff import _pfParticleNetFromMiniAODAK4PuppiCentralJetTagsAll from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK4_cff import _pfParticleNetFromMiniAODAK4PuppiForwardJetTagsAll from RecoBTag.ONNXRuntime.pfParticleTransformerAK4_cff import _pfParticleTransformerAK4JetTagsAll +from RecoBTag.ONNXRuntime.pfUnifiedParticleTransformerAK4_cff import _pfUnifiedParticleTransformerAK4JetTagsAll bTagDiscriminatorsForAK4 = cms.PSet(foo = cms.vstring( bTagDeepJet+ _pfParticleNetFromMiniAODAK4PuppiCentralJetTagsAll+_pfParticleNetFromMiniAODAK4PuppiForwardJetTagsAll+ - _pfParticleTransformerAK4JetTagsAll + _pfParticleTransformerAK4JetTagsAll + _pfUnifiedParticleTransformerAK4JetTagsAll )) run2_nanoAOD_ANY.toModify( bTagDiscriminatorsForAK4, @@ -194,6 +195,16 @@ btagRobustParTAK4CvB = Var("?(pt>=15)&&(bDiscriminator('pfParticleTransformerAK4JetTags:probc')+bDiscriminator('pfParticleTransformerAK4JetTags:probb')+bDiscriminator('pfParticleTransformerAK4JetTags:probbb')+bDiscriminator('pfParticleTransformerAK4JetTags:problepb'))>0?bDiscriminator('pfParticleTransformerAK4JetTags:probc')/(bDiscriminator('pfParticleTransformerAK4JetTags:probc')+bDiscriminator('pfParticleTransformerAK4JetTags:probb')+bDiscriminator('pfParticleTransformerAK4JetTags:probbb')+bDiscriminator('pfParticleTransformerAK4JetTags:problepb')):-1",float,doc="RobustParTAK4 c vs b+bb+lepb discriminator",precision=10), btagRobustParTAK4QG = Var("?(pt>=15)&&(bDiscriminator('pfParticleTransformerAK4JetTags:probg')+bDiscriminator('pfParticleTransformerAK4JetTags:probuds'))>0?bDiscriminator('pfParticleTransformerAK4JetTags:probg')/(bDiscriminator('pfParticleTransformerAK4JetTags:probg')+bDiscriminator('pfParticleTransformerAK4JetTags:probuds')):-1",float,doc="RobustParTAK4 g vs uds discriminator",precision=10), ) +UNIFIEDPARTAK4VARS = cms.PSet( + btagUParTAK4B = Var("?pt>15 && bDiscriminator('pfUnifiedParticleTransformerAK4DiscriminatorsJetTags:BvsAll')>0?bDiscriminator('pfUnifiedParticleTransformerAK4DiscriminatorsJetTags:BvsAll'):-1",float,precision=10,doc="UnifiedParTAK4 b vs. udscg"), + btagUParTAK4CvL = Var("?pt>15 && bDiscriminator('pfUnifiedParticleTransformerAK4DiscriminatorsJetTags:CvsL')>0?bDiscriminator('pfUnifiedParticleTransformerAK4DiscriminatorsJetTags:CvsL'):-1",float,precision=10,doc="UnifiedParTAK4 c vs. udsg"), + btagUParTAK4CvB = Var("?pt>15 && bDiscriminator('pfUnifiedParticleTransformerAK4DiscriminatorsJetTags:CvsB')>0?bDiscriminator('pfUnifiedParticleTransformerAK4DiscriminatorsJetTags:CvsB'):-1",float,precision=10,doc="UnifiedParTAK4 c vs. b"), + btagUParTAK4QvG = Var("?pt>15 && bDiscriminator('pfUnifiedParticleTransformerAK4DiscriminatorsJetTags:QvsG')>0?bDiscriminator('pfUnifiedParticleTransformerAK4DiscriminatorsJetTags:QvsG'):-1",float,precision=10,doc="UnifiedParTAK4 q (udsbc) vs. g"), + btagUParTAK4TauVJet = Var("?pt>15 && bDiscriminator('pfUnifiedParticleTransformerAK4DiscriminatorsJetTags:TauVsJet')>0?bDiscriminator('pfUnifiedParticleTransformerAK4DiscriminatorsJetTags:TauVsJet'):-1",float,precision=10,doc="UnifiedParTAK4 tau vs. jet"), + UParTAK4RegPtRawCorr = Var("?pt>15 && bDiscriminator('pfUnifiedParticleTransformerAK4JetTags:ptcorr')>0?bDiscriminator('pfUnifiedParticleTransformerAK4JetTags:ptcorr'):-1",float,precision=10,doc="UnifiedParTAK4 universal flavor-aware visible pT regression (no neutrinos), correction relative to raw jet pT"), + UParTAK4RegPtRawCorrNeutrino = Var("?pt>15 && bDiscriminator('pfUnifiedParticleTransformerAK4JetTags:ptnu')>0?bDiscriminator('pfUnifiedParticleTransformerAK4JetTags:ptnu'):-1",float,precision=10,doc="UnifiedParTAK4 universal flavor-aware pT regression neutrino correction, relative to visible. To apply full regression, multiply raw jet pT by both UParTAK4RegPtRawCorr and UParTAK4RegPtRawCorrNeutrino."), + UParTAK4RegPtRawRes = Var("?pt>15 && 0.5*(bDiscriminator('pfUnifiedParticleTransformerAK4JetTags:ptreshigh')-bDiscriminator('pfUnifiedParticleTransformerAK4JetTags:ptreslow')) > 0?0.5*(bDiscriminator('pfUnifiedParticleTransformerAK4JetTags:ptreshigh')-bDiscriminator('pfUnifiedParticleTransformerAK4JetTags:ptreslow')):-1",float,precision=10,doc="UnifiedParTAK4 universal flavor-aware jet pT resolution estimator, (q84 - q16)/2"), +) PARTICLENETAK4VARS = cms.PSet( particleNetAK4_B = Var("?(pt>=15)?bDiscriminator('pfParticleNetAK4DiscriminatorsJetTags:BvsAll'):-1",float,doc="ParticleNetAK4 tagger b vs all (udsg, c) discriminator",precision=10), particleNetAK4_CvsL = Var("?(pt>=15)?bDiscriminator('pfParticleNetAK4DiscriminatorsJetTags:CvsL'):-1",float,doc="ParticleNetAK4 tagger c vs udsg discriminator",precision=10), @@ -432,6 +443,21 @@ def AddRobustParTAK4Scores(proc, jetTableName=""): return proc +def AddUnifiedParTAK4Scores(proc, jetTableName=""): + """ + Store RobustParTAK4 scores in jetTable + """ + + getattr(proc, jetTableName).variables.btagUParTAK4B = UNIFIEDPARTAK4VARS.btagUParTAK4B + getattr(proc, jetTableName).variables.btagUParTAK4CvL = UNIFIEDPARTAK4VARS.btagUParTAK4CvL + getattr(proc, jetTableName).variables.btagUParTAK4CvB = UNIFIEDPARTAK4VARS.btagUParTAK4CvB + getattr(proc, jetTableName).variables.btagUParTAK4TauVJet = UNIFIEDPARTAK4VARS.btagUParTAK4TauVJet + getattr(proc, jetTableName).variables.UParTAK4RegPtRawCorr = UNIFIEDPARTAK4VARS.UParTAK4RegPtRawCorr + getattr(proc, jetTableName).variables.UParTAK4RegPtRawCorrNeutrino = UNIFIEDPARTAK4VARS.UParTAK4RegPtRawCorrNeutrino + getattr(proc, jetTableName).variables.UParTAK4RegPtRawRes = UNIFIEDPARTAK4VARS.UParTAK4RegPtRawRes + + return proc + def AddParticleNetAK4Scores(proc, jetTableName=""): """ Store ParticleNetAK4 scores in jetTable @@ -612,6 +638,7 @@ def SavePatJets(proc, jetName, payload, patJetFinalColl, jetTablePrefix, jetTabl AddDeepJetGluonLQuarkScores(proc,jetTableName=jetTableName) AddParticleNetAK4Scores(proc,jetTableName=jetTableName) AddRobustParTAK4Scores(proc,jetTableName=jetTableName) + AddUnifiedParTAK4Scores(proc,jetTableName=jetTableName) return proc @@ -742,7 +769,16 @@ def ReclusterAK4PuppiJets(proc, recoJA, runOnMC): proc.jetPuppiTable.variables.btagRobustParTAK4B = ROBUSTPARTAK4VARS.btagRobustParTAK4B proc.jetPuppiTable.variables.btagRobustParTAK4CvL = ROBUSTPARTAK4VARS.btagRobustParTAK4CvL proc.jetPuppiTable.variables.btagRobustParTAK4CvB = ROBUSTPARTAK4VARS.btagRobustParTAK4CvB - + # + # Save UnifiedParTAK4 b-tagging and c-tagging variables + # + proc.jetPuppiTable.variables.btagUParTAK4B = UNIFIEDPARTAK4VARS.btagUParTAK4B + proc.jetPuppiTable.variables.btagUParTAK4CvL = UNIFIEDPARTAK4VARS.btagUParTAK4CvL + proc.jetPuppiTable.variables.btagUParTAK4CvB = UNIFIEDPARTAK4VARS.btagUParTAK4CvB + proc.jetPuppiTable.variables.btagUParTAK4TauVJet = UNIFIEDPARTAK4VARS.btagUParTAK4TauVJet + proc.jetPuppiTable.variables.UParTAK4RegPtRawCorr = UNIFIEDPARTAK4VARS.UParTAK4RegPtRawCorr + proc.jetPuppiTable.variables.UParTAK4RegPtRawCorrNeutrino = UNIFIEDPARTAK4VARS.UParTAK4RegPtRawCorrNeutrino + proc.jetPuppiTable.variables.UParTAK4RegPtRawRes = UNIFIEDPARTAK4VARS.UParTAK4RegPtRawRes # # For Run-2 eras, don't need to save the low pt AK4 Puppi jet table for MET # @@ -878,7 +914,7 @@ def ReclusterAK4CHSJets(proc, recoJA, runOnMC): # one tagger only. # for varNames in proc.jetTable.variables.parameterNames_(): - if "btagDeepFlav" in varNames or "btagRobustParT" in varNames: + if "btagDeepFlav" in varNames or "btagRobustParT" in varNames or "btagUParT" in varNames: delattr(proc.jetTable.variables, varNames) proc.jetTable.variables.btagPNetB = Var("?pt>15 && bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags:BvsAll')>0?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags:BvsAll'):-1",float,precision=10,doc="ParticleNet b vs. udscg") diff --git a/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py b/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py index eafbca1c54059..823193b28d1c8 100644 --- a/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py +++ b/PhysicsTools/NanoAOD/python/jetsAK4_CHS_cff.py @@ -135,33 +135,27 @@ svIdx2 = Var("?overlaps('vertices').size()>1?overlaps('vertices')[1].key():-1", "int16", doc="index of second matching secondary vertex"), nSVs = Var("?hasOverlaps('vertices')?overlaps('vertices').size():0", "uint8", doc="number of secondary vertices in the jet"), btagDeepFlavB = Var("bDiscriminator('pfDeepFlavourJetTags:probb')+bDiscriminator('pfDeepFlavourJetTags:probbb')+bDiscriminator('pfDeepFlavourJetTags:problepb')",float,doc="DeepJet b+bb+lepb tag discriminator",precision=10), - btagRobustParTAK4B = Var("bDiscriminator('pfParticleTransformerAK4JetTags:probb')+bDiscriminator('pfParticleTransformerAK4JetTags:probbb')+bDiscriminator('pfParticleTransformerAK4JetTags:problepb')", - float, - doc="RobustParTAK4 b+bb+lepb tag discriminator", - precision=10), btagDeepFlavCvL = Var("?(bDiscriminator('pfDeepFlavourJetTags:probc')+bDiscriminator('pfDeepFlavourJetTags:probuds')+bDiscriminator('pfDeepFlavourJetTags:probg'))>0?bDiscriminator('pfDeepFlavourJetTags:probc')/(bDiscriminator('pfDeepFlavourJetTags:probc')+bDiscriminator('pfDeepFlavourJetTags:probuds')+bDiscriminator('pfDeepFlavourJetTags:probg')):-1",float,doc="DeepJet c vs uds+g discriminator",precision=10), btagDeepFlavCvB = Var("?(bDiscriminator('pfDeepFlavourJetTags:probc')+bDiscriminator('pfDeepFlavourJetTags:probb')+bDiscriminator('pfDeepFlavourJetTags:probbb')+bDiscriminator('pfDeepFlavourJetTags:problepb'))>0?bDiscriminator('pfDeepFlavourJetTags:probc')/(bDiscriminator('pfDeepFlavourJetTags:probc')+bDiscriminator('pfDeepFlavourJetTags:probb')+bDiscriminator('pfDeepFlavourJetTags:probbb')+bDiscriminator('pfDeepFlavourJetTags:problepb')):-1",float,doc="DeepJet c vs b+bb+lepb discriminator",precision=10), btagDeepFlavQG = Var("?(bDiscriminator('pfDeepFlavourJetTags:probg')+bDiscriminator('pfDeepFlavourJetTags:probuds'))>0?bDiscriminator('pfDeepFlavourJetTags:probg')/(bDiscriminator('pfDeepFlavourJetTags:probg')+bDiscriminator('pfDeepFlavourJetTags:probuds')):-1",float,doc="DeepJet g vs uds discriminator",precision=10), - btagRobustParTAK4CvL = Var("?(bDiscriminator('pfParticleTransformerAK4JetTags:probc')+bDiscriminator('pfParticleTransformerAK4JetTags:probuds')+bDiscriminator('pfParticleTransformerAK4JetTags:probg'))>0?bDiscriminator('pfParticleTransformerAK4JetTags:probc')/(bDiscriminator('pfParticleTransformerAK4JetTags:probc')+bDiscriminator('pfParticleTransformerAK4JetTags:probuds')+bDiscriminator('pfParticleTransformerAK4JetTags:probg')):-1", - float, - doc="RobustParTAK4 c vs uds+g discriminator", - precision=10), - btagRobustParTAK4CvB = Var("?(bDiscriminator('pfParticleTransformerAK4JetTags:probc')+bDiscriminator('pfParticleTransformerAK4JetTags:probb')+bDiscriminator('pfParticleTransformerAK4JetTags:probbb')+bDiscriminator('pfParticleTransformerAK4JetTags:problepb'))>0?bDiscriminator('pfParticleTransformerAK4JetTags:probc')/(bDiscriminator('pfParticleTransformerAK4JetTags:probc')+bDiscriminator('pfParticleTransformerAK4JetTags:probb')+bDiscriminator('pfParticleTransformerAK4JetTags:probbb')+bDiscriminator('pfParticleTransformerAK4JetTags:problepb')):-1", - float, - doc="RobustParTAK4 c vs b+bb+lepb discriminator", - precision=10), - btagRobustParTAK4QG = Var("?(bDiscriminator('pfParticleTransformerAK4JetTags:probg')+bDiscriminator('pfParticleTransformerAK4JetTags:probuds'))>0?bDiscriminator('pfParticleTransformerAK4JetTags:probg')/(bDiscriminator('pfParticleTransformerAK4JetTags:probg')+bDiscriminator('pfParticleTransformerAK4JetTags:probuds')):-1", - float, - doc="RobustParTAK4 g vs uds discriminator", - precision=10), btagPNetB = Var("?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags:BvsAll')>0?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags:BvsAll'):-1",float,precision=10,doc="ParticleNet b vs. udscg"), btagPNetCvL = Var("?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags:CvsL')>0?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags:CvsL'):-1",float,precision=10,doc="ParticleNet c vs. udsg"), btagPNetCvB = Var("?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags:CvsB')>0?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags:CvsB'):-1",float,precision=10,doc="ParticleNet c vs. b"), + btagPNetCvNotB = Var("?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralJetTags:probb')>0?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralJetTags:probc')/(1.-bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralJetTags:probb')):-1",float,precision=10,doc="ParticleNet C vs notB"), btagPNetQvG = Var("?abs(eta())<2.5?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags:QvsG'):bDiscriminator('pfParticleNetFromMiniAODAK4CHSForwardDiscriminatorsJetTags:QvsG')",float,precision=10,doc="ParticleNet q (udsbc) vs. g"), btagPNetTauVJet = Var("?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags:TauVsJet')>0?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralDiscriminatorsJetTags:TauVsJet'):-1",float,precision=10,doc="ParticleNet tau vs. jet"), PNetRegPtRawCorr = Var("?abs(eta())<2.5?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralJetTags:ptcorr'):bDiscriminator('pfParticleNetFromMiniAODAK4CHSForwardJetTags:ptcorr')",float,precision=10,doc="ParticleNet universal flavor-aware visible pT regression (no neutrinos), correction relative to raw jet pT"), PNetRegPtRawCorrNeutrino = Var("?abs(eta())<2.5?bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralJetTags:ptnu'):bDiscriminator('pfParticleNetFromMiniAODAK4CHSForwardJetTags:ptnu')",float,precision=10,doc="ParticleNet universal flavor-aware pT regression neutrino correction, relative to visible. To apply full regression, multiply raw jet pT by both PNetRegPtRawCorr and PNetRegPtRawCorrNeutrino."), PNetRegPtRawRes = Var("?abs(eta())<2.5?0.5*(bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralJetTags:ptreshigh')-bDiscriminator('pfParticleNetFromMiniAODAK4CHSCentralJetTags:ptreslow')):0.5*(bDiscriminator('pfParticleNetFromMiniAODAK4CHSForwardJetTags:ptreshigh')-bDiscriminator('pfParticleNetFromMiniAODAK4CHSForwardJetTags:ptreslow'))",float,precision=10,doc="ParticleNet universal flavor-aware jet pT resolution estimator, (q84 - q16)/2"), + btagUParTAK4B = Var("?bDiscriminator('pfUnifiedParticleTransformerAK4DiscriminatorsJetTags:BvsAll')>0?bDiscriminator('pfUnifiedParticleTransformerAK4DiscriminatorsJetTags:BvsAll'):-1",float,precision=10,doc="UnifiedParT b vs. udscg"), + btagUParTAK4CvL = Var("?bDiscriminator('pfUnifiedParticleTransformerAK4DiscriminatorsJetTags:CvsL')>0?bDiscriminator('pfUnifiedParticleTransformerAK4DiscriminatorsJetTags:CvsL'):-1",float,precision=10,doc="UnifiedParT c vs. udsg"), + btagUParTAK4CvB = Var("?bDiscriminator('pfUnifiedParticleTransformerAK4DiscriminatorsJetTags:CvsB')>0?bDiscriminator('pfUnifiedParticleTransformerAK4DiscriminatorsJetTags:CvsB'):-1",float,precision=10,doc="UnifiedParT c vs. b"), + btagUParTAK4CvNotB = Var("?((bDiscriminator('pfUnifiedParticleTransformerAK4JetTags:probb')+bDiscriminator('pfUnifiedParticleTransformerAK4JetTags:probbb')+bDiscriminator('pfUnifiedParticleTransformerAK4JetTags:problepb')))>0?((bDiscriminator('pfUnifiedParticleTransformerAK4JetTags:probc'))/(1.-bDiscriminator('pfUnifiedParticleTransformerAK4JetTags:probb')-bDiscriminator('pfUnifiedParticleTransformerAK4JetTags:probbb')-bDiscriminator('pfUnifiedParticleTransformerAK4JetTags:problepb'))):-1",float,precision=10,doc="UnifiedParT c vs. not b"), + btagUParTAK4QvG = Var("?bDiscriminator('pfUnifiedParticleTransformerAK4DiscriminatorsJetTags:QvsG')>0?bDiscriminator('pfUnifiedParticleTransformerAK4DiscriminatorsJetTags:QvsG'):-1",float,precision=10,doc="UnifiedParT q (udsbc) vs. g"), + btagUParTAK4TauVJet = Var("?bDiscriminator('pfUnifiedParticleTransformerAK4DiscriminatorsJetTags:TauVsJet')>0?bDiscriminator('pfUnifiedParticleTransformerAK4DiscriminatorsJetTags:TauVsJet'):-1",float,precision=10,doc="UnifiedParT tau vs. jet"), + UParTAK4RegPtRawCorr = Var("?bDiscriminator('pfUnifiedParticleTransformerAK4JetTags:ptcorr')>0?bDiscriminator('pfUnifiedParticleTransformerAK4JetTags:ptcorr'):-1",float,precision=10,doc="UnifiedParT universal flavor-aware visible pT regression (no neutrinos), correction relative to raw jet pT"), + UParTAK4RegPtRawCorrNeutrino = Var("?bDiscriminator('pfUnifiedParticleTransformerAK4JetTags:ptnu')>0?bDiscriminator('pfUnifiedParticleTransformerAK4JetTags:ptnu'):-1",float,precision=10,doc="UnifiedParT universal flavor-aware pT regression neutrino correction, relative to visible. To apply full regression, multiply raw jet pT by both UParTAK4RegPtRawCorr and UParTAK4RegPtRawCorrNeutrino."), + UParTAK4RegPtRawRes = Var("?(bDiscriminator('pfUnifiedParticleTransformerAK4JetTags:ptreshigh')+bDiscriminator('pfUnifiedParticleTransformerAK4JetTags:ptreslow'))>0?0.5*(bDiscriminator('pfUnifiedParticleTransformerAK4JetTags:ptreshigh')-bDiscriminator('pfUnifiedParticleTransformerAK4JetTags:ptreslow')):-1",float,precision=10,doc="UnifiedParT universal flavor-aware jet pT resolution estimator, (q84 - q16)/2"), puIdDisc = Var("userFloat('puIdNanoDisc')", float,doc="Pileup ID discriminant with 106X (2018) training",precision=10), puId = Var("userInt('puIdNanoId')", "uint8", doc="Pileup ID flags with 106X (2018) training"), jetId = Var("userInt('tightId')*2+4*userInt('tightIdLepVeto')", "uint8", doc="Jet ID flags bit1 is loose (always false in 2017 since it does not exist), bit2 is tight, bit3 is tightLepVeto"), @@ -385,7 +379,7 @@ ## - To be used in nanoAOD_customizeCommon() in nano_cff.py ############################################################### from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection -def nanoAOD_addDeepInfoAK4CHS(process,addDeepBTag,addDeepFlavour,addParticleNet,addRobustParTAK4=False): +def nanoAOD_addDeepInfoAK4CHS(process,addDeepBTag,addDeepFlavour,addParticleNet,addRobustParTAK4=False,addUnifiedParTAK4=False): _btagDiscriminators=[] if addDeepBTag: print("Updating process to run DeepCSV btag") @@ -403,6 +397,10 @@ def nanoAOD_addDeepInfoAK4CHS(process,addDeepBTag,addDeepFlavour,addParticleNet, print("Updating process to run RobustParTAK4") from RecoBTag.ONNXRuntime.pfParticleTransformerAK4_cff import _pfParticleTransformerAK4JetTagsAll as pfParticleTransformerAK4JetTagsAll _btagDiscriminators += pfParticleTransformerAK4JetTagsAll + if addUnifiedParTAK4: + print("Updating process to run UnifiedParTAK4") + from RecoBTag.ONNXRuntime.pfUnifiedParticleTransformerAK4_cff import _pfUnifiedParticleTransformerAK4JetTagsAll as pfUnifiedParticleTransformerAK4JetTagsAll + _btagDiscriminators += pfUnifiedParticleTransformerAK4JetTagsAll if len(_btagDiscriminators)==0: return process print("Will recalculate the following discriminators: "+", ".join(_btagDiscriminators)) @@ -422,7 +420,8 @@ def nanoAOD_addDeepInfoAK4CHS(process,addDeepBTag,addDeepFlavour,addParticleNet, nanoAOD_addDeepBTag_switch = cms.untracked.bool(False), nanoAOD_addDeepFlavourTag_switch = cms.untracked.bool(False), nanoAOD_addParticleNet_switch = cms.untracked.bool(False), - nanoAOD_addRobustParTAK4Tag_switch = cms.untracked.bool(False) + nanoAOD_addRobustParTAK4Tag_switch = cms.untracked.bool(False), + nanoAOD_addUnifiedParTAK4Tag_switch = cms.untracked.bool(False) ) ################################################ diff --git a/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py b/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py index f3eac030aa776..4b4006cff284a 100644 --- a/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py +++ b/PhysicsTools/NanoAOD/python/jetsAK4_Puppi_cff.py @@ -100,14 +100,11 @@ svIdx2 = Var("?overlaps('vertices').size()>1?overlaps('vertices')[1].key():-1", "int16", doc="index of second matching secondary vertex"), nSVs = Var("?hasOverlaps('vertices')?overlaps('vertices').size():0", "uint8", doc="number of secondary vertices in the jet"), btagDeepFlavB = Var("bDiscriminator('pfDeepFlavourJetTags:probb')+bDiscriminator('pfDeepFlavourJetTags:probbb')+bDiscriminator('pfDeepFlavourJetTags:problepb')",float,doc="DeepJet b+bb+lepb tag discriminator",precision=10), - btagRobustParTAK4B = Var("bDiscriminator('pfParticleTransformerAK4JetTags:probb')+bDiscriminator('pfParticleTransformerAK4JetTags:probbb')+bDiscriminator('pfParticleTransformerAK4JetTags:problepb')",float,doc="RobustParTAK4 b+bb+lepb tag discriminator",precision=10), btagDeepFlavCvL = Var("?(bDiscriminator('pfDeepFlavourJetTags:probc')+bDiscriminator('pfDeepFlavourJetTags:probuds')+bDiscriminator('pfDeepFlavourJetTags:probg'))>0?bDiscriminator('pfDeepFlavourJetTags:probc')/(bDiscriminator('pfDeepFlavourJetTags:probc')+bDiscriminator('pfDeepFlavourJetTags:probuds')+bDiscriminator('pfDeepFlavourJetTags:probg')):-1",float,doc="DeepJet c vs uds+g discriminator",precision=10), btagDeepFlavCvB = Var("?(bDiscriminator('pfDeepFlavourJetTags:probc')+bDiscriminator('pfDeepFlavourJetTags:probb')+bDiscriminator('pfDeepFlavourJetTags:probbb')+bDiscriminator('pfDeepFlavourJetTags:problepb'))>0?bDiscriminator('pfDeepFlavourJetTags:probc')/(bDiscriminator('pfDeepFlavourJetTags:probc')+bDiscriminator('pfDeepFlavourJetTags:probb')+bDiscriminator('pfDeepFlavourJetTags:probbb')+bDiscriminator('pfDeepFlavourJetTags:problepb')):-1",float,doc="DeepJet c vs b+bb+lepb discriminator",precision=10), btagDeepFlavQG = Var("?(bDiscriminator('pfDeepFlavourJetTags:probg')+bDiscriminator('pfDeepFlavourJetTags:probuds'))>0?bDiscriminator('pfDeepFlavourJetTags:probg')/(bDiscriminator('pfDeepFlavourJetTags:probg')+bDiscriminator('pfDeepFlavourJetTags:probuds')):-1",float,doc="DeepJet g vs uds discriminator",precision=10), - btagRobustParTAK4CvL = Var("?(bDiscriminator('pfParticleTransformerAK4JetTags:probc')+bDiscriminator('pfParticleTransformerAK4JetTags:probuds')+bDiscriminator('pfParticleTransformerAK4JetTags:probg'))>0?bDiscriminator('pfParticleTransformerAK4JetTags:probc')/(bDiscriminator('pfParticleTransformerAK4JetTags:probc')+bDiscriminator('pfParticleTransformerAK4JetTags:probuds')+bDiscriminator('pfParticleTransformerAK4JetTags:probg')):-1",float,doc="RobustParTAK4 c vs uds+g discriminator",precision=10), - btagRobustParTAK4CvB = Var("?(bDiscriminator('pfParticleTransformerAK4JetTags:probc')+bDiscriminator('pfParticleTransformerAK4JetTags:probb')+bDiscriminator('pfParticleTransformerAK4JetTags:probbb')+bDiscriminator('pfParticleTransformerAK4JetTags:problepb'))>0?bDiscriminator('pfParticleTransformerAK4JetTags:probc')/(bDiscriminator('pfParticleTransformerAK4JetTags:probc')+bDiscriminator('pfParticleTransformerAK4JetTags:probb')+bDiscriminator('pfParticleTransformerAK4JetTags:probbb')+bDiscriminator('pfParticleTransformerAK4JetTags:problepb')):-1",float,doc="RobustParTAK4 c vs b+bb+lepb discriminator",precision=10), - btagRobustParTAK4QG = Var("?(bDiscriminator('pfParticleTransformerAK4JetTags:probg')+bDiscriminator('pfParticleTransformerAK4JetTags:probuds'))>0?bDiscriminator('pfParticleTransformerAK4JetTags:probg')/(bDiscriminator('pfParticleTransformerAK4JetTags:probg')+bDiscriminator('pfParticleTransformerAK4JetTags:probuds')):-1",float,doc="RobustParTAK4 g vs uds discriminator",precision=10), btagPNetB = Var("?bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralDiscriminatorsJetTags:BvsAll')>0?bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralDiscriminatorsJetTags:BvsAll'):-1",float,precision=10,doc="ParticleNet b vs. udscg"), + btagPNetCvNotB = Var("?bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralJetTags:probb')>0?bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralJetTags:probc')/(1.-bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralJetTags:probb')):-1",float,precision=10,doc="ParticleNet C vs notB"), btagPNetCvL = Var("?bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralDiscriminatorsJetTags:CvsL')>0?bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralDiscriminatorsJetTags:CvsL'):-1",float,precision=10,doc="ParticleNet c vs. udsg"), btagPNetCvB = Var("?bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralDiscriminatorsJetTags:CvsB')>0?bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralDiscriminatorsJetTags:CvsB'):-1",float,precision=10,doc="ParticleNet c vs. b"), btagPNetQvG = Var("?abs(eta())<2.5?bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralDiscriminatorsJetTags:QvsG'):bDiscriminator('pfParticleNetFromMiniAODAK4PuppiForwardDiscriminatorsJetTags:QvsG')",float,precision=10,doc="ParticleNet q (udsbc) vs. g"), @@ -115,6 +112,15 @@ PNetRegPtRawCorr = Var("?abs(eta())<2.5?bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralJetTags:ptcorr'):bDiscriminator('pfParticleNetFromMiniAODAK4PuppiForwardJetTags:ptcorr')",float,precision=10,doc="ParticleNet universal flavor-aware visible pT regression (no neutrinos), correction relative to raw jet pT"), PNetRegPtRawCorrNeutrino = Var("?abs(eta())<2.5?bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralJetTags:ptnu'):bDiscriminator('pfParticleNetFromMiniAODAK4PuppiForwardJetTags:ptnu')",float,precision=10,doc="ParticleNet universal flavor-aware pT regression neutrino correction, relative to visible. To apply full regression, multiply raw jet pT by both PNetRegPtRawCorr and PNetRegPtRawCorrNeutrino."), PNetRegPtRawRes = Var("?abs(eta())<2.5?0.5*(bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralJetTags:ptreshigh')-bDiscriminator('pfParticleNetFromMiniAODAK4PuppiCentralJetTags:ptreslow')):0.5*(bDiscriminator('pfParticleNetFromMiniAODAK4PuppiForwardJetTags:ptreshigh')-bDiscriminator('pfParticleNetFromMiniAODAK4PuppiForwardJetTags:ptreslow'))",float,precision=10,doc="ParticleNet universal flavor-aware jet pT resolution estimator, (q84 - q16)/2"), + btagUParTAK4B = Var("?bDiscriminator('pfUnifiedParticleTransformerAK4DiscriminatorsJetTags:BvsAll')>0?bDiscriminator('pfUnifiedParticleTransformerAK4DiscriminatorsJetTags:BvsAll'):-1",float,precision=10,doc="UnifiedParT b vs. udscg"), + btagUParTAK4CvL = Var("?bDiscriminator('pfUnifiedParticleTransformerAK4DiscriminatorsJetTags:CvsL')>0?bDiscriminator('pfUnifiedParticleTransformerAK4DiscriminatorsJetTags:CvsL'):-1",float,precision=10,doc="UnifiedParT c vs. udsg"), + btagUParTAK4CvB = Var("?bDiscriminator('pfUnifiedParticleTransformerAK4DiscriminatorsJetTags:CvsB')>0?bDiscriminator('pfUnifiedParticleTransformerAK4DiscriminatorsJetTags:CvsB'):-1",float,precision=10,doc="UnifiedParT c vs. b"), + btagUParTAK4CvNotB = Var("?((bDiscriminator('pfUnifiedParticleTransformerAK4JetTags:probb')+bDiscriminator('pfUnifiedParticleTransformerAK4JetTags:probbb')+bDiscriminator('pfUnifiedParticleTransformerAK4JetTags:problepb')))>0?((bDiscriminator('pfUnifiedParticleTransformerAK4JetTags:probc'))/(1.-bDiscriminator('pfUnifiedParticleTransformerAK4JetTags:probb')-bDiscriminator('pfUnifiedParticleTransformerAK4JetTags:probbb')-bDiscriminator('pfUnifiedParticleTransformerAK4JetTags:problepb'))):-1",float,precision=10,doc="UnifiedParT c vs. not b"), + btagUParTAK4QvG = Var("?bDiscriminator('pfUnifiedParticleTransformerAK4DiscriminatorsJetTags:QvsG')>0?bDiscriminator('pfUnifiedParticleTransformerAK4DiscriminatorsJetTags:QvsG'):-1",float,precision=10,doc="UnifiedParT q (udsbc) vs. g"), + btagUParTAK4TauVJet = Var("?bDiscriminator('pfUnifiedParticleTransformerAK4DiscriminatorsJetTags:TauVsJet')>0?bDiscriminator('pfUnifiedParticleTransformerAK4DiscriminatorsJetTags:TauVsJet'):-1",float,precision=10,doc="UnifiedParT tau vs. jet"), + UParTAK4RegPtRawCorr = Var("?bDiscriminator('pfUnifiedParticleTransformerAK4JetTags:ptcorr')>0?bDiscriminator('pfUnifiedParticleTransformerAK4JetTags:ptcorr'):-1",float,precision=10,doc="UnifiedParT universal flavor-aware visible pT regression (no neutrinos), correction relative to raw jet pT"), + UParTAK4RegPtRawCorrNeutrino = Var("?bDiscriminator('pfUnifiedParticleTransformerAK4JetTags:ptnu')>0?bDiscriminator('pfUnifiedParticleTransformerAK4JetTags:ptnu'):-1",float,precision=10,doc="UnifiedParT universal flavor-aware pT regression neutrino correction, relative to visible. To apply full regression, multiply raw jet pT by both UParTAK4RegPtRawCorr and UParTAK4RegPtRawCorrNeutrino."), + UParTAK4RegPtRawRes = Var("?(bDiscriminator('pfUnifiedParticleTransformerAK4JetTags:ptreshigh')+bDiscriminator('pfUnifiedParticleTransformerAK4JetTags:ptreslow'))>0?0.5*(bDiscriminator('pfUnifiedParticleTransformerAK4JetTags:ptreshigh')-bDiscriminator('pfUnifiedParticleTransformerAK4JetTags:ptreslow')):-1",float,precision=10,doc="UnifiedParT universal flavor-aware jet pT resolution estimator, (q84 - q16)/2"), jetId = Var("userInt('tightId')*2+4*userInt('tightIdLepVeto')", "uint8",doc="Jet ID flag: bit2 is tight, bit3 is tightLepVeto"), hfsigmaEtaEta = Var("userFloat('hfsigmaEtaEta')",float,doc="sigmaEtaEta for HF jets (noise discriminating variable)",precision=10), hfsigmaPhiPhi = Var("userFloat('hfsigmaPhiPhi')",float,doc="sigmaPhiPhi for HF jets (noise discriminating variable)",precision=10), @@ -168,7 +174,7 @@ ## - To be used in nanoAOD_customizeCommon() in nano_cff.py ############################################################### from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection -def nanoAOD_addDeepInfoAK4(process,addParticleNet,addRobustParTAK4=False): +def nanoAOD_addDeepInfoAK4(process,addParticleNet,addRobustParTAK4=False,addUnifiedParTAK4=False): _btagDiscriminators=[] if addParticleNet: print("Updating process to run ParticleNetAK4") @@ -180,6 +186,10 @@ def nanoAOD_addDeepInfoAK4(process,addParticleNet,addRobustParTAK4=False): print("Updating process to run RobustParTAK4") from RecoBTag.ONNXRuntime.pfParticleTransformerAK4_cff import _pfParticleTransformerAK4JetTagsAll as pfParticleTransformerAK4JetTagsAll _btagDiscriminators += pfParticleTransformerAK4JetTagsAll + if addUnifiedParTAK4: + print("Updating process to run UnifiedParTAK4") + from RecoBTag.ONNXRuntime.pfUnifiedParticleTransformerAK4_cff import _pfUnifiedParticleTransformerAK4JetTagsAll as pfUnifiedParticleTransformerAK4JetTagsAll + _btagDiscriminators += pfUnifiedParticleTransformerAK4JetTagsAll if len(_btagDiscriminators)==0: return process print("Will recalculate the following discriminators: "+", ".join(_btagDiscriminators)) updateJetCollection( @@ -196,7 +206,8 @@ def nanoAOD_addDeepInfoAK4(process,addParticleNet,addRobustParTAK4=False): nanoAOD_addDeepInfoAK4_switch = cms.PSet( nanoAOD_addParticleNet_switch = cms.untracked.bool(False), - nanoAOD_addRobustParTAK4Tag_switch = cms.untracked.bool(False) + nanoAOD_addRobustParTAK4Tag_switch = cms.untracked.bool(False), + nanoAOD_addUnifiedParTAK4Tag_switch = cms.untracked.bool(False) ) ################################################ diff --git a/PhysicsTools/NanoAOD/python/nanoDQM_cfi.py b/PhysicsTools/NanoAOD/python/nanoDQM_cfi.py index 665f9934d2114..b240946ebc344 100644 --- a/PhysicsTools/NanoAOD/python/nanoDQM_cfi.py +++ b/PhysicsTools/NanoAOD/python/nanoDQM_cfi.py @@ -417,10 +417,12 @@ Plot1D('btagDeepFlavCvB', 'btagDeepFlavCvB', 20, -1, 1, 'DeepJet c vs b+bb+lepb discriminator'), Plot1D('btagDeepFlavCvL', 'btagDeepFlavCvL', 20, -1, 1, 'DeepJet c vs uds+g discriminator'), Plot1D('btagDeepFlavQG', 'btagDeepFlavQG', 20, -1, 1, 'DeepJet g vs uds discriminator'), - Plot1D('btagRobustParTAK4B', 'btagRobustParTAK4B', 20, 0, 1, 'RobustParTAK4 b+bb+lepb tag discriminator'), - Plot1D('btagRobustParTAK4CvB', 'btagRobustParTAK4CvB', 20, -1, 1, 'RobustParTAK4 c vs b+bb+lepb discriminator'), - Plot1D('btagRobustParTAK4CvL', 'btagRobustParTAK4CvL', 20, -1, 1, 'RobustParTAK4 c vs uds+g discriminator'), - Plot1D('btagRobustParTAK4QG', 'btagRobustParTAK4QG', 20, -1, 1, 'RobustParTAK4 g vs uds discriminator'), + Plot1D('btagUParTAK4B', 'btagUParTAK4B', 20, 0, 1, 'UnifiedParT b vs. udscg discriminator'), + Plot1D('btagUParTAK4CvB', 'btagUParTAK4CvB', 20, -1, 1, 'UnifiedParT c vs. b discriminator'), + Plot1D('btagUParTAK4CvL', 'btagUParTAK4CvL', 20, -1, 1, 'UnifiedParT c vs. udsg discriminator'), + Plot1D('btagUParTAK4QG', 'btagUParTAK4QG', 20, -1, 1, 'UnifiedParT q (udsbc) vs. g discriminator'), + Plot1D('btagUParTAK4TauVJet', 'btagUParTAK4TauVJet', 20, -1, 1, 'UnifiedParT tau vs. jet discriminator'), + Plot1D('btagUParTCvNotB', 'btagUParTCvNotB', 20, 0, 1, 'UnifiedParT C vs notB discriminator'), Plot1D('cRegCorr', 'cRegCorr', 20, 0.6, 2, 'pt correction for c-jet energy regression'), Plot1D('cRegRes', 'cRegRes', 20, 0.05, 0.4, 'res on pt corrected with c-jet regression'), Plot1D('btagPNetB', 'btagPNetB', 20, 0, 1, 'ParticleNet b tag discriminator'), diff --git a/PhysicsTools/NanoAOD/python/nano_cff.py b/PhysicsTools/NanoAOD/python/nano_cff.py index cec1cd27dac30..233adeb51d711 100644 --- a/PhysicsTools/NanoAOD/python/nano_cff.py +++ b/PhysicsTools/NanoAOD/python/nano_cff.py @@ -203,13 +203,15 @@ def nanoAOD_customizeCommon(process): run2_nanoAOD_106Xv2.toModify( nanoAOD_addDeepInfoAK4CHS_switch, nanoAOD_addParticleNet_switch=True, - nanoAOD_addRobustParTAK4Tag_switch=True, + nanoAOD_addRobustParTAK4Tag_switch=False, + nanoAOD_addUnifiedParTAK4Tag_switch=True, ) # This function is defined in jetsAK4_Puppi_cff.py process = nanoAOD_addDeepInfoAK4(process, addParticleNet=nanoAOD_addDeepInfoAK4_switch.nanoAOD_addParticleNet_switch, - addRobustParTAK4=nanoAOD_addDeepInfoAK4_switch.nanoAOD_addRobustParTAK4Tag_switch + addRobustParTAK4=nanoAOD_addDeepInfoAK4_switch.nanoAOD_addRobustParTAK4Tag_switch, + addUnifiedParTAK4=nanoAOD_addDeepInfoAK4_switch.nanoAOD_addUnifiedParTAK4Tag_switch ) # This function is defined in jetsAK4_CHS_cff.py @@ -217,7 +219,8 @@ def nanoAOD_customizeCommon(process): addDeepBTag=nanoAOD_addDeepInfoAK4CHS_switch.nanoAOD_addDeepBTag_switch, addDeepFlavour=nanoAOD_addDeepInfoAK4CHS_switch.nanoAOD_addDeepFlavourTag_switch, addParticleNet=nanoAOD_addDeepInfoAK4CHS_switch.nanoAOD_addParticleNet_switch, - addRobustParTAK4=nanoAOD_addDeepInfoAK4CHS_switch.nanoAOD_addRobustParTAK4Tag_switch + addRobustParTAK4=nanoAOD_addDeepInfoAK4CHS_switch.nanoAOD_addRobustParTAK4Tag_switch, + addUnifiedParTAK4=nanoAOD_addDeepInfoAK4CHS_switch.nanoAOD_addUnifiedParTAK4Tag_switch ) # This function is defined in jetsAK8_cff.py diff --git a/PhysicsTools/PatAlgos/python/recoLayer0/bTagging_cff.py b/PhysicsTools/PatAlgos/python/recoLayer0/bTagging_cff.py index 361c2fd2814ae..c3efd2dc0dc7c 100644 --- a/PhysicsTools/PatAlgos/python/recoLayer0/bTagging_cff.py +++ b/PhysicsTools/PatAlgos/python/recoLayer0/bTagging_cff.py @@ -43,6 +43,8 @@ , 'pfNegativeDeepFlavourTagInfos' # ParticleTransformerAK4 tag infos , 'pfParticleTransformerAK4TagInfos' + # UnifiedParticleTransformerAK4 tag infos + , 'pfUnifiedParticleTransformerAK4TagInfos' # DeepDoubleB/C tag infos , 'pfDeepDoubleXTagInfos' # DeepBoostedJet tag infos @@ -338,3 +340,21 @@ for disc in _pfParticleTransformerAK4JetTagsMetaDiscrs: supportedMetaDiscr[disc] = _pfParticleTransformerAK4JetTagsProbs # ----------------------------------- + +# ----------------------------------- +# setup UnifiedParticleTransformer AK4 +from RecoBTag.ONNXRuntime.pfUnifiedParticleTransformerAK4_cff import _pfUnifiedParticleTransformerAK4JetTagsProbs, _pfUnifiedParticleTransformerAK4JetTagsMetaDiscrs +# update supportedBtagDiscr +for disc in _pfUnifiedParticleTransformerAK4JetTagsProbs + _pfUnifiedParticleTransformerAK4JetTagsMetaDiscrs: + supportedBtagDiscr[disc] = [["pfUnifiedParticleTransformerAK4TagInfos"]] +# update supportedMetaDiscr +for disc in _pfUnifiedParticleTransformerAK4JetTagsMetaDiscrs: + supportedMetaDiscr[disc] = _pfUnifiedParticleTransformerAK4JetTagsProbs +# ----------------------------------- + +# ----------------------------------- +# setup Negative ParticleTransformer AK4 +from RecoBTag.ONNXRuntime.pfParticleTransformerAK4_cff import _pfNegativeParticleTransformerAK4JetTagsProbs +# update supportedBtagDiscr +for disc in _pfNegativeParticleTransformerAK4JetTagsProbs: + supportedBtagDiscr[disc] = [["pfNegativeParticleTransformerAK4TagInfos"]] diff --git a/PhysicsTools/PatAlgos/python/slimming/applyDeepBtagging_cff.py b/PhysicsTools/PatAlgos/python/slimming/applyDeepBtagging_cff.py index f566769f6b4ee..69c62997c27af 100644 --- a/PhysicsTools/PatAlgos/python/slimming/applyDeepBtagging_cff.py +++ b/PhysicsTools/PatAlgos/python/slimming/applyDeepBtagging_cff.py @@ -15,6 +15,7 @@ def applyDeepBtagging(process, postfix=""): from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK4_cff import _pfParticleNetFromMiniAODAK4CHSCentralJetTagsAll as pfParticleNetFromMiniAODAK4CHSCentralJetTagsAll from RecoBTag.ONNXRuntime.pfParticleNetFromMiniAODAK4_cff import _pfParticleNetFromMiniAODAK4CHSForwardJetTagsAll as pfParticleNetFromMiniAODAK4CHSForwardJetTagsAll from RecoBTag.ONNXRuntime.pfParticleTransformerAK4_cff import _pfParticleTransformerAK4JetTagsAll as pfParticleTransformerAK4JetTagsAll + from RecoBTag.ONNXRuntime.pfUnifiedParticleTransformerAK4_cff import _pfUnifiedParticleTransformerAK4JetTagsAll as pfUnifiedParticleTransformerAK4JetTagsAll # update slimmed jets to include DeepFlavour (keep same name) # make clone for DeepFlavour-less slimmed jets, so output name is preserved @@ -66,7 +67,7 @@ def applyDeepBtagging(process, postfix=""): 'pfDeepFlavourJetTags:probg') + pfParticleNetFromMiniAODAK4PuppiCentralJetTagsAll + pfParticleNetFromMiniAODAK4PuppiForwardJetTagsAll - + pfParticleTransformerAK4JetTagsAll + + pfUnifiedParticleTransformerAK4JetTagsAll ) updateJetCollection( diff --git a/PhysicsTools/PatAlgos/python/tools/jetTools.py b/PhysicsTools/PatAlgos/python/tools/jetTools.py index 5854c1481c874..41307309ed1a0 100644 --- a/PhysicsTools/PatAlgos/python/tools/jetTools.py +++ b/PhysicsTools/PatAlgos/python/tools/jetTools.py @@ -681,7 +681,7 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou flip = flip), process, task) - if 'ParticleTransformerAK4TagInfos' in btagInfo: + if ('ParticleTransformerAK4TagInfos' in btagInfo) and ('UnifiedParticleTransformerAK4TagInfos' not in btagInfo): #We also have to veto UParT is we select ParT svUsed = svSource if btagInfo == 'pfNegativeParticleTransformerAK4TagInfos': svUsed = cms.InputTag(btagPrefix+'inclusiveCandidateNegativeSecondaryVertices'+labelName+postfix) @@ -711,6 +711,38 @@ def setupBTagging(process, jetSource, pfCandidates, explicitJTA, pvSource, svSou is_weighted_jet = is_weighted_jet, flip = flip), process, task) + + if 'UnifiedParticleTransformerAK4TagInfos' in btagInfo: + svUsed = svSource + if btagInfo == 'pfNegativeUnifiedParticleTransformerAK4TagInfos': + svUsed = cms.InputTag(btagPrefix+'inclusiveCandidateNegativeSecondaryVertices'+labelName+postfix) + flip = True + else: + flip = False + # use right input tags when running with RECO PF candidates, which actually + # depends of whether jets use "particleFlow" + if pfCandidates.value() == 'packedPFCandidates': + puppi_value_map = setupPuppiForPackedPF(process)[0] + vertex_associator = cms.InputTag("") + else: + puppi_value_map = cms.InputTag("puppi") + vertex_associator = cms.InputTag("primaryVertexAssociation","original") + + # If this jet is a puppi jet, then set is_weighted_jet to true. + is_weighted_jet = False + if ('puppi' in jetSource.value().lower()): + is_weighted_jet = True + addToProcessAndTask(btagPrefix+btagInfo+labelName+postfix, + btag.pfUnifiedParticleTransformerAK4TagInfos.clone( + jets = jetSource, + vertices=pvSource, + secondary_vertices=svUsed, + puppi_value_map = puppi_value_map, + vertex_associator = vertex_associator, + is_weighted_jet = is_weighted_jet, + flip = flip), + process, task) + if btagInfo == 'pfDeepDoubleXTagInfos': # can only run on PAT jets, so the updater needs to be used if 'updated' not in jetSource.value().lower(): diff --git a/RecoBTag/Configuration/python/RecoBTag_cff.py b/RecoBTag/Configuration/python/RecoBTag_cff.py index fab7ac28b3475..2602b0ccb75cc 100644 --- a/RecoBTag/Configuration/python/RecoBTag_cff.py +++ b/RecoBTag/Configuration/python/RecoBTag_cff.py @@ -14,6 +14,7 @@ from RecoBTag.ONNXRuntime.pfParticleNet_cff import * from RecoBTag.ONNXRuntime.pfParticleNetAK4_cff import * from RecoBTag.ONNXRuntime.pfParticleTransformerAK4_cff import * +from RecoBTag.ONNXRuntime.pfUnifiedParticleTransformerAK4_cff import * from RecoVertex.AdaptiveVertexFinder.inclusiveVertexing_cff import * from RecoBTag.PixelCluster.pixelClusterTagInfos_cfi import * diff --git a/RecoBTag/FeatureTools/interface/ChargedCandidateConverter.h b/RecoBTag/FeatureTools/interface/ChargedCandidateConverter.h index 02dc62ce7384d..ff711d3838505 100644 --- a/RecoBTag/FeatureTools/interface/ChargedCandidateConverter.h +++ b/RecoBTag/FeatureTools/interface/ChargedCandidateConverter.h @@ -57,6 +57,7 @@ namespace btagbtvdeep { c_pf_features.btagPf_trackSip2dVal = catch_infs_and_bound(trackSip2dVal, 0, -1, 70); c_pf_features.btagPf_trackSip2dSig = catch_infs_and_bound(trackSip2dSig, 0, -1, 4e4); c_pf_features.btagPf_trackJetDistVal = catch_infs_and_bound(track_info.getTrackJetDistVal(), 0, -20, 1); + c_pf_features.btagPf_trackDecayLen = track_info.getTrackJetDecayLen(); c_pf_features.drminsv = catch_infs_and_bound(drminpfcandsv, 0, -1. * jetR, 0, -1. * jetR); c_pf_features.distminsv = distminpfcandsv; diff --git a/RecoBTag/FeatureTools/interface/LostTracksConverter.h b/RecoBTag/FeatureTools/interface/LostTracksConverter.h new file mode 100644 index 0000000000000..6c1d7283adbac --- /dev/null +++ b/RecoBTag/FeatureTools/interface/LostTracksConverter.h @@ -0,0 +1,81 @@ +#ifndef RecoBTag_FeatureTools_LostTracksConverter_h +#define RecoBTag_FeatureTools_LostTracksConverter_h + +#include "RecoBTag/FeatureTools/interface/deep_helpers.h" +#include "RecoBTag/FeatureTools/interface/TrackInfoBuilder.h" +#include "DataFormats/BTauReco/interface/LostTracksFeatures.h" + +#include "DataFormats/PatCandidates/interface/PackedCandidate.h" +#include "DataFormats/ParticleFlowCandidate/interface/PFCandidate.h" +#include "DataFormats/PatCandidates/interface/Jet.h" + +namespace btagbtvdeep { + + template + void commonCandidateToFeatures(const CandidateType* c_pf, + const reco::Jet& jet, + const TrackInfoBuilder& track_info, + const bool& isWeightedJet, + const float& drminpfcandsv, + const float& jetR, + const float& puppiw, + LostTracksFeatures& lt_features, + const bool flip = false, + const float& distminpfcandsv = 0) { + float trackSip2dVal = track_info.getTrackSip2dVal(); + float trackSip2dSig = track_info.getTrackSip2dSig(); + float trackSip3dVal = track_info.getTrackSip3dVal(); + float trackSip3dSig = track_info.getTrackSip3dSig(); + if (flip == true) { + trackSip2dVal = -trackSip2dVal; + trackSip2dSig = -trackSip2dSig; + trackSip3dSig = -trackSip3dSig; + trackSip3dVal = -trackSip3dVal; + } + + lt_features.btagPf_trackEtaRel = catch_infs_and_bound(track_info.getTrackEtaRel(), 0, -5, 15); + lt_features.btagPf_trackPtRel = catch_infs_and_bound(track_info.getTrackPtRel(), 0, -1, 4); + lt_features.btagPf_trackPPar = catch_infs_and_bound(track_info.getTrackPPar(), 0, -1e5, 1e5); + lt_features.btagPf_trackDeltaR = catch_infs_and_bound(track_info.getTrackDeltaR(), 0, -5, 5); + lt_features.btagPf_trackPParRatio = catch_infs_and_bound(track_info.getTrackPParRatio(), 0, -10, 100); + lt_features.btagPf_trackSip3dVal = catch_infs_and_bound(trackSip3dVal, 0, -1, 1e5); + lt_features.btagPf_trackSip3dSig = catch_infs_and_bound(trackSip3dSig, 0, -1, 4e4); + lt_features.btagPf_trackSip2dVal = catch_infs_and_bound(trackSip2dVal, 0, -1, 70); + lt_features.btagPf_trackSip2dSig = catch_infs_and_bound(trackSip2dSig, 0, -1, 4e4); + lt_features.btagPf_trackJetDistVal = catch_infs_and_bound(track_info.getTrackJetDistVal(), 0, -20, 1); + + lt_features.drminsv = catch_infs_and_bound(drminpfcandsv, 0, -1. * jetR, 0, -1. * jetR); + + lt_features.pt = c_pf->pt(); + lt_features.eta = c_pf->eta(); + lt_features.phi = c_pf->phi(); + lt_features.e = c_pf->energy(); + } + + void packedCandidateToFeatures(const pat::PackedCandidate* c_pf, + const pat::Jet& jet, + const TrackInfoBuilder& track_info, + const bool isWeightedJet, + const float drminpfcandsv, + const float jetR, + const float puppiw, + LostTracksFeatures& lt_features, + const bool flip = false, + const float distminpfcandsv = 0); + + void recoCandidateToFeatures(const reco::PFCandidate* c_pf, + const reco::Jet& jet, + const TrackInfoBuilder& track_info, + const bool isWeightedJet, + const float drminpfcandsv, + const float jetR, + const float puppiw, + const int pv_ass_quality, + const reco::VertexRef& pv, + LostTracksFeatures& lt_features, + const bool flip = false, + const float distminpfcandsv = 0); + +} // namespace btagbtvdeep + +#endif //RecoBTag_FeatureTools_LostTracksConverter_h diff --git a/RecoBTag/FeatureTools/interface/TrackInfoBuilder.h b/RecoBTag/FeatureTools/interface/TrackInfoBuilder.h index c9c6cc47c500b..44bb016642079 100644 --- a/RecoBTag/FeatureTools/interface/TrackInfoBuilder.h +++ b/RecoBTag/FeatureTools/interface/TrackInfoBuilder.h @@ -31,6 +31,7 @@ namespace btagbtvdeep { const float getTrackSip2dVal() const { return trackSip2dVal_; } const float getTrackSip3dSig() const { return trackSip3dSig_; } const float getTrackSip3dVal() const { return trackSip3dVal_; } + const float getTrackJetDecayLen() const { return trackJetDecayLen_; } private: edm::ESHandle builder_; @@ -50,6 +51,7 @@ namespace btagbtvdeep { float trackJetDistVal_; float trackJetDistSig_; + float trackJetDecayLen_; }; } // namespace btagbtvdeep diff --git a/RecoBTag/FeatureTools/plugins/UnifiedParticleTransformerAK4TagInfoProducer.cc b/RecoBTag/FeatureTools/plugins/UnifiedParticleTransformerAK4TagInfoProducer.cc new file mode 100644 index 0000000000000..349da4f98f797 --- /dev/null +++ b/RecoBTag/FeatureTools/plugins/UnifiedParticleTransformerAK4TagInfoProducer.cc @@ -0,0 +1,530 @@ +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/stream/EDProducer.h" + +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" + +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/Utilities/interface/StreamID.h" +#include "FWCore/Utilities/interface/ESGetToken.h" + +#include "DataFormats/PatCandidates/interface/Jet.h" +#include "DataFormats/PatCandidates/interface/PackedCandidate.h" + +#include "DataFormats/BTauReco/interface/ShallowTagInfo.h" + +#include "TrackingTools/TransientTrack/interface/TransientTrackBuilder.h" +#include "TrackingTools/Records/interface/TransientTrackRecord.h" + +#include "DataFormats/BTauReco/interface/UnifiedParticleTransformerAK4TagInfo.h" +#include "DataFormats/BTauReco/interface/UnifiedParticleTransformerAK4Features.h" + +#include "RecoBTag/FeatureTools/interface/JetConverter.h" +#include "RecoBTag/FeatureTools/interface/ShallowTagInfoConverter.h" +#include "RecoBTag/FeatureTools/interface/SecondaryVertexConverter.h" +#include "RecoBTag/FeatureTools/interface/NeutralCandidateConverter.h" +#include "RecoBTag/FeatureTools/interface/ChargedCandidateConverter.h" +#include "RecoBTag/FeatureTools/interface/LostTracksConverter.h" + +#include "RecoBTag/FeatureTools/interface/TrackInfoBuilder.h" +#include "RecoBTag/FeatureTools/interface/sorting_modules.h" + +#include "DataFormats/VertexReco/interface/VertexFwd.h" +#include "DataFormats/Candidate/interface/VertexCompositePtrCandidate.h" + +#include "RecoBTag/FeatureTools/interface/deep_helpers.h" + +#include "FWCore/ParameterSet/interface/Registry.h" +#include "FWCore/Common/interface/Provenance.h" +#include "DataFormats/Provenance/interface/ProductProvenance.h" + +#include "DataFormats/BTauReco/interface/SeedingTrackFeatures.h" +#include "DataFormats/BTauReco/interface/TrackPairFeatures.h" +#include "RecoBTag/FeatureTools/interface/TrackPairInfoBuilder.h" +#include "RecoBTag/FeatureTools/interface/SeedingTrackInfoBuilder.h" +#include "RecoBTag/FeatureTools/interface/SeedingTracksConverter.h" + +#include "FWCore/Framework/interface/ESHandle.h" +#include "FWCore/Framework/interface/EventSetup.h" +#include "RecoBTag/TrackProbability/interface/HistogramProbabilityEstimator.h" +class HistogramProbabilityEstimator; +#include + +#include +#include "CondFormats/BTauObjects/interface/TrackProbabilityCalibration.h" +#include "CondFormats/DataRecord/interface/BTagTrackProbability2DRcd.h" +#include "CondFormats/DataRecord/interface/BTagTrackProbability3DRcd.h" +#include "FWCore/Framework/interface/EventSetupRecord.h" +#include "FWCore/Framework/interface/EventSetupRecordImplementation.h" +#include "FWCore/Framework/interface/EventSetupRecordKey.h" +#include "DataFormats/Common/interface/AssociationMap.h" + +class UnifiedParticleTransformerAK4TagInfoProducer : public edm::stream::EDProducer<> { +public: + explicit UnifiedParticleTransformerAK4TagInfoProducer(const edm::ParameterSet&); + ~UnifiedParticleTransformerAK4TagInfoProducer() override = default; + + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + +private: + typedef std::vector UnifiedParticleTransformerAK4TagInfoCollection; + typedef reco::VertexCompositePtrCandidateCollection SVCollection; + typedef reco::VertexCollection VertexCollection; + typedef edm::AssociationMap> JetMatchMap; + + void beginStream(edm::StreamID) override {} + void produce(edm::Event&, const edm::EventSetup&) override; + void endStream() override {} + + const double jet_radius_; + const double min_candidate_pt_; + const bool flip_; + + const edm::EDGetTokenT> jet_token_; + const edm::EDGetTokenT vtx_token_; + const edm::EDGetTokenT> lt_token_; + const edm::EDGetTokenT sv_token_; + edm::EDGetTokenT unsubjet_map_token_; + edm::EDGetTokenT> puppi_value_map_token_; + edm::EDGetTokenT> pvasq_value_map_token_; + edm::EDGetTokenT> pvas_token_; + const edm::EDGetTokenT> candidateToken_; + const edm::ESGetToken track_builder_token_; + bool use_puppi_value_map_; + bool use_pvasq_value_map_; + bool use_unsubjet_map_; + + const bool fallback_puppi_weight_; + const bool fallback_vertex_association_; + + const bool is_weighted_jet_; + + const double min_jet_pt_; + const double max_jet_eta_; +}; + +UnifiedParticleTransformerAK4TagInfoProducer::UnifiedParticleTransformerAK4TagInfoProducer( + const edm::ParameterSet& iConfig) + : jet_radius_(iConfig.getParameter("jet_radius")), + min_candidate_pt_(iConfig.getParameter("min_candidate_pt")), + flip_(iConfig.getParameter("flip")), + jet_token_(consumes>(iConfig.getParameter("jets"))), + vtx_token_(consumes(iConfig.getParameter("vertices"))), + lt_token_(consumes>(iConfig.getParameter("losttracks"))), + sv_token_(consumes(iConfig.getParameter("secondary_vertices"))), + candidateToken_(consumes>(iConfig.getParameter("candidates"))), + track_builder_token_( + esConsumes(edm::ESInputTag("", "TransientTrackBuilder"))), + use_puppi_value_map_(false), + use_pvasq_value_map_(false), + use_unsubjet_map_(false), + fallback_puppi_weight_(iConfig.getParameter("fallback_puppi_weight")), + fallback_vertex_association_(iConfig.getParameter("fallback_vertex_association")), + is_weighted_jet_(iConfig.getParameter("is_weighted_jet")), + min_jet_pt_(iConfig.getParameter("min_jet_pt")), + max_jet_eta_(iConfig.getParameter("max_jet_eta")) { + produces(); + + const auto& puppi_value_map_tag = iConfig.getParameter("puppi_value_map"); + if (!puppi_value_map_tag.label().empty()) { + puppi_value_map_token_ = consumes>(puppi_value_map_tag); + use_puppi_value_map_ = true; + } else if (is_weighted_jet_) { + throw edm::Exception(edm::errors::Configuration, + "puppi_value_map is not set but jet is weighted. Must set puppi_value_map."); + } + + const auto& pvas_tag = iConfig.getParameter("vertex_associator"); + if (!pvas_tag.label().empty()) { + pvasq_value_map_token_ = consumes>(pvas_tag); + pvas_token_ = consumes>(pvas_tag); + use_pvasq_value_map_ = true; + } + + const auto& unsubjet_map_tag = iConfig.getParameter("unsubjet_map"); + if (!unsubjet_map_tag.label().empty()) { + unsubjet_map_token_ = consumes(unsubjet_map_tag); + use_unsubjet_map_ = true; + } +} + +void UnifiedParticleTransformerAK4TagInfoProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + // pfUnifiedParticleTransformerAK4TagInfos + edm::ParameterSetDescription desc; + desc.add("jet_radius", 0.4); + desc.add("min_candidate_pt", 0.10); + desc.add("flip", false); + desc.add("vertices", edm::InputTag("offlinePrimaryVertices")); + desc.add("losttracks", edm::InputTag("lostTracks")); + desc.add("puppi_value_map", edm::InputTag("puppi")); + desc.add("secondary_vertices", edm::InputTag("inclusiveCandidateSecondaryVertices")); + desc.add("jets", edm::InputTag("ak4PFJetsCHS")); + desc.add("unsubjet_map", {}); + desc.add("candidates", edm::InputTag("packedPFCandidates")); + desc.add("vertex_associator", edm::InputTag("primaryVertexAssociation", "original")); + desc.add("fallback_puppi_weight", false); + desc.add("fallback_vertex_association", false); + desc.add("is_weighted_jet", false); + desc.add("min_jet_pt", 15.0); + desc.add("max_jet_eta", 2.5); + descriptions.add("pfUnifiedParticleTransformerAK4TagInfos", desc); +} + +void UnifiedParticleTransformerAK4TagInfoProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) { + auto output_tag_infos = std::make_unique(); + edm::Handle> jets; + iEvent.getByToken(jet_token_, jets); + + edm::Handle unsubjet_map; + if (use_unsubjet_map_) + iEvent.getByToken(unsubjet_map_token_, unsubjet_map); + + edm::Handle vtxs; + iEvent.getByToken(vtx_token_, vtxs); + if (vtxs->empty()) { + // produce empty TagInfos in case no primary vertex + iEvent.put(std::move(output_tag_infos)); + return; // exit event + } + + edm::Handle> LTs; + iEvent.getByToken(lt_token_, LTs); + + // reference to primary vertex + const auto& pv = vtxs->at(0); + + edm::Handle> tracks; + iEvent.getByToken(candidateToken_, tracks); + + edm::Handle svs; + iEvent.getByToken(sv_token_, svs); + + edm::Handle> puppi_value_map; + if (use_puppi_value_map_) { + iEvent.getByToken(puppi_value_map_token_, puppi_value_map); + } + + edm::Handle> pvasq_value_map; + edm::Handle> pvas; + if (use_pvasq_value_map_) { + iEvent.getByToken(pvasq_value_map_token_, pvasq_value_map); + iEvent.getByToken(pvas_token_, pvas); + } + + edm::ESHandle track_builder = iSetup.getHandle(track_builder_token_); + + for (std::size_t jet_n = 0; jet_n < jets->size(); jet_n++) { + // create data containing structure + btagbtvdeep::UnifiedParticleTransformerAK4Features features; + + // reco jet reference (use as much as possible) + const auto& jet = jets->at(jet_n); + if (jet.pt() < 15.0) { + features.is_filled = false; + } + if (std::abs(jet.eta()) > 2.5) { + features.is_filled = false; + } + // dynamical casting to pointers, null if not possible + const auto* pf_jet = dynamic_cast(&jet); + const auto* pat_jet = dynamic_cast(&jet); + edm::RefToBase jet_ref(jets, jet_n); + const auto& unsubJet = + (use_unsubjet_map_ && (*unsubjet_map)[jet_ref].isNonnull()) ? *(*unsubjet_map)[jet_ref] : jet; + + if (features.is_filled) { + math::XYZVector jet_dir = jet.momentum().Unit(); + GlobalVector jet_ref_track_dir(jet.px(), jet.py(), jet.pz()); + + // copy which will be sorted + auto svs_sorted = *svs; + // sort by dxy + std::sort(svs_sorted.begin(), svs_sorted.end(), [&pv](const auto& sva, const auto& svb) { + return btagbtvdeep::sv_vertex_comparator(sva, svb, pv); + }); + // fill features from secondary vertices + for (const auto& sv : svs_sorted) { + if (reco::deltaR2(sv, jet_dir) > (jet_radius_ * jet_radius_)) + continue; + else { + features.sv_features.emplace_back(); + // in C++17 could just get from emplace_back output + auto& sv_features = features.sv_features.back(); + btagbtvdeep::svToFeatures(sv, pv, jet, sv_features, flip_); + } + } + + // stuff required for dealing with pf candidates and lost tracks + std::vector> c_sorted, n_sorted, lt_sorted; + // to cache the TrackInfo + std::map trackinfos; + std::map lt_trackinfos; + // unsorted reference to sv + const auto& svs_unsorted = *svs; + std::vector ltPtrs; + static constexpr size_t max_lt_ = 5; + + //Adding the lost tracks associated with the jets + for (size_t i = 0; i < LTs->size(); ++i) { + auto cand = LTs->ptrAt(i); + if ((reco::deltaR(*cand, jet) < 0.2)) { + const auto* PackedCandidate_ = dynamic_cast(&(*cand)); + if (PackedCandidate_) { + if (PackedCandidate_->pt() < 1.0) + continue; + auto& trackinfo = lt_trackinfos.emplace(i, track_builder).first->second; + trackinfo.buildTrackInfo(PackedCandidate_, jet_dir, jet_ref_track_dir, pv); + + lt_sorted.emplace_back(i, + trackinfo.getTrackSip2dSig(), + -btagbtvdeep::mindrsvpfcand(svs_unsorted, PackedCandidate_), + PackedCandidate_->pt() / jet.pt()); + + ltPtrs.push_back(cand); + } + } + } + + // sort lt collection + std::sort(lt_sorted.begin(), lt_sorted.end(), btagbtvdeep::SortingClass::compareByABCInv); + int n_ltcand_ = std::min(lt_sorted.size(), max_lt_); + + std::vector lt_sortedindices; + lt_sortedindices = btagbtvdeep::invertSortingVector(lt_sorted); + + // set right size to vectors + features.lt_features.clear(); + features.lt_features.resize(lt_sorted.size()); + + for (unsigned int i = 0; i < (unsigned int)n_ltcand_; i++) { + //auto cand = LTs->ptrAt(i); + //const auto *PackedCandidate_ = dynamic_cast(&(*cand)); + const auto* PackedCandidate_ = dynamic_cast(&(*ltPtrs.at(i))); + if (!PackedCandidate_) + continue; + if (PackedCandidate_->pt() < min_candidate_pt_) + continue; + + if (PackedCandidate_->charge() != 0) { + //auto reco_cand = dynamic_cast(cand); + float puppiw = PackedCandidate_->puppiWeight(); + + float drminpfcandsv = btagbtvdeep::mindrsvpfcand(svs_unsorted, PackedCandidate_); + float distminpfcandsv = 0; + + size_t entry = lt_sortedindices.at(i); + // get cached track info + auto& trackinfo = lt_trackinfos.emplace(i, track_builder).first->second; + trackinfo.buildTrackInfo(PackedCandidate_, jet_dir, jet_ref_track_dir, pv); + // get_ref to vector element + auto& lt_features = features.lt_features.at(entry); + + if (PackedCandidate_) { + if (PackedCandidate_->hasTrackDetails()) { + const reco::Track& PseudoTrack = PackedCandidate_->pseudoTrack(); + reco::TransientTrack transientTrack; + transientTrack = track_builder->build(PseudoTrack); + distminpfcandsv = btagbtvdeep::mindistsvpfcand(svs_unsorted, transientTrack); + } + + btagbtvdeep::packedCandidateToFeatures(PackedCandidate_, + jet, + trackinfo, + is_weighted_jet_, + drminpfcandsv, + static_cast(jet_radius_), + puppiw, + lt_features, + flip_, + distminpfcandsv); + } + } + } + + // fill collection, from DeepTNtuples plus some styling + for (unsigned int i = 0; i < unsubJet.numberOfDaughters(); i++) { + auto cand = unsubJet.daughter(i); + if (cand) { + // candidates under 100MeV (configurable) are not considered + // might change if we use also white-listing + if (cand->pt() < min_candidate_pt_) + continue; + if (cand->charge() != 0) { + auto& trackinfo = trackinfos.emplace(i, track_builder).first->second; + trackinfo.buildTrackInfo(cand, jet_dir, jet_ref_track_dir, pv); + + c_sorted.emplace_back(i, + trackinfo.getTrackSip2dSig(), + -btagbtvdeep::mindrsvpfcand(svs_unsorted, cand), + cand->pt() / jet.pt()); + } else { + n_sorted.emplace_back(i, -1, -btagbtvdeep::mindrsvpfcand(svs_unsorted, cand), cand->pt() / jet.pt()); + } + } + } + + // sort collections (open the black-box if you please) + std::sort(c_sorted.begin(), c_sorted.end(), btagbtvdeep::SortingClass::compareByABCInv); + std::sort(n_sorted.begin(), n_sorted.end(), btagbtvdeep::SortingClass::compareByABCInv); + + std::vector c_sortedindices, n_sortedindices; + + // this puts 0 everywhere and the right position in ind + c_sortedindices = btagbtvdeep::invertSortingVector(c_sorted); + n_sortedindices = btagbtvdeep::invertSortingVector(n_sorted); + + // set right size to vectors + features.c_pf_features.clear(); + features.c_pf_features.resize(c_sorted.size()); + features.n_pf_features.clear(); + features.n_pf_features.resize(n_sorted.size()); + + for (unsigned int i = 0; i < unsubJet.numberOfDaughters(); i++) { + // get pointer and check that is correct + auto cand = dynamic_cast(unsubJet.daughter(i)); + if (!cand) + continue; + // candidates under 100MeV are not considered + // might change if we use also white-listing + if (cand->pt() < 0.100) + continue; + + auto packed_cand = dynamic_cast(cand); + auto reco_cand = dynamic_cast(cand); + + // need some edm::Ptr or edm::Ref if reco candidates + reco::PFCandidatePtr reco_ptr; + if (pf_jet) { + reco_ptr = pf_jet->getPFConstituent(i); + } else if (pat_jet && reco_cand) { + reco_ptr = pat_jet->getPFConstituent(i); + } + + reco::CandidatePtr cand_ptr; + if (pat_jet) { + cand_ptr = pat_jet->sourceCandidatePtr(i); + } + + // + // Access puppi weight from ValueMap. + // + float puppiw = 1.0; // Set to fallback value + + if (reco_cand) { + if (use_puppi_value_map_) + puppiw = (*puppi_value_map)[reco_ptr]; + else if (!fallback_puppi_weight_) { + throw edm::Exception(edm::errors::InvalidReference, "PUPPI value map missing") + << "use fallback_puppi_weight option to use " << puppiw << " for reco_cand as default"; + } + } else if (packed_cand) { + if (use_puppi_value_map_) + puppiw = (*puppi_value_map)[cand_ptr]; + else if (!fallback_puppi_weight_) { + throw edm::Exception(edm::errors::InvalidReference, "PUPPI value map missing") + << "use fallback_puppi_weight option to use " << puppiw << " for packed_cand as default"; + } + } else { + throw edm::Exception(edm::errors::InvalidReference) + << "Cannot convert to either reco::PFCandidate or pat::PackedCandidate"; + } + + float drminpfcandsv = btagbtvdeep::mindrsvpfcand(svs_unsorted, cand); + float distminpfcandsv = 0; + if (cand->charge() != 0) { + // is charged candidate + auto entry = c_sortedindices.at(i); + + // get cached track info + auto& trackinfo = trackinfos.at(i); + + // get_ref to vector element + auto& c_pf_features = features.c_pf_features.at(entry); + // fill feature structure + if (packed_cand) { + if (packed_cand->hasTrackDetails()) { + const reco::Track& PseudoTrack = packed_cand->pseudoTrack(); + reco::TransientTrack transientTrack; + transientTrack = track_builder->build(PseudoTrack); + distminpfcandsv = btagbtvdeep::mindistsvpfcand(svs_unsorted, transientTrack); + } + + btagbtvdeep::packedCandidateToFeatures(packed_cand, + jet, + trackinfo, + is_weighted_jet_, + drminpfcandsv, + static_cast(jet_radius_), + puppiw, + c_pf_features, + flip_, + distminpfcandsv); + } else if (reco_cand) { + // get vertex association quality + int pv_ass_quality = 0; // fallback value + if (use_pvasq_value_map_) { + pv_ass_quality = (*pvasq_value_map)[reco_ptr]; + } else if (!fallback_vertex_association_) { + throw edm::Exception(edm::errors::InvalidReference, "vertex association missing") + << "use fallback_vertex_association option to use" << pv_ass_quality + << "as default quality and closest dz PV as criteria"; + } + // getting the PV as PackedCandidatesProducer + // but using not the slimmed but original vertices + auto ctrack = reco_cand->bestTrack(); + int pvi = -1; + float dist = 1e99; + for (size_t ii = 0; ii < vtxs->size(); ii++) { + float dz = (ctrack) ? std::abs(ctrack->dz(((*vtxs)[ii]).position())) : 0; + if (dz < dist) { + pvi = ii; + dist = dz; + } + } + auto PV = reco::VertexRef(vtxs, pvi); + if (use_pvasq_value_map_) { + const reco::VertexRef& PV_orig = (*pvas)[reco_ptr]; + if (PV_orig.isNonnull()) + PV = reco::VertexRef(vtxs, PV_orig.key()); + } + btagbtvdeep::recoCandidateToFeatures(reco_cand, + jet, + trackinfo, + is_weighted_jet_, + drminpfcandsv, + static_cast(jet_radius_), + puppiw, + pv_ass_quality, + PV, + c_pf_features, + flip_, + distminpfcandsv); + } + } else { + // is neutral candidate + auto entry = n_sortedindices.at(i); + // get_ref to vector element + auto& n_pf_features = features.n_pf_features.at(entry); + // fill feature structure + if (packed_cand) { + btagbtvdeep::packedCandidateToFeatures(packed_cand, + jet, + is_weighted_jet_, + drminpfcandsv, + static_cast(jet_radius_), + puppiw, + n_pf_features); + } else if (reco_cand) { + btagbtvdeep::recoCandidateToFeatures( + reco_cand, jet, is_weighted_jet_, drminpfcandsv, static_cast(jet_radius_), puppiw, n_pf_features); + } + } + } + } + output_tag_infos->emplace_back(features, jet_ref); + } + iEvent.put(std::move(output_tag_infos)); +} + +//define this as a plug-in +DEFINE_FWK_MODULE(UnifiedParticleTransformerAK4TagInfoProducer); diff --git a/RecoBTag/FeatureTools/src/ChargedCandidateConverter.cc b/RecoBTag/FeatureTools/src/ChargedCandidateConverter.cc index 5209c7d2818c4..a5661a61a8739 100644 --- a/RecoBTag/FeatureTools/src/ChargedCandidateConverter.cc +++ b/RecoBTag/FeatureTools/src/ChargedCandidateConverter.cc @@ -18,6 +18,13 @@ namespace btagbtvdeep { c_pf_features.vtx_ass = c_pf->pvAssociationQuality(); c_pf_features.puppiw = puppiw; + c_pf_features.charge = c_pf->charge(); + + c_pf_features.CaloFrac = c_pf->caloFraction(); + c_pf_features.HadFrac = c_pf->hcalFraction(); + c_pf_features.lostInnerHits = catch_infs(c_pf->lostInnerHits(), 2); + c_pf_features.numberOfPixelHits = catch_infs(c_pf->numberOfPixelHits(), -1); + c_pf_features.numberOfStripHits = catch_infs(c_pf->stripLayersWithMeasurement(), -1); // if PackedCandidate does not have TrackDetails this gives an Exception // because unpackCovariance might be called for pseudoTrack/bestTrack @@ -36,6 +43,27 @@ namespace btagbtvdeep { c_pf_features.dz = catch_infs(c_pf->dz()); c_pf_features.dxysig = c_pf->bestTrack() ? catch_infs(c_pf->dxy() / c_pf->dxyError()) : 0; c_pf_features.dzsig = c_pf->bestTrack() ? catch_infs(c_pf->dz() / c_pf->dzError()) : 0; + + float pdgid_; + if (abs(c_pf->pdgId()) == 11 and c_pf->charge() != 0) { + pdgid_ = 0.0; + } else if (abs(c_pf->pdgId()) == 13 and c_pf->charge() != 0) { + pdgid_ = 1.0; + } else if (abs(c_pf->pdgId()) == 22 and c_pf->charge() == 0) { + pdgid_ = 2.0; + } else if (abs(c_pf->pdgId()) != 22 and c_pf->charge() == 0 and abs(c_pf->pdgId()) != 1 and + abs(c_pf->pdgId()) != 2) { + pdgid_ = 3.0; + } else if (abs(c_pf->pdgId()) != 11 and abs(c_pf->pdgId()) != 13 and c_pf->charge() != 0) { + pdgid_ = 4.0; + } else if (c_pf->charge() == 0 and abs(c_pf->pdgId()) == 1) { + pdgid_ = 5.0; + } else if (c_pf->charge() == 0 and abs(c_pf->pdgId()) == 2) { + pdgid_ = 6.0; + } else { + pdgid_ = 7.0; + } + c_pf_features.pdgID = pdgid_; } void recoCandidateToFeatures(const reco::PFCandidate* c_pf, diff --git a/RecoBTag/FeatureTools/src/LostTracksConverter.cc b/RecoBTag/FeatureTools/src/LostTracksConverter.cc new file mode 100644 index 0000000000000..11fc316039c90 --- /dev/null +++ b/RecoBTag/FeatureTools/src/LostTracksConverter.cc @@ -0,0 +1,60 @@ +#include "RecoBTag/FeatureTools/interface/LostTracksConverter.h" + +namespace btagbtvdeep { + + void packedCandidateToFeatures(const pat::PackedCandidate* c_pf, + const pat::Jet& jet, + const TrackInfoBuilder& track_info, + const bool isWeightedJet, + const float drminpfcandsv, + const float jetR, + const float puppiw, + LostTracksFeatures& lt_features, + const bool flip, + const float distminpfcandsv) { + commonCandidateToFeatures( + c_pf, jet, track_info, isWeightedJet, drminpfcandsv, jetR, puppiw, lt_features, flip, distminpfcandsv); + + lt_features.puppiw = puppiw; + lt_features.charge = c_pf->charge(); + + lt_features.lostInnerHits = catch_infs(c_pf->lostInnerHits(), 2); + lt_features.numberOfPixelHits = catch_infs(c_pf->numberOfPixelHits(), -1); + lt_features.numberOfStripHits = catch_infs(c_pf->stripLayersWithMeasurement(), -1); + + // if PackedCandidate does not have TrackDetails this gives an Exception + // because unpackCovariance might be called for pseudoTrack/bestTrack + if (c_pf->hasTrackDetails()) { + const auto& pseudo_track = c_pf->pseudoTrack(); + lt_features.chi2 = catch_infs_and_bound(pseudo_track.normalizedChi2(), 300, -1, 300); + // this returns the quality enum not a mask. + lt_features.quality = pseudo_track.qualityMask(); + } else { + // default negative chi2 and loose track if notTrackDetails + lt_features.chi2 = catch_infs_and_bound(-1, 300, -1, 300); + lt_features.quality = (1 << reco::TrackBase::loose); + } + } + void recoCandidateToFeatures(const reco::PFCandidate* c_pf, + const reco::Jet& jet, + const TrackInfoBuilder& track_info, + const bool isWeightedJet, + const float drminpfcandsv, + const float jetR, + const float puppiw, + const int pv_ass_quality, + const reco::VertexRef& pv, + LostTracksFeatures& lt_features, + const bool flip, + const float distminpfcandsv) { + commonCandidateToFeatures( + c_pf, jet, track_info, isWeightedJet, drminpfcandsv, jetR, puppiw, lt_features, flip, distminpfcandsv); + + lt_features.puppiw = puppiw; + + const auto& pseudo_track = (c_pf->bestTrack()) ? *c_pf->bestTrack() : reco::Track(); + lt_features.chi2 = catch_infs_and_bound(std::floor(pseudo_track.normalizedChi2()), 300, -1, 300); + lt_features.quality = quality_from_pfcand(*c_pf); + } + +} // namespace btagbtvdeep diff --git a/RecoBTag/FeatureTools/src/TrackInfoBuilder.cc b/RecoBTag/FeatureTools/src/TrackInfoBuilder.cc index 57753af18595f..f75e4ef20b2e6 100644 --- a/RecoBTag/FeatureTools/src/TrackInfoBuilder.cc +++ b/RecoBTag/FeatureTools/src/TrackInfoBuilder.cc @@ -27,7 +27,8 @@ namespace btagbtvdeep { trackSip3dVal_(0), trackSip3dSig_(0), trackJetDistVal_(0), - trackJetDistSig_(0) {} + trackJetDistSig_(0), + trackJetDecayLen_(0) {} void TrackInfoBuilder::buildTrackInfo(const reco::Candidate *candidate, const math::XYZVector &jetDir, @@ -63,6 +64,7 @@ namespace btagbtvdeep { trackSip3dSig_ = 0.; trackJetDistVal_ = 0.; trackJetDistSig_ = 0.; + trackJetDecayLen_ = 0.; return; } @@ -84,12 +86,15 @@ namespace btagbtvdeep { Measurement1D meas_ip2d = IPTools::signedTransverseImpactParameter(transientTrack, refjetdirection, pv).second; Measurement1D meas_ip3d = IPTools::signedImpactParameter3D(transientTrack, refjetdirection, pv).second; Measurement1D jetdist = IPTools::jetTrackDistance(transientTrack, refjetdirection, pv).second; + Measurement1D decayl = IPTools::signedDecayLength3D(transientTrack, refjetdirection, pv).second; trackSip2dVal_ = static_cast(meas_ip2d.value()); trackSip2dSig_ = static_cast(meas_ip2d.significance()); trackSip3dVal_ = static_cast(meas_ip3d.value()); trackSip3dSig_ = static_cast(meas_ip3d.significance()); trackJetDistVal_ = static_cast(jetdist.value()); trackJetDistSig_ = static_cast(jetdist.significance()); + + trackJetDecayLen_ = static_cast(decayl.value()); } } // namespace btagbtvdeep diff --git a/RecoBTag/ONNXRuntime/plugins/UnifiedParticleTransformerAK4ONNXJetTagsProducer.cc b/RecoBTag/ONNXRuntime/plugins/UnifiedParticleTransformerAK4ONNXJetTagsProducer.cc new file mode 100644 index 0000000000000..a6864da0c3de5 --- /dev/null +++ b/RecoBTag/ONNXRuntime/plugins/UnifiedParticleTransformerAK4ONNXJetTagsProducer.cc @@ -0,0 +1,358 @@ +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/stream/EDProducer.h" + +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" + +#include "FWCore/Framework/interface/makeRefToBaseProdFrom.h" + +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/Utilities/interface/StreamID.h" + +#include "DataFormats/BTauReco/interface/JetTag.h" + +#include "DataFormats/BTauReco/interface/UnifiedParticleTransformerAK4TagInfo.h" +#include "DataFormats/BTauReco/interface/UnifiedParticleTransformerAK4Features.h" + +#include "PhysicsTools/ONNXRuntime/interface/ONNXRuntime.h" + +using namespace cms::Ort; + +class UnifiedParticleTransformerAK4ONNXJetTagsProducer : public edm::stream::EDProducer> { +public: + explicit UnifiedParticleTransformerAK4ONNXJetTagsProducer(const edm::ParameterSet&, const ONNXRuntime*); + ~UnifiedParticleTransformerAK4ONNXJetTagsProducer() override = default; + + static void fillDescriptions(edm::ConfigurationDescriptions&); + + static std::unique_ptr initializeGlobalCache(const edm::ParameterSet&); + static void globalEndJob(const ONNXRuntime*); + +private: + typedef std::vector TagInfoCollection; + typedef reco::JetTagCollection JetTagCollection; + + void produce(edm::Event&, const edm::EventSetup&) override; + + void make_inputs(btagbtvdeep::UnifiedParticleTransformerAK4Features features); + void get_input_sizes(const reco::FeaturesTagInfo taginfo); + + const edm::EDGetTokenT src_; + std::vector flav_names_; + std::vector input_names_; + std::vector output_names_; + + enum InputIndexes { + kChargedCandidates = 0, + kLostTracks = 1, + kNeutralCandidates = 2, + kVertices = 3, + kChargedCandidates4Vec = 4, + kLostTracks4Vec = 5, + kNeutralCandidates4Vec = 6, + kVertices4Vec = 7 + }; + unsigned n_cpf_; + constexpr static unsigned n_features_cpf_ = 25; + constexpr static unsigned n_pairwise_features_cpf_ = 4; + unsigned n_lt_; + constexpr static unsigned n_features_lt_ = 18; + constexpr static unsigned n_pairwise_features_lt_ = 4; + unsigned n_npf_; + constexpr static unsigned n_features_npf_ = 8; + constexpr static unsigned n_pairwise_features_npf_ = 4; + unsigned n_sv_; + constexpr static unsigned n_features_sv_ = 14; + constexpr static unsigned n_pairwise_features_sv_ = 4; + std::vector input_sizes_; + std::vector> input_shapes_; // shapes of each input group (-1 for dynamic axis) + + // hold the input data + FloatArrays data_; +}; + +UnifiedParticleTransformerAK4ONNXJetTagsProducer::UnifiedParticleTransformerAK4ONNXJetTagsProducer( + const edm::ParameterSet& iConfig, const ONNXRuntime* cache) + : src_(consumes(iConfig.getParameter("src"))), + flav_names_(iConfig.getParameter>("flav_names")), + input_names_(iConfig.getParameter>("input_names")), + output_names_(iConfig.getParameter>("output_names")) { + // get output names from flav_names + for (const auto& flav_name : flav_names_) { + produces(flav_name); + } +} + +void UnifiedParticleTransformerAK4ONNXJetTagsProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + // pfUnifiedParticleTransformerAK4JetTags + edm::ParameterSetDescription desc; + desc.add("src", edm::InputTag("pfUnifiedParticleTransformerAK4TagInfos")); + desc.add>( + "input_names", {"input_1", "input_2", "input_3", "input_4", "input_5", "input_6", "input_7", "input_8"}); + desc.add("model_path", edm::FileInPath("RecoBTag/Combined/data/UParTAK4/PUPPI/V00/UParTAK4.onnx")); + desc.add>("output_names", {"softmax"}); + desc.add>( + "flav_names", + std::vector{"probb", "probbb", "problepb", "probc", "probs", + "probu", "probd", "probg", "probele", "probmu", + "probtaup1h0p", "probtaup1h1p", "probtaup1h2p", "probtaup3h0p", "probtaup3h1p", + "probtaum1h0p", "probtaum1h1p", "probtaum1h2p", "probtaum3h0p", "probtaum3h1p", + "ptcorr", "ptreshigh", "ptreslow", "ptnu", "probemudata", + "probemumc", "probdimudata", "probdimumc", "probmutaudata", "probmutaumc"}); + + descriptions.add("pfUnifiedParticleTransformerAK4JetTags", desc); +} + +std::unique_ptr UnifiedParticleTransformerAK4ONNXJetTagsProducer::initializeGlobalCache( + const edm::ParameterSet& iConfig) { + return std::make_unique(iConfig.getParameter("model_path").fullPath()); +} + +void UnifiedParticleTransformerAK4ONNXJetTagsProducer::globalEndJob(const ONNXRuntime* cache) {} + +void UnifiedParticleTransformerAK4ONNXJetTagsProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) { + edm::Handle tag_infos; + iEvent.getByToken(src_, tag_infos); + + // initialize output collection + std::vector> output_tags; + if (!tag_infos->empty()) { + auto jet_ref = tag_infos->begin()->jet(); + auto ref2prod = edm::makeRefToBaseProdFrom(jet_ref, iEvent); + for (std::size_t i = 0; i < flav_names_.size(); i++) { + output_tags.emplace_back(std::make_unique(ref2prod)); + } + } else { + for (std::size_t i = 0; i < flav_names_.size(); i++) { + output_tags.emplace_back(std::make_unique()); + } + } + + for (unsigned jet_n = 0; jet_n < tag_infos->size(); ++jet_n) { + const auto& taginfo = (*tag_infos)[jet_n]; + std::vector outputs(flav_names_.size(), -1.0); + if (taginfo.features().is_filled) { + get_input_sizes(taginfo); + + // run prediction with dynamic batch size per event + input_shapes_ = {{(int64_t)1, (int64_t)n_cpf_, (int64_t)n_features_cpf_}, + {(int64_t)1, (int64_t)n_lt_, (int64_t)n_features_lt_}, + {(int64_t)1, (int64_t)n_npf_, (int64_t)n_features_npf_}, + {(int64_t)1, (int64_t)n_sv_, (int64_t)n_features_sv_}, + {(int64_t)1, (int64_t)n_cpf_, (int64_t)n_pairwise_features_cpf_}, + {(int64_t)1, (int64_t)n_lt_, (int64_t)n_pairwise_features_lt_}, + {(int64_t)1, (int64_t)n_npf_, (int64_t)n_pairwise_features_npf_}, + {(int64_t)1, (int64_t)n_sv_, (int64_t)n_pairwise_features_sv_}}; + + outputs = globalCache()->run(input_names_, data_, input_shapes_, output_names_, 1)[0]; + assert(outputs.size() == flav_names_.size()); + } + + const auto& jet_ref = tag_infos->at(jet_n).jet(); + for (std::size_t flav_n = 0; flav_n < flav_names_.size(); flav_n++) { + (*(output_tags[flav_n]))[jet_ref] = outputs[flav_n]; + } + } + + // put into the event + for (std::size_t flav_n = 0; flav_n < flav_names_.size(); ++flav_n) { + iEvent.put(std::move(output_tags[flav_n]), flav_names_[flav_n]); + } +} + +void UnifiedParticleTransformerAK4ONNXJetTagsProducer::get_input_sizes( + const reco::FeaturesTagInfo taginfo) { + const auto& features = taginfo.features(); + + /// We require a fixed size due to an ONNX conversion issue (to be improved in the future ?) /// + n_cpf_ = (unsigned int)29; + n_lt_ = (unsigned int)5; + n_npf_ = (unsigned int)25; + n_sv_ = (unsigned int)5; + + input_sizes_ = { + n_cpf_ * n_features_cpf_, + n_lt_ * n_features_lt_, + n_npf_ * n_features_npf_, + n_sv_ * n_features_sv_, + n_cpf_ * n_pairwise_features_cpf_, + n_lt_ * n_pairwise_features_lt_, + n_npf_ * n_pairwise_features_npf_, + n_sv_ * n_pairwise_features_sv_, + }; + // init data storage + data_.clear(); + for (const auto& len : input_sizes_) { + data_.emplace_back(1 * len, 0); + } + + make_inputs(features); +} + +void UnifiedParticleTransformerAK4ONNXJetTagsProducer::make_inputs( + btagbtvdeep::UnifiedParticleTransformerAK4Features features) { + float* ptr = nullptr; + const float* start = nullptr; + unsigned offset = 0; + + // c_pf candidates + auto max_c_pf_n = std::min(features.c_pf_features.size(), (std::size_t)n_cpf_); + for (std::size_t c_pf_n = 0; c_pf_n < max_c_pf_n; c_pf_n++) { + const auto& c_pf_features = features.c_pf_features.at(c_pf_n); + ptr = &data_[kChargedCandidates][offset + c_pf_n * n_features_cpf_]; + start = ptr; + *ptr = c_pf_features.btagPf_trackEtaRel; + *(++ptr) = c_pf_features.btagPf_trackPtRel; + *(++ptr) = c_pf_features.btagPf_trackPPar; + *(++ptr) = c_pf_features.btagPf_trackDeltaR; + *(++ptr) = c_pf_features.btagPf_trackPParRatio; + *(++ptr) = c_pf_features.btagPf_trackSip2dVal; + *(++ptr) = c_pf_features.btagPf_trackSip2dSig; + *(++ptr) = c_pf_features.btagPf_trackSip3dVal; + *(++ptr) = c_pf_features.btagPf_trackSip3dSig; + *(++ptr) = c_pf_features.btagPf_trackJetDistVal; + *(++ptr) = c_pf_features.ptrel; + *(++ptr) = c_pf_features.drminsv; + *(++ptr) = c_pf_features.vtx_ass; + *(++ptr) = c_pf_features.puppiw; + *(++ptr) = c_pf_features.chi2; + *(++ptr) = c_pf_features.quality; + *(++ptr) = c_pf_features.charge; + *(++ptr) = c_pf_features.dz; + *(++ptr) = c_pf_features.btagPf_trackDecayLen; + *(++ptr) = c_pf_features.HadFrac; + *(++ptr) = c_pf_features.CaloFrac; + *(++ptr) = c_pf_features.pdgID; + *(++ptr) = c_pf_features.lostInnerHits; + *(++ptr) = c_pf_features.numberOfPixelHits; + *(++ptr) = c_pf_features.numberOfStripHits; + + assert(start + n_features_cpf_ - 1 == ptr); + } + + // n_lt candidates + auto max_lt_n = std::min(features.lt_features.size(), (std::size_t)n_lt_); + for (std::size_t lt_n = 0; lt_n < max_lt_n; lt_n++) { + const auto& lt_features = features.lt_features.at(lt_n); + ptr = &data_[kLostTracks][offset + lt_n * n_features_lt_]; + start = ptr; + *ptr = lt_features.btagPf_trackEtaRel; + *(++ptr) = lt_features.btagPf_trackPtRel; + *(++ptr) = lt_features.btagPf_trackPPar; + *(++ptr) = lt_features.btagPf_trackDeltaR; + *(++ptr) = lt_features.btagPf_trackPParRatio; + *(++ptr) = lt_features.btagPf_trackSip2dVal; + *(++ptr) = lt_features.btagPf_trackSip2dSig; + *(++ptr) = lt_features.btagPf_trackSip3dVal; + *(++ptr) = lt_features.btagPf_trackSip3dSig; + *(++ptr) = lt_features.btagPf_trackJetDistVal; + *(++ptr) = lt_features.drminsv; + *(++ptr) = lt_features.charge; + *(++ptr) = lt_features.puppiw; + *(++ptr) = lt_features.chi2; + *(++ptr) = lt_features.quality; + *(++ptr) = lt_features.lostInnerHits; + *(++ptr) = lt_features.numberOfPixelHits; + *(++ptr) = lt_features.numberOfStripHits; + assert(start + n_features_lt_ - 1 == ptr); + } + + // n_pf candidates + auto max_n_pf_n = std::min(features.n_pf_features.size(), (std::size_t)n_npf_); + for (std::size_t n_pf_n = 0; n_pf_n < max_n_pf_n; n_pf_n++) { + const auto& n_pf_features = features.n_pf_features.at(n_pf_n); + ptr = &data_[kNeutralCandidates][offset + n_pf_n * n_features_npf_]; + start = ptr; + *ptr = n_pf_features.ptrel; + *(++ptr) = n_pf_features.etarel; + *(++ptr) = n_pf_features.phirel; + *(++ptr) = n_pf_features.deltaR; + *(++ptr) = n_pf_features.isGamma; + *(++ptr) = n_pf_features.hadFrac; + *(++ptr) = n_pf_features.drminsv; + *(++ptr) = n_pf_features.puppiw; + assert(start + n_features_npf_ - 1 == ptr); + } + + // sv candidates + auto max_sv_n = std::min(features.sv_features.size(), (std::size_t)n_sv_); + for (std::size_t sv_n = 0; sv_n < max_sv_n; sv_n++) { + const auto& sv_features = features.sv_features.at(sv_n); + ptr = &data_[kVertices][offset + sv_n * n_features_sv_]; + start = ptr; + *ptr = sv_features.pt; + *(++ptr) = sv_features.deltaR; + *(++ptr) = sv_features.mass; + *(++ptr) = sv_features.etarel; + *(++ptr) = sv_features.phirel; + *(++ptr) = sv_features.ntracks; + *(++ptr) = sv_features.chi2; + *(++ptr) = sv_features.normchi2; + *(++ptr) = sv_features.dxy; + *(++ptr) = sv_features.dxysig; + *(++ptr) = sv_features.d3d; + *(++ptr) = sv_features.d3dsig; + *(++ptr) = sv_features.costhetasvpv; + *(++ptr) = sv_features.enratio; + assert(start + n_features_sv_ - 1 == ptr); + } + + // cpf pairwise features (4-vectors) + auto max_cpf_n = std::min(features.c_pf_features.size(), (std::size_t)n_cpf_); + for (std::size_t cpf_n = 0; cpf_n < max_cpf_n; cpf_n++) { + const auto& cpf_pairwise_features = features.c_pf_features.at(cpf_n); + ptr = &data_[kChargedCandidates4Vec][offset + cpf_n * n_pairwise_features_cpf_]; + start = ptr; + *ptr = cpf_pairwise_features.px; + *(++ptr) = cpf_pairwise_features.py; + *(++ptr) = cpf_pairwise_features.pz; + *(++ptr) = cpf_pairwise_features.e; + + assert(start + n_pairwise_features_cpf_ - 1 == ptr); + } + + // lt pairwise features (4-vectors) specific case requiring (pt,eta,phi,e) + auto max_lt_N = std::min(features.lt_features.size(), (std::size_t)n_lt_); + for (std::size_t lt_N = 0; lt_N < max_lt_N; lt_N++) { + const auto& lt_pairwise_features = features.lt_features.at(lt_N); + ptr = &data_[kLostTracks4Vec][offset + lt_N * n_pairwise_features_lt_]; + start = ptr; + *ptr = lt_pairwise_features.pt; + *(++ptr) = lt_pairwise_features.eta; + *(++ptr) = lt_pairwise_features.phi; + *(++ptr) = lt_pairwise_features.e; + + assert(start + n_pairwise_features_lt_ - 1 == ptr); + } + + // npf pairwise features (4-vectors) + auto max_npf_n = std::min(features.n_pf_features.size(), (std::size_t)n_npf_); + for (std::size_t npf_n = 0; npf_n < max_npf_n; npf_n++) { + const auto& npf_pairwise_features = features.n_pf_features.at(npf_n); + ptr = &data_[kNeutralCandidates4Vec][offset + npf_n * n_pairwise_features_npf_]; + start = ptr; + *ptr = npf_pairwise_features.px; + *(++ptr) = npf_pairwise_features.py; + *(++ptr) = npf_pairwise_features.pz; + *(++ptr) = npf_pairwise_features.e; + + assert(start + n_pairwise_features_npf_ - 1 == ptr); + } + + // sv pairwise features (4-vectors) + auto max_sv_N = std::min(features.sv_features.size(), (std::size_t)n_sv_); + for (std::size_t sv_N = 0; sv_N < max_sv_N; sv_N++) { + const auto& sv_pairwise_features = features.sv_features.at(sv_N); + ptr = &data_[kVertices4Vec][offset + sv_N * n_pairwise_features_sv_]; + start = ptr; + *ptr = sv_pairwise_features.px; + *(++ptr) = sv_pairwise_features.py; + *(++ptr) = sv_pairwise_features.pz; + *(++ptr) = sv_pairwise_features.e; + + assert(start + n_pairwise_features_sv_ - 1 == ptr); + } +} + +//define this as a plug-in +DEFINE_FWK_MODULE(UnifiedParticleTransformerAK4ONNXJetTagsProducer); diff --git a/RecoBTag/ONNXRuntime/python/pfUnifiedParticleTransformerAK4DiscriminatorsJetTags_cfi.py b/RecoBTag/ONNXRuntime/python/pfUnifiedParticleTransformerAK4DiscriminatorsJetTags_cfi.py new file mode 100644 index 0000000000000..28064787c6fc1 --- /dev/null +++ b/RecoBTag/ONNXRuntime/python/pfUnifiedParticleTransformerAK4DiscriminatorsJetTags_cfi.py @@ -0,0 +1,157 @@ +import FWCore.ParameterSet.Config as cms + +pfUnifiedParticleTransformerAK4DiscriminatorsJetTags = cms.EDProducer( + 'BTagProbabilityToDiscriminator', + discriminators = cms.VPSet( + cms.PSet( + name = cms.string('BvsAll'), + numerator = cms.VInputTag( + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probb'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probbb'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'problepb'), + ), + denominator=cms.VInputTag( + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probb'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probbb'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'problepb'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probc'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probs'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probu'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probd'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probg'), + ), + ), + cms.PSet( + name = cms.string('CvsL'), + numerator = cms.VInputTag( + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probc'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probc'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probs'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probu'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probd'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probg'), + ), + ), + cms.PSet( + name = cms.string('CvsB'), + numerator = cms.VInputTag( + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probc'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probc'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probb'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probbb'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'problepb'), + ), + ), + cms.PSet( + name = cms.string('QvsG'), + numerator = cms.VInputTag( + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probs'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probu'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probd'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probs'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probu'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probd'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probg'), + ), + ), + cms.PSet( + name = cms.string('TauVsJet'), + numerator = cms.VInputTag( + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaup1h0p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaup1h1p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaup1h2p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaup3h0p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaup3h1p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaum1h0p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaum1h1p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaum1h2p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaum3h0p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaum3h1p'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probb'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probbb'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'problepb'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probc'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probs'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probu'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probd'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probg'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaup1h0p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaup1h1p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaup1h2p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaup3h0p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaup3h1p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaum1h0p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaum1h1p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaum1h2p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaum3h0p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaum3h1p'), + ), + ), + cms.PSet( + name = cms.string('TauVsEle'), + numerator = cms.VInputTag( + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaup1h0p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaup1h1p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaup1h2p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaup3h0p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaup3h1p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaum1h0p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaum1h1p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaum1h2p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaum3h0p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaum3h1p'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probele'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaup1h0p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaup1h1p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaup1h2p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaup3h0p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaup3h1p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaum1h0p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaum1h1p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaum1h2p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaum3h0p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaum3h1p'), + ), + ), + + cms.PSet( + name = cms.string('TauVsMu'), + numerator = cms.VInputTag( + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaup1h0p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaup1h1p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaup1h2p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaup3h0p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaup3h1p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaum1h0p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaum1h1p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaum1h2p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaum3h0p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaum3h1p'), + ), + denominator = cms.VInputTag( + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probmu'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaup1h0p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaup1h1p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaup1h2p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaup3h0p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaup3h1p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaum1h0p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaum1h1p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaum1h2p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaum3h0p'), + cms.InputTag('pfUnifiedParticleTransformerAK4JetTags', 'probtaum3h1p'), + ), + ), + + ) + ) diff --git a/RecoBTag/ONNXRuntime/python/pfUnifiedParticleTransformerAK4_cff.py b/RecoBTag/ONNXRuntime/python/pfUnifiedParticleTransformerAK4_cff.py new file mode 100644 index 0000000000000..aee089f50ef68 --- /dev/null +++ b/RecoBTag/ONNXRuntime/python/pfUnifiedParticleTransformerAK4_cff.py @@ -0,0 +1,29 @@ +import FWCore.ParameterSet.Config as cms + +from RecoBTag.FeatureTools.pfUnifiedParticleTransformerAK4TagInfos_cfi import pfUnifiedParticleTransformerAK4TagInfos + +from RecoBTag.ONNXRuntime.pfUnifiedParticleTransformerAK4JetTags_cfi import pfUnifiedParticleTransformerAK4JetTags +from RecoBTag.ONNXRuntime.pfUnifiedParticleTransformerAK4DiscriminatorsJetTags_cfi import pfUnifiedParticleTransformerAK4DiscriminatorsJetTags +from CommonTools.PileupAlgos.Puppi_cff import puppi +from CommonTools.RecoAlgos.primaryVertexAssociation_cfi import primaryVertexAssociation + +# declare all the discriminators +# probs +_pfUnifiedParticleTransformerAK4JetTagsProbs = ['pfUnifiedParticleTransformerAK4JetTags:' + flav_name + for flav_name in pfUnifiedParticleTransformerAK4JetTags.flav_names] +# meta-taggers +_pfUnifiedParticleTransformerAK4JetTagsMetaDiscrs = ['pfUnifiedParticleTransformerAK4DiscriminatorsJetTags:' + disc.name.value() + for disc in pfUnifiedParticleTransformerAK4DiscriminatorsJetTags.discriminators] +_pfUnifiedParticleTransformerAK4JetTagsAll = _pfUnifiedParticleTransformerAK4JetTagsProbs + _pfUnifiedParticleTransformerAK4JetTagsMetaDiscrs + + + +# == +# This task is not used, useful only if we run it from RECO jets (RECO/AOD) +pfUnifiedParticleTransformerAK4Task = cms.Task(puppi, primaryVertexAssociation, + pfUnifiedParticleTransformerAK4TagInfos, pfUnifiedParticleTransformerAK4JetTags, + pfUnifiedParticleTransformerAK4DiscriminatorsJetTags) +# run from MiniAOD instead +pfUnifiedParticleTransformerAK4FromMiniAODTask = cms.Task(pfUnifiedParticleTransformerAK4TagInfos, + pfUnifiedParticleTransformerAK4JetTags, + pfUnifiedParticleTransformerAK4DiscriminatorsJetTags) diff --git a/RecoBTag/ONNXRuntime/test/test_deep_flavour_cfg.py b/RecoBTag/ONNXRuntime/test/test_deep_flavour_cfg.py index 3a791fbcaadf7..6ed9615811014 100644 --- a/RecoBTag/ONNXRuntime/test/test_deep_flavour_cfg.py +++ b/RecoBTag/ONNXRuntime/test/test_deep_flavour_cfg.py @@ -71,7 +71,7 @@ from PhysicsTools.PatAlgos.patInputFiles_cff import filesRelValTTbarPileUpMINIAODSIM process.source.fileNames = filesRelValTTbarPileUpMINIAODSIM -process.source.fileNames = cms.untracked.vstring('/store/mc/PhaseIFall16MiniAOD/TT_TuneCUETP8M2T4_13TeV-powheg-pythia8/MINIAODSIM/PhaseIFall16PUFlat20to50_PhaseIFall16_81X_upgrade2017_realistic_v26-v1/50000/08358A47-61E3-E611-8B77-001E677928AE.root') +process.source.fileNames = cms.untracked.vstring('/store/mc/Run3Summer23BPixMiniAODv4/TTtoLNu2Q_TuneCP5_13p6TeV_powheg-pythia8/MINIAODSIM/130X_mcRun3_2023_realistic_postBPix_v2-v3/2520000/00488681-4f49-4bdc-89e6-198da9e42a17.root') process.maxEvents.input = 10 diff --git a/RecoBTag/ONNXRuntime/test/test_unifiedpartak4_cfg.py b/RecoBTag/ONNXRuntime/test/test_unifiedpartak4_cfg.py new file mode 100644 index 0000000000000..4330ad8d00bea --- /dev/null +++ b/RecoBTag/ONNXRuntime/test/test_unifiedpartak4_cfg.py @@ -0,0 +1,88 @@ + +import FWCore.ParameterSet.Config as cms +from PhysicsTools.PatAlgos.tools.helpers import getPatAlgosToolsTask + +process = cms.Process("PATtest") + +## MessageLogger +process.load("FWCore.MessageLogger.MessageLogger_cfi") + +## Options and Output Report +process.options = cms.untracked.PSet( wantSummary = cms.untracked.bool(True) ) + +## Source +process.source = cms.Source("PoolSource", + fileNames = cms.untracked.vstring() +) +## Maximal Number of Events +process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(1000)) + +## Geometry and Detector Conditions (needed for a few patTuple production steps) +process.load("Configuration.Geometry.GeometryRecoDB_cff") +process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_cff") +from Configuration.AlCa.GlobalTag import GlobalTag +process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:run2_mc') +process.load("Configuration.StandardSequences.MagneticField_cff") + +## Output Module Configuration (expects a path 'p') +from PhysicsTools.PatAlgos.patEventContent_cff import patEventContentNoCleaning +process.out = cms.OutputModule("PoolOutputModule", + fileName = cms.untracked.string('patTuple.root'), + outputCommands = cms.untracked.vstring('drop *', *patEventContentNoCleaning ) + ) + +patAlgosToolsTask = getPatAlgosToolsTask(process) +process.outpath = cms.EndPath(process.out, patAlgosToolsTask) + +## and add them to the event content +from PhysicsTools.PatAlgos.tools.jetTools import updateJetCollection + +updateJetCollection( + process, + jetSource = cms.InputTag('slimmedJetsPuppi'), + pvSource = cms.InputTag('offlineSlimmedPrimaryVertices'), + svSource = cms.InputTag('slimmedSecondaryVertices'), + jetCorrections = ('AK4PFchs', cms.vstring(['L1FastJet', 'L2Relative', 'L3Absolute']), 'None'), + btagDiscriminators = [ + 'pfDeepFlavourJetTags:probb', + 'pfDeepFlavourJetTags:probbb', + 'pfDeepFlavourJetTags:problepb', + 'pfDeepFlavourJetTags:probc', + 'pfDeepFlavourJetTags:probuds', + 'pfDeepFlavourJetTags:probg', + 'pfUnifiedParticleTransformerAK4JetTags:probb', + 'pfUnifiedParticleTransformerAK4JetTags:probbb', + 'pfUnifiedParticleTransformerAK4JetTags:problepb', + 'pfUnifiedParticleTransformerAK4JetTags:probc', + 'pfUnifiedParticleTransformerAK4JetTags:probs', + 'pfUnifiedParticleTransformerAK4JetTags:probu', + 'pfUnifiedParticleTransformerAK4JetTags:probd', + 'pfUnifiedParticleTransformerAK4JetTags:probg', + 'pfParticleTransformerAK4JetTags:probb', + 'pfParticleTransformerAK4JetTags:probbb', + 'pfParticleTransformerAK4JetTags:problepb', + 'pfParticleTransformerAK4JetTags:probc', + 'pfParticleTransformerAK4JetTags:probuds', + 'pfParticleTransformerAK4JetTags:probg', + 'pfParticleNetFromMiniAODAK4PuppiCentralJetTags:probb', + 'pfParticleNetFromMiniAODAK4PuppiCentralJetTags:probc', + 'pfParticleNetFromMiniAODAK4PuppiCentralJetTags:probuds', + 'pfParticleNetFromMiniAODAK4PuppiCentralJetTags:probg', + ] + ) + +from PhysicsTools.PatAlgos.patInputFiles_cff import filesRelValTTbarPileUpMINIAODSIM + +process.source.fileNames = filesRelValTTbarPileUpMINIAODSIM +process.source.fileNames = cms.untracked.vstring('/store/mc/Run3Summer23BPixMiniAODv4/TTtoLNu2Q_TuneCP5_13p6TeV_powheg-pythia8/MINIAODSIM/130X_mcRun3_2023_realistic_postBPix_v2-v3/2520000/00488681-4f49-4bdc-89e6-198da9e42a17.root') + +process.maxEvents.input = 1000 + +from Configuration.EventContent.EventContent_cff import MINIAODSIMEventContent +process.out.outputCommands = MINIAODSIMEventContent.outputCommands +process.out.outputCommands.append('keep *_selectedUpdatedPatJets*_*_*') +process.out.outputCommands.append('keep *_pfDeepFlavourTagInfos*_*_*') +process.out.outputCommands.append('keep *_pfDeepFlavourJetTags*_*_*') +process.out.outputCommands.append('keep *_updatedPatJets*_*_*') + +process.out.fileName = 'test_deep_unifiedpartak4_MINIAODSIM.root'