Preparations of deep tau ID for hlt phase2 (backport to CMSSW_11_1_X)

RecoTauTag/HLTProducers/python/deepTauAtHLT.py

@@ -0,0 +1,140 @@
+import FWCore.ParameterSet.Config as cms
+
+from RecoTauTag.RecoTau.PFRecoTauDiscriminationByIsolation_cfi import *
+from RecoTauTag.RecoTau.PFRecoTauQualityCuts_cfi import PFTauQualityCuts
+from RecoTauTag.RecoTau.PFRecoTauDiscriminationByHPSSelection_cfi import hpsSelectionDiscriminator
+
+from RecoTauTag.RecoTau.PFTauPrimaryVertexProducer_cfi      import *
+from RecoTauTag.RecoTau.PFTauSecondaryVertexProducer_cfi    import *
+from RecoTauTag.RecoTau.PFTauTransverseImpactParameters_cfi import *
+
+from RecoTauTag.RecoTau.DeepTau_cfi import *
+
+from RecoTauTag.RecoTau.PFRecoTauPFJetInputs_cfi import PFRecoTauPFJetInputs
+## DeltaBeta correction factor
+ak4dBetaCorrection = 0.20
+
+def update(process):
+    process.options.wantSummary = cms.untracked.bool(True)
+
+    process.hltFixedGridRhoFastjetAll = cms.EDProducer( "FixedGridRhoProducerFastjet",
+        gridSpacing = cms.double( 0.55 ),
+        maxRapidity = cms.double( 5.0 ),
+        pfCandidatesTag = cms.InputTag( "hltParticleFlowReg" )
+    )
+
+    PFTauQualityCuts.primaryVertexSrc = cms.InputTag("hltPixelVertices")
+
+    ## Decay mode prediscriminant
+    requireDecayMode = cms.PSet(
+        BooleanOperator = cms.string("and"),
+        decayMode = cms.PSet(
+            Producer = cms.InputTag('hltHpsPFTauDiscriminationByDecayModeFindingNewDMsReg'),
+            cut = cms.double(0.5)
+        )
+    )
+
+    ## Cut based isolations dR=0.5
+    process.hpsPFTauBasicDiscriminators = pfRecoTauDiscriminationByIsolation.clone(
+        PFTauProducer = 'hltHpsPFTauProducerReg',
+        Prediscriminants = requireDecayMode.clone(),
+        deltaBetaPUTrackPtCutOverride     = True, # Set the boolean = True to override.
+        deltaBetaPUTrackPtCutOverride_val = 0.5,  # Set the value for new value.
+        particleFlowSrc = 'hltParticleFlowReg',
+        vertexSrc = PFTauQualityCuts.primaryVertexSrc,
+        customOuterCone = PFRecoTauPFJetInputs.isolationConeSize,
+        isoConeSizeForDeltaBeta = 0.8,
+        deltaBetaFactor = "%0.4f"%(ak4dBetaCorrection),
+        qualityCuts = dict(isolationQualityCuts = dict(minTrackHits = 3, minGammaEt = 1.0, minTrackPt = 0.5)),
+        IDdefinitions = [
+            cms.PSet(
+                IDname = cms.string("ChargedIsoPtSum"),
+                ApplyDiscriminationByTrackerIsolation = cms.bool(True),
+                storeRawSumPt = cms.bool(True)
+            ),
+            cms.PSet(
+                IDname = cms.string("NeutralIsoPtSum"),
+                ApplyDiscriminationByECALIsolation = cms.bool(True),
+                storeRawSumPt = cms.bool(True)
+            ),
+            cms.PSet(
+                IDname = cms.string("NeutralIsoPtSumWeight"),
+                ApplyDiscriminationByWeightedECALIsolation = cms.bool(True),
+                storeRawSumPt = cms.bool(True),
+                UseAllPFCandsForWeights = cms.bool(True)
+            ),
+            cms.PSet(
+                IDname = cms.string("TauFootprintCorrection"),
+                storeRawFootprintCorrection = cms.bool(True)
+            ),
+            cms.PSet(
+                IDname = cms.string("PhotonPtSumOutsideSignalCone"),
+                storeRawPhotonSumPt_outsideSignalCone = cms.bool(True)
+            ),
+            cms.PSet(
+                IDname = cms.string("PUcorrPtSum"),
+                applyDeltaBetaCorrection = cms.bool(True),
+                storeRawPUsumPt = cms.bool(True)
+            ),
+        ],
+    )
+
+    ## Cut based isolations dR=0.3
+    process.hpsPFTauBasicDiscriminatorsdR03 = process.hpsPFTauBasicDiscriminators.clone(
+        customOuterCone = 0.3
+    )
+
+    process.hpsPFTauPrimaryVertexProducer = PFTauPrimaryVertexProducer.clone(
+        PFTauTag = "hltHpsPFTauProducerReg",
+        ElectronTag = "hltEgammaCandidates",
+        MuonTag = "hltMuonsReg",
+        PVTag = "hltPixelVertices",
+        beamSpot = "hltOnlineBeamSpot",
+        discriminators = [
+            cms.PSet(
+                discriminator = cms.InputTag('hltHpsPFTauDiscriminationByDecayModeFindingNewDMsReg'),
+                selectionCut = cms.double(0.5)
+            )
+        ],
+        cut = "pt > 18.0 & abs(eta) < 2.4",
+        qualityCuts = PFTauQualityCuts
+    )
+
+    process.hpsPFTauSecondaryVertexProducer = PFTauSecondaryVertexProducer.clone(
+        PFTauTag = "hltHpsPFTauProducerReg"
+    )
+    process.hpsPFTauTransverseImpactParameters = PFTauTransverseImpactParameters.clone(
+        PFTauTag = "hltHpsPFTauProducerReg",
+        PFTauPVATag = "hpsPFTauPrimaryVertexProducer",
+        PFTauSVATag = "hpsPFTauSecondaryVertexProducer",
+        useFullCalculation = True
+    )
+
+    file_names = [
+    				'core:RecoTauTag/TrainingFiles/data/DeepTauId/deepTau_2017v2p6_e6_core.pb',
+    				'inner:RecoTauTag/TrainingFiles/data/DeepTauId/deepTau_2017v2p6_e6_inner.pb',
+    				'outer:RecoTauTag/TrainingFiles/data/DeepTauId/deepTau_2017v2p6_e6_outer.pb',
+    			]
+
+    working_points = ["0.", "0.92"]
+
+    process.deepTauProducer = DeepTau.clone(
+        taus = 'hltHpsPFTauProducerReg',
+        pfcands = 'hltParticleFlowReg',
+        vertices = 'hltPixelVertices',
+        rho = 'hltFixedGridRhoFastjetAll',
+        graph_file = file_names,
+        disable_dxy_pca = cms.bool(True),
+        is_online = cms.bool(True),
+        basicTauDiscriminators = 'hpsPFTauBasicDiscriminators',
+        basicTauDiscriminatorsdR03 = 'hpsPFTauBasicDiscriminatorsdR03',
+        Prediscriminants = requireDecayMode.clone(),  
+        VSeWP = working_points,
+        VSmuWP = working_points,
+        VSjetWP = working_points     
+    )	
+
+    # Add DeepTauProducer
+    process.HLTHPSMediumChargedIsoPFTauSequenceReg += (process.hpsPFTauPrimaryVertexProducer  + process.hpsPFTauSecondaryVertexProducer + process.hpsPFTauTransverseImpactParameters + process.hltFixedGridRhoFastjetAll +  process.hpsPFTauBasicDiscriminators + process.hpsPFTauBasicDiscriminatorsdR03 + process.deepTauProducer)
+
+    return process

RecoTauTag/RecoTau/interface/DeepTauBase.h

@@ -19,18 +19,26 @@
 #include "DataFormats/PatCandidates/interface/Muon.h"
 #include "DataFormats/PatCandidates/interface/Tau.h"
 #include "DataFormats/TauReco/interface/TauDiscriminatorContainer.h"
+#include "DataFormats/TauReco/interface/PFTauDiscriminator.h"
+#include "DataFormats/PatCandidates/interface/PATTauDiscriminator.h"
 #include "CommonTools/Utils/interface/StringObjectFunction.h"
 #include "RecoTauTag/RecoTau/interface/PFRecoTauClusterVariables.h"
 #include "FWCore/ParameterSet/interface/ConfigurationDescriptions.h"
 #include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
+#include "DataFormats/Common/interface/View.h"
+#include "DataFormats/Common/interface/RefToBase.h"
+#include "DataFormats/Provenance/interface/ProductProvenance.h"
+#include "DataFormats/Provenance/interface/ProcessHistoryID.h"
+#include "FWCore/Common/interface/Provenance.h"
 #include <TF1.h>
+#include <map>
 
 namespace deep_tau {
 
   class TauWPThreshold {
   public:
     explicit TauWPThreshold(const std::string& cut_str);
-    double operator()(const pat::Tau& tau) const;
+    double operator()(const reco::BaseTau& tau, bool isPFTau) const;
 
   private:
     std::unique_ptr<TF1> fn_;
@@ -57,9 +65,9 @@ namespace deep_tau {
 
   class DeepTauBase : public edm::stream::EDProducer<edm::GlobalCache<DeepTauCache>> {
   public:
-    using TauType = pat::Tau;
     using TauDiscriminator = reco::TauDiscriminatorContainer;
-    using TauCollection = std::vector<TauType>;
+    using TauCollection = edm::View<reco::BaseTau>;
+    using CandidateCollection = edm::View<reco::Candidate>;
     using TauRef = edm::Ref<TauCollection>;
     using TauRefProd = edm::RefProd<TauCollection>;
     using ElectronCollection = pat::ElectronCollection;
@@ -76,7 +84,8 @@ namespace deep_tau {
 
       std::unique_ptr<TauDiscriminator> get_value(const edm::Handle<TauCollection>& taus,
                                                   const tensorflow::Tensor& pred,
-                                                  const WPList& working_points) const;
+                                                  const WPList* working_points,
+                                                  bool is_online) const;
     };
 
     using OutputCollection = std::map<std::string, Output>;
@@ -89,19 +98,45 @@ namespace deep_tau {
     static std::unique_ptr<DeepTauCache> initializeGlobalCache(const edm::ParameterSet& cfg);
     static void globalEndJob(const DeepTauCache* cache) {}
 
+    template <typename ConsumeType>
+    struct TauDiscInfo {
+      edm::InputTag label;
+      edm::Handle<ConsumeType> handle;
+      edm::EDGetTokenT<ConsumeType> disc_token;
+      double cut;
+      void fill(const edm::Event& evt) { evt.getByToken(disc_token, handle); }
+    };
+
+    // select boolean operation on prediscriminants (and = 0x01, or = 0x00)
+    uint8_t andPrediscriminants_;
+    std::vector<TauDiscInfo<pat::PATTauDiscriminator>> patPrediscriminants_;
+    std::vector<TauDiscInfo<reco::PFTauDiscriminator>> recoPrediscriminants_;
+
+    enum BasicDiscriminator {
+      ChargedIsoPtSum,
+      NeutralIsoPtSum,
+      NeutralIsoPtSumWeight,
+      FootprintCorrection,
+      PhotonPtSumOutsideSignalCone,
+      PUcorrPtSum
+    };
+
   private:
-    virtual tensorflow::Tensor getPredictions(edm::Event& event,
-                                              const edm::EventSetup& es,
-                                              edm::Handle<TauCollection> taus) = 0;
+    virtual tensorflow::Tensor getPredictions(edm::Event& event, edm::Handle<TauCollection> taus) = 0;
     virtual void createOutputs(edm::Event& event, const tensorflow::Tensor& pred, edm::Handle<TauCollection> taus);
 
   protected:
     edm::EDGetTokenT<TauCollection> tausToken_;
-    edm::EDGetTokenT<pat::PackedCandidateCollection> pfcandToken_;
+    edm::EDGetTokenT<CandidateCollection> pfcandToken_;
     edm::EDGetTokenT<reco::VertexCollection> vtxToken_;
     std::map<std::string, WPList> workingPoints_;
+    const bool is_online_;
     OutputCollection outputs_;
     const DeepTauCache* cache_;
+
+    static const std::map<BasicDiscriminator, std::string> stringFromDiscriminator_;
+    static const std::vector<BasicDiscriminator> requiredBasicDiscriminators_;
+    static const std::vector<BasicDiscriminator> requiredBasicDiscriminatorsdR03_;
   };
 
 }  // namespace deep_tau

RecoTauTag/RecoTau/plugins/DPFIsolation.cc

@@ -74,9 +74,7 @@ class DPFIsolation : public deep_tau::DeepTauBase {
   }
 
 private:
-  tensorflow::Tensor getPredictions(edm::Event& event,
-                                    const edm::EventSetup& es,
-                                    edm::Handle<TauCollection> taus) override {
+  tensorflow::Tensor getPredictions(edm::Event& event, edm::Handle<TauCollection> taus) override {
     edm::Handle<pat::PackedCandidateCollection> pfcands;
     event.getByToken(pfcandToken_, pfcands);