link lost tracks to taus [12_4_X]

DataFormats/PatCandidates/interface/Tau.h

@@ -256,13 +256,18 @@ namespace pat {
     /// note that the vector is returned by value.
     reco::CandidatePtrVector isolationGammaCands() const;
 
+    /// return the PackedCandidates on miniAOD corresponding with tau "lost" tracks
+    /// note that the vector is returned by value.
+    std::vector<reco::CandidatePtr> signalLostTracks() const;
+
     /// setters for the PtrVectors (for miniAOD)
     void setSignalChargedHadrCands(const reco::CandidatePtrVector& ptrs) { signalChargedHadrCandPtrs_ = ptrs; }
     void setSignalNeutralHadrCands(const reco::CandidatePtrVector& ptrs) { signalNeutralHadrCandPtrs_ = ptrs; }
     void setSignalGammaCands(const reco::CandidatePtrVector& ptrs) { signalGammaCandPtrs_ = ptrs; }
     void setIsolationChargedHadrCands(const reco::CandidatePtrVector& ptrs) { isolationChargedHadrCandPtrs_ = ptrs; }
     void setIsolationNeutralHadrCands(const reco::CandidatePtrVector& ptrs) { isolationNeutralHadrCandPtrs_ = ptrs; }
     void setIsolationGammaCands(const reco::CandidatePtrVector& ptrs) { isolationGammaCandPtrs_ = ptrs; }
+    void setSignalLostTracks(const std::vector<reco::CandidatePtr>& ptrs);
 
     /// ----- Top Projection business -------
     /// get the number of non-null PFCandidates

DataFormats/PatCandidates/src/Tau.cc

@@ -112,6 +112,15 @@ void Tau::initFromBaseTau(const reco::BaseTau& aTau) {
 
       for (const auto& ptr : pfTau->isolationGammaCands())
         isolationGammaCandPtrs_.push_back(ptr);
+
+      std::vector<reco::CandidatePtr> signalLostTracks;
+      for (const auto& chargedHadron : pfTau->signalTauChargedHadronCandidates()) {
+        if (chargedHadron.algoIs(reco::PFRecoTauChargedHadron::kTrack) &&
+            chargedHadron.getLostTrackCandidate().isNonnull()) {
+          signalLostTracks.push_back(chargedHadron.getLostTrackCandidate());
+        }
+      }
+      this->setSignalLostTracks(signalLostTracks);
     } else {
       pfSpecific_.push_back(pat::tau::TauPFSpecific(*pfTau));
     }
@@ -1017,6 +1026,27 @@ reco::CandidatePtrVector Tau::isolationGammaCands() const {
   }
 }
 
+std::vector<reco::CandidatePtr> Tau::signalLostTracks() const {
+  std::vector<reco::CandidatePtr> ret;
+  unsigned int i = 0;
+  std::string label = "_lostTrack_" + std::to_string(i);
+  while (this->hasUserCand(label)) {
+    ret.push_back(userCand(label));
+    i++;
+    label = "_lostTrack_" + std::to_string(i);
+  }
+  return ret;
+}
+
+void Tau::setSignalLostTracks(const std::vector<reco::CandidatePtr>& ptrs) {
+  unsigned int i = 0;
+  for (const auto& ptr : ptrs) {
+    std::string label = "_lostTrack_" + std::to_string(i);
+    addUserCand(label, ptr);
+    i++;
+  }
+}
+
 /// ----- Top Projection business -------
 /// get the number of non-null PFCandidates
 size_t Tau::numberOfSourceCandidatePtrs() const {

PhysicsTools/PatAlgos/plugins/PATTauSlimmer.cc

@@ -27,6 +27,8 @@ namespace pat {
     const edm::EDGetTokenT<edm::View<pat::Tau>> src_;
     const bool linkToPackedPF_;
     const edm::EDGetTokenT<edm::Association<pat::PackedCandidateCollection>> pf2pc_;
+    const bool linkToLostTracks_;
+    const edm::EDGetTokenT<edm::Association<pat::PackedCandidateCollection>> trk2lost_;
     const bool dropPiZeroRefs_;
     const bool dropTauChargedHadronRefs_;
     const bool dropPFSpecific_;
@@ -41,6 +43,9 @@ pat::PATTauSlimmer::PATTauSlimmer(const edm::ParameterSet &iConfig)
       linkToPackedPF_(iConfig.getParameter<bool>("linkToPackedPFCandidates")),
       pf2pc_(mayConsume<edm::Association<pat::PackedCandidateCollection>>(
           iConfig.getParameter<edm::InputTag>("packedPFCandidates"))),
+      linkToLostTracks_(iConfig.getParameter<bool>("linkToLostTracks")),
+      trk2lost_(mayConsume<edm::Association<pat::PackedCandidateCollection>>(
+          iConfig.getParameter<edm::InputTag>("lostTracks"))),
       dropPiZeroRefs_(iConfig.exists("dropPiZeroRefs") ? iConfig.getParameter<bool>("dropPiZeroRefs") : true),
       dropTauChargedHadronRefs_(
           iConfig.exists("dropTauChargedHadronRefs") ? iConfig.getParameter<bool>("dropTauChargedHadronRefs") : true),
@@ -67,6 +72,10 @@ void pat::PATTauSlimmer::produce(edm::Event &iEvent, const edm::EventSetup &iSet
   if (linkToPackedPF_)
     iEvent.getByToken(pf2pc_, pf2pc);
 
+  Handle<edm::Association<pat::PackedCandidateCollection>> trk2lost;
+  if (linkToLostTracks_)
+    iEvent.getByToken(trk2lost_, trk2lost);
+
   auto out = std::make_unique<std::vector<pat::Tau>>();
   out->reserve(src->size());
 
@@ -120,6 +129,16 @@ void pat::PATTauSlimmer::produce(edm::Event &iEvent, const edm::EventSetup &iSet
       }
       tau.setIsolationGammaCands(isolationGammaPtrs);
     }
+    if (linkToLostTracks_ && !tau.signalTracks().empty()) {
+      std::vector<reco::CandidatePtr> signalLostTracks;
+      for (const auto &trkRef : tau.signalTracks()) {
+        const auto &lostCandRef = (*trk2lost)[edm::refToPtr(trkRef)];
+        if (lostCandRef.isNonnull())
+          signalLostTracks.push_back(edm::refToPtr(lostCandRef));
+      }
+      tau.setSignalLostTracks(signalLostTracks);
+    }
+
     if (dropPiZeroRefs_) {
       tau.pfSpecific_[0].signalPiZeroCandidates_.clear();
       tau.pfSpecific_[0].isolationPiZeroCandidates_.clear();

PhysicsTools/PatAlgos/python/slimming/slimmedTaus_cfi.py

@@ -6,8 +6,10 @@
    dropPiZeroRefs = cms.bool(True),
    dropTauChargedHadronRefs = cms.bool(True),
    dropPFSpecific = cms.bool(True),
-   packedPFCandidates = cms.InputTag("packedPFCandidates"), 
+   packedPFCandidates = cms.InputTag("packedPFCandidates"),
    modifyTaus = cms.bool(True),
-   modifierConfig = cms.PSet( modifications = cms.VPSet() )    
+   modifierConfig = cms.PSet( modifications = cms.VPSet() ),
+   linkToLostTracks = cms.bool(True),
+   lostTracks = cms.InputTag("lostTracks")
 )
 

RecoTauTag/Configuration/python/tools/adaptToRunAtMiniAOD.py

@@ -176,6 +176,9 @@ def adaptTauToMiniAODReReco(self,reclusterJets=True):
 			elif mod.name.value() == 'TTIworkaround':
 				_modifiersToRemove.append(mod)
 				continue
+			elif mod.name.value() == 'tau_lost_tracks':
+				_modifiersToRemove.append(mod)
+				continue
 			for name,value in mod.parameters_().items():
 				if name == 'qualityCuts':
 					mod.qualityCuts.primaryVertexSrc = 'offlineSlimmedPrimaryVertices'

RecoTauTag/RecoTau/plugins/PFRecoTauDiscriminationByHPSSelection.cc

@@ -313,10 +313,22 @@ double PFRecoTauDiscriminationByHPSSelection::discriminate(const reco::PFTauRef&
 
   if (minPixelHits_ > 0) {
     int numPixelHits = 0;
+    const int nProngs = tau->decayMode() / 5 + 1;  //no. of charged prongs expected for this tau
+    int nTracks = 0;
     for (const auto& chargedHadrCand : tau->signalChargedHadrCands()) {
       const reco::Track* track = getTrack(*chargedHadrCand);
       if (track != nullptr) {
         numPixelHits += track->hitPattern().numberOfValidPixelHits();
+        nTracks++;
+      }
+    }
+    //MB: how to deal with tau@miniAOD case?
+    if (nTracks < nProngs) {  //"lost track" probably used to build this tau
+      for (const auto& track : tau->signalTracks()) {
+        if (track.isNonnull()) {
+          numPixelHits += track->hitPattern().numberOfValidPixelHits();
+          nTracks++;
+        }
       }
     }
     if (!(numPixelHits >= minPixelHits_)) {

RecoTauTag/RecoTau/plugins/PFRecoTauLostTrackPlugin.cc

@@ -0,0 +1,80 @@
+/*
+ * =============================================================================
+ *       Filename:  PFRecoTauLostTrackPlugin.cc
+ *
+ *    Description: Add references to tracks of tau-charged-hadrons built on 
+ *                 top of a track
+ *
+ *        Created:  25/04/2022
+ *
+ *         Authors:  Michal Bluj (NCBJ, Warsaw)
+ *
+ * =============================================================================
+ */
+
+#include "FWCore/MessageLogger/interface/MessageLogger.h"
+
+#include "RecoTauTag/RecoTau/interface/RecoTauBuilderPlugins.h"
+#include "DataFormats/TauReco/interface/PFTau.h"
+#include "DataFormats/TauReco/interface/PFRecoTauChargedHadron.h"
+#include "DataFormats/TauReco/interface/PFRecoTauChargedHadronFwd.h"
+
+namespace reco {
+  namespace tau {
+
+    class PFRecoTauLostTrackPlugin : public RecoTauModifierPlugin {
+    public:
+      explicit PFRecoTauLostTrackPlugin(const edm::ParameterSet&, edm::ConsumesCollector&& iC);
+      ~PFRecoTauLostTrackPlugin() override = default;
+      void operator()(PFTau&) const override;
+      void beginEvent() override;
+      void endEvent() override;
+
+    private:
+      edm::Handle<reco::TrackCollection> tracks_;
+      const edm::EDGetTokenT<reco::TrackCollection> track_token_;
+      const int verbosity_;
+    };
+
+    PFRecoTauLostTrackPlugin::PFRecoTauLostTrackPlugin(const edm::ParameterSet& cfg, edm::ConsumesCollector&& iC)
+        : RecoTauModifierPlugin(cfg, std::move(iC)),
+          track_token_(iC.consumes(cfg.getParameter<edm::InputTag>("trackSrc"))),
+          verbosity_(cfg.getParameter<int>("verbosity")) {}
+
+    void PFRecoTauLostTrackPlugin::beginEvent() { evt()->getByToken(track_token_, tracks_); }
+
+    void PFRecoTauLostTrackPlugin::operator()(PFTau& tau) const {
+      if (!tracks_.isValid()) {  //track collection not available in the event
+        if (verbosity_) {
+          edm::LogPrint("<PFRecoTauLostTrackPlugin::operator()>:")
+              << " Track collection " << tracks_.provenance() << " is not valid."
+              << " No tracks will be added to tau.";
+        }
+        return;
+      }
+      reco::TrackRefVector lostTracks;
+      const PFRecoTauChargedHadronCollection& chargedHadrons = tau.signalTauChargedHadronCandidates();
+      for (const auto& chargedHadron : chargedHadrons) {
+        if (chargedHadron.algoIs(PFRecoTauChargedHadron::kTrack) && chargedHadron.getTrack().isNonnull()) {
+          reco::TrackRef trackRef(tracks_, chargedHadron.getTrack().key());
+          lostTracks.push_back(trackRef);
+        }
+      }
+      if (verbosity_) {
+        edm::LogPrint("<PFRecoTauLostTrackPlugin::operator()>:")
+            << " tau: Pt = " << tau.pt() << ", eta = " << tau.eta() << ", phi = " << tau.phi()
+            << ", mass = " << tau.mass() << " (decayMode = " << tau.decayMode() << ")"
+            << ", nChHadrs = " << chargedHadrons.size() << ", nLostTracks = " << lostTracks.size();
+      }
+      if (!lostTracks.empty())
+        tau.setsignalTracks(lostTracks);
+    }
+
+    void PFRecoTauLostTrackPlugin::endEvent() {}
+
+  }  // namespace tau
+}  // namespace reco
+
+#include "FWCore/Framework/interface/MakerMacros.h"
+
+DEFINE_EDM_PLUGIN(RecoTauModifierPluginFactory, reco::tau::PFRecoTauLostTrackPlugin, "PFRecoTauLostTrackPlugin");

RecoTauTag/RecoTau/plugins/RecoTauProducer.cc

@@ -266,6 +266,7 @@ void RecoTauProducer::fillDescriptions(edm::ConfigurationDescriptions& descripti
     vpsd_modifiers.addOptional<double>("dRaddPhoton");
     vpsd_modifiers.addOptional<double>("minNeutralHadronEt");
     vpsd_modifiers.addOptional<edm::InputTag>("pfTauTagInfoSrc");
+    vpsd_modifiers.addOptional<edm::InputTag>("trackSrc");
 
     desc.addVPSet("modifiers", vpsd_modifiers);
   }

RecoTauTag/RecoTau/python/RecoTauCombinatoricProducer_cfi.py

@@ -99,11 +99,19 @@
     ),
     # Tau energy reconstruction
     # (to avoid double-counting of energy carried by neutral PFCandidates
-    #  in case PFRecoTauChargedHadrons are built from reco::Tracks)                                          
+    #  in case PFRecoTauChargedHadrons are built from reco::Tracks)
     cms.PSet(
         pfTauEnergyAlgorithmPlugin,
         name = cms.string("tau_en_reconstruction"),
         plugin = cms.string("PFRecoTauEnergyAlgorithmPlugin"),
+    ),
+    # Add refs to "lost tracks", i.e. tracks associated to
+    # PFRecoTauChargedHadrons built from reco::Tracks
+    cms.PSet(
+        name = cms.string("tau_lost_tracks"),
+        trackSrc = cms.InputTag("generalTracks"),
+        plugin = cms.string("PFRecoTauLostTrackPlugin"),
+        verbosity = cms.int32(0)
     )
 ]