Tau reconstruction based on miniAOD event content

DataFormats/JetReco/src/classes_3.h

@@ -125,6 +125,11 @@ namespace DataFormats_JetReco {
     edm::RefToBaseVector<reco::Jet> jrtbv;
     edm::Wrapper<edm::RefToBaseVector<reco::Jet> > jrtbv_w;
     edm::reftobase::BaseVectorHolder<reco::Jet> * bvhj_p;    // pointer since it's pure virtual
+
+    // Generic association (used e.g. in TauReco)
+    edm::AssociationMap<edm::OneToOne<edm::View<reco::Jet>,edm::View<reco::Jet>,unsigned int> > v_j_v_j_am;
+    edm::Wrapper<edm::AssociationMap<edm::OneToOne<edm::View<reco::Jet>,edm::View<reco::Jet>,unsigned int> > > v_j_v_j_am_w;
+    edm::helpers::KeyVal<edm::RefToBaseProd<reco::Jet>,edm::RefToBaseProd<reco::Jet> > v_j_v_j_kv;
   };
 }
 #endif

DataFormats/JetReco/src/classes_def_3.xml

@@ -118,4 +118,10 @@
   <class name="edm::reftobase::RefHolder<reco::PFClusterJetRef>" />
   <class name="edm::reftobase::Holder<reco::Jet, reco::JPTJetRef>" />
   <class name="edm::reftobase::RefHolder<reco::JPTJetRef>" />
+
+  <class name="edm::AssociationMap<edm::OneToOne<edm::View<reco::Jet>,edm::View<reco::Jet>,unsigned int> >">
+      <field name="transientMap_" transient="true" />
+  </class>
+  <class name="edm::Wrapper<edm::AssociationMap<edm::OneToOne<edm::View<reco::Jet>,edm::View<reco::Jet>,unsigned int> > >"/>
+  <class name="edm::helpers::KeyVal<edm::RefToBaseProd<reco::Jet>,edm::RefToBaseProd<reco::Jet> >"/>
 </lcgdict>

DataFormats/PatCandidates/interface/Tau.h

@@ -23,6 +23,7 @@
 #include "DataFormats/PatCandidates/interface/Lepton.h"
 #include "DataFormats/JetReco/interface/GenJetCollection.h"
 #include "DataFormats/Candidate/interface/Candidate.h"
+#include "DataFormats/ParticleFlowCandidate/interface/PFCandidate.h"
 
 #include "DataFormats/PatCandidates/interface/TauPFSpecific.h"
 #include "DataFormats/PatCandidates/interface/TauCaloSpecific.h"
@@ -160,7 +161,7 @@ namespace pat {
       const pat::tau::TauPFEssential & pfEssential() const;
       /// Method copied from reco::PFTau. 
       /// Throws an exception if this pat::Tau was not made from a reco::PFTau
-      const reco::PFJetRef & pfJetRef() const { return pfSpecific().pfJetRef_; }
+      const reco::JetBaseRef & pfJetRef() const { return pfSpecific().pfJetRef_; }
       /// Method copied from reco::PFTau. 
       /// Throws an exception if this pat::Tau was not made from a reco::PFTau
       reco::PFRecoTauChargedHadronRef leadTauChargedHadronCandidate() const;
@@ -452,6 +453,8 @@ namespace pat {
 
 
   private:
+      /// helper to avoid code duplication in constructors
+      void initFromBaseTau(const reco::BaseTau& aTau);
       // ---- for content embedding ----
       bool embeddedIsolationTracks_;
       std::vector<reco::Track> isolationTracks_;

DataFormats/PatCandidates/interface/TauPFSpecific.h

@@ -6,7 +6,7 @@
 
 /**
   \class    pat::tau::PFSpecific TauPFSpecific.h "DataFormats/PatCandidates/interface/TauPFSpecific.h"
-  \brief    Structure to hold information specific to a PFTau inside a pat::Tau
+  \brief    Structure to hold information specific to a PFTau made from PFCandidates inside a pat::Tau
 
   \author   Giovanni Petrucciani
 */
@@ -24,8 +24,8 @@ struct TauPFSpecific {
 // constructor from PFTau
   TauPFSpecific(const reco::PFTau& tau);
 // datamembers 
-  reco::PFJetRef pfJetRef_;
-  reco::PFCandidatePtr leadPFChargedHadrCand_;
+  reco::JetBaseRef pfJetRef_;
+  reco::CandidatePtr leadPFChargedHadrCand_;
   float leadPFChargedHadrCandsignedSipt_;
   reco::PFCandidatePtr leadPFNeutralCand_;
   reco::PFCandidatePtr leadPFCand_;

DataFormats/PatCandidates/src/classes_def_objects.xml

@@ -158,7 +158,8 @@
   <ioread sourceClass="pat::Tau" targetClass="pat::Tau" version="[1-]" source="" target="isolationPFGammaCandsTransientPtrs_">
   <![CDATA[isolationPFGammaCandsTransientPtrs_.reset();]]>
   </ioread>
-  <class name="pat::tau::TauPFSpecific"  ClassVersion="15">
+  <class name="pat::tau::TauPFSpecific"  ClassVersion="16">
+   <version ClassVersion="16" checksum="443572625"/>
    <version ClassVersion="15" checksum="3425877587"/>
    <version ClassVersion="14" checksum="1401440164"/>
    <version ClassVersion="13" checksum="3129436753"/>
@@ -167,6 +168,7 @@
    <version ClassVersion="10" checksum="2617942038"/>
   </class>
   <class name="std::vector<pat::tau::TauPFSpecific>" />
+
   <class name="pat::tau::TauCaloSpecific"  ClassVersion="11">
    <version ClassVersion="11" checksum="943826557"/>
    <version ClassVersion="10" checksum="2692173055"/>
@@ -605,6 +607,16 @@
   <class name="edm::Wrapper< std::vector<edm::Ptr<pat::Jet> > >" />
   <class name="edm::Wrapper< std::vector< std::vector<edm::Ptr<pat::Jet> > > >" />
 
+  <!--  Association for Jet, and AssociationMap Jet-PackedCandidate -->
+  <class name="edm::Association<std::vector<pat::Jet> >"/>
+  <class name="edm::Wrapper<edm::Association<std::vector<pat::Jet> > >"/>
+  <class name="edm::RefProd<vector<pat::Jet> >"/>
+  <class name="edm::AssociationMap<edm::OneToMany<std::vector<pat::Jet>,std::vector<pat::PackedCandidate>,unsigned int> >">
+    <field name="transientMap_" transient="true" />
+  </class>
+  <class name="edm::Wrapper<edm::AssociationMap<edm::OneToMany<std::vector<pat::Jet>,std::vector<pat::PackedCandidate>,unsigned int> > >"/>
+  <class name="edm::helpers::KeyVal<edm::RefProd<vector<pat::Jet> >,edm::RefProd<vector<pat::PackedCandidate> > >"/>
+
   <class name="pat::PATTauDiscriminatorBase">
     <field name="transientVector_" transient="true"/>
   </class>  

DataFormats/PatCandidates/src/classes_objects.h

@@ -1,5 +1,6 @@
 #include "DataFormats/Common/interface/ValueMap.h"
 #include "DataFormats/Common/interface/Association.h"
+#include "DataFormats/Common/interface/AssociationMap.h"
 #include "DataFormats/Common/interface/Wrapper.h"
 #include "DataFormats/Common/interface/PtrVector.h"
 #include "DataFormats/Common/interface/FwdPtr.h"
@@ -200,6 +201,13 @@ namespace DataFormats_PatCandidates {
   edm::Wrapper< std::vector< edm::Ptr<pat::Jet> > > wvptr_jet; 
   edm::Wrapper< std::vector< std::vector< edm::Ptr<pat::Jet> > > > wvvptr_jet;
 
+  edm::Association<std::vector<pat::Jet> > patjet_assoc_vr;
+  edm::Wrapper<edm::Association<std::vector<pat::Jet> > > patjet_assoc_vr_wrapper;
+  edm::RefProd<vector<pat::Jet> > patjet_rp;
+  edm::AssociationMap<edm::OneToMany<std::vector<pat::Jet>,std::vector<pat::PackedCandidate>,unsigned int> >  patjet_v_patpc_v_otm_am;
+  edm::Wrapper<edm::AssociationMap<edm::OneToMany<std::vector<pat::Jet>,std::vector<pat::PackedCandidate>,unsigned int> > >   patjet_v_patpc_v_otm_am_w;
+  edm::helpers::KeyVal<edm::RefProd<vector<pat::Jet> >,edm::RefProd<vector<pat::PackedCandidate> > > patjet_v_patpc_v_kv;
+
   pat::PATTauDiscriminatorBase                     pattdiscr_b;
   pat::PATTauDiscriminator                         pattdiscr_o;
   pat::PATTauDiscriminatorRef                      pattdiscr_r;

DataFormats/TauReco/interface/JetPiZeroAssociation.h

@@ -3,12 +3,12 @@
 
 #include "DataFormats/Common/interface/AssociationVector.h"
 #include "DataFormats/TauReco/interface/RecoTauPiZero.h"
-#include "DataFormats/JetReco/interface/PFJetCollection.h"
+#include "DataFormats/JetReco/interface/JetCollection.h"
 
 namespace reco {
    // This base class improves the readability of the ROOT class name by hiding
    // the template crap
-   typedef edm::AssociationVector<PFJetRefProd, std::vector<std::vector<RecoTauPiZero> > >
+   typedef edm::AssociationVector<JetRefBaseProd, std::vector<std::vector<RecoTauPiZero> > >
      JetPiZeroAssociationBase;  
 
    class JetPiZeroAssociation : public JetPiZeroAssociationBase {
@@ -17,7 +17,7 @@ namespace reco {
       JetPiZeroAssociationBase()
       { }
 
-    JetPiZeroAssociation(const reco::PFJetRefProd & ref) :
+    JetPiZeroAssociation(const JetRefBaseProd & ref) :
       JetPiZeroAssociationBase(ref)
       { }
 

DataFormats/TauReco/interface/PFJetChargedHadronAssociation.h

@@ -3,13 +3,13 @@
 
 #include "DataFormats/Common/interface/AssociationVector.h"
 #include "DataFormats/TauReco/interface/PFRecoTauChargedHadron.h"
-#include "DataFormats/JetReco/interface/PFJetCollection.h"
+#include "DataFormats/JetReco/interface/JetCollection.h"
 
 namespace reco 
 {
   // This base class improves the readability of the ROOT class name by hiding
   // the template crap
-  typedef edm::AssociationVector<PFJetRefProd, std::vector<std::vector<PFRecoTauChargedHadron> > > PFJetChargedHadronAssociationBase;  
+  typedef edm::AssociationVector<JetRefBaseProd, std::vector<std::vector<PFRecoTauChargedHadron> > > PFJetChargedHadronAssociationBase;  
 
   class PFJetChargedHadronAssociation : public PFJetChargedHadronAssociationBase 
   {
@@ -18,7 +18,7 @@ namespace reco
       : PFJetChargedHadronAssociationBase()
     {}
 
-    PFJetChargedHadronAssociation(const reco::PFJetRefProd& ref) 
+    PFJetChargedHadronAssociation(const reco::JetRefBaseProd& ref) 
       : PFJetChargedHadronAssociationBase(ref)
     {}
 

DataFormats/TauReco/interface/PFRecoTauChargedHadron.h

@@ -2,14 +2,15 @@
 #define DataFormats_TauReco_PFRecoTauChargedHadron_h
 
 #include "DataFormats/Candidate/interface/CompositePtrCandidate.h"
-#include "DataFormats/ParticleFlowCandidate/interface/PFCandidateFwd.h"
+#include "DataFormats/Candidate/interface/CandidateFwd.h"
 #include "DataFormats/TrackReco/interface/Track.h"
 #include "DataFormats/Common/interface/Ptr.h"
 #include "DataFormats/Math/interface/Point3D.h"
 
 namespace reco { namespace tau {
+  template<class TrackClass>
+  class PFRecoTauChargedHadronFromGenericTrackPlugin;
   class PFRecoTauChargedHadronFromPFCandidatePlugin;
-  class PFRecoTauChargedHadronFromTrackPlugin;
   class RecoTauConstructor;
   class PFRecoTauEnergyAlgorithmPlugin;
 }} 
@@ -47,13 +48,16 @@ class PFRecoTauChargedHadron : public CompositePtrCandidate
   ~PFRecoTauChargedHadron() override;
 
   /// reference to "charged" PFCandidate (either charged PFCandidate or PFNeutralHadron)
-  const PFCandidatePtr& getChargedPFCandidate() const;
+  const CandidatePtr& getChargedPFCandidate() const;
 
   /// reference to reco::Track
   const TrackPtr& getTrack() const;
 
+  /// reference to "lostTrack Candidate" when chadron built with tracks stored as pat::PackedCandidates
+  const CandidatePtr& getLostTrackCandidate() const;
+
   /// references to additional neutral PFCandidates
-  const std::vector<PFCandidatePtr>& getNeutralPFCandidates() const;  
+  const std::vector<CandidatePtr>& getNeutralPFCandidates() const;  
 
   /// position at ECAL entrance
   const math::XYZPointF& positionAtECALEntrance() const;
@@ -68,16 +72,18 @@ class PFRecoTauChargedHadron : public CompositePtrCandidate
 
  private:
   friend class tau::PFRecoTauChargedHadronFromPFCandidatePlugin;
-  friend class tau::PFRecoTauChargedHadronFromTrackPlugin;
+  template<class TrackClass>
+  friend class tau::PFRecoTauChargedHadronFromGenericTrackPlugin;
   friend class tau::RecoTauConstructor;
   friend class tau::PFRecoTauEnergyAlgorithmPlugin;
   friend class ::PFRecoTauChargedHadronProducer;
 
   PFRecoTauChargedHadronAlgorithm algo_;
 
-  PFCandidatePtr chargedPFCandidate_;
+  CandidatePtr chargedPFCandidate_;
+  CandidatePtr lostTrackCandidate_;
   TrackPtr track_;
-  std::vector<PFCandidatePtr> neutralPFCandidates_;
+  std::vector<CandidatePtr> neutralPFCandidates_;
 
   math::XYZPointF positionAtECALEntrance_;
 };

DataFormats/TauReco/interface/PFTau.h

@@ -13,9 +13,9 @@
 #include "DataFormats/TauReco/interface/BaseTau.h"
 #include "DataFormats/TauReco/interface/PFTauFwd.h"
 #include "DataFormats/TauReco/interface/PFTauTagInfo.h"
-#include "DataFormats/JetReco/interface/PFJetCollection.h"
-#include "DataFormats/ParticleFlowCandidate/interface/PFCandidate.h"
-#include "DataFormats/ParticleFlowCandidate/interface/PFCandidateFwd.h"
+#include "DataFormats/JetReco/interface/JetCollection.h"
+#include "DataFormats/Candidate/interface/Candidate.h"
+#include "DataFormats/Candidate/interface/CandidateFwd.h"
 #include "DataFormats/TauReco/interface/RecoTauPiZero.h"
 #include "DataFormats/TauReco/interface/RecoTauPiZeroFwd.h"
 #include "DataFormats/TauReco/interface/PFRecoTauChargedHadron.h"
@@ -58,59 +58,72 @@ class PFTau : public BaseTau {
     ~PFTau() override {};
     PFTau* clone() const override;
 
-    const PFJetRef& jetRef() const;
-    void setjetRef(const PFJetRef&);
+    const JetBaseRef& jetRef() const;
+    void setjetRef(const JetBaseRef&);
 
     // functions to access the PFTauTagInfoRef used by HLT
     const PFTauTagInfoRef& pfTauTagInfoRef() const;
     void setpfTauTagInfoRef(const PFTauTagInfoRef);
 
     PFRecoTauChargedHadronRef leadTauChargedHadronCandidate() const;
-    const PFCandidatePtr& leadPFChargedHadrCand() const;
-    const PFCandidatePtr& leadPFNeutralCand() const;
+    const CandidatePtr& leadChargedHadrCand() const;
+    const CandidatePtr& leadNeutralCand() const;
     //Can be either the charged or the neutral one
-    const PFCandidatePtr& leadPFCand() const;
+    const CandidatePtr& leadCand() const;
 
-    void setleadPFChargedHadrCand(const PFCandidatePtr&);
-    void setleadPFNeutralCand(const PFCandidatePtr&);
-    void setleadPFCand(const PFCandidatePtr&);
+    void setleadChargedHadrCand(const CandidatePtr&);
+    void setleadNeutralCand(const CandidatePtr&);
+    void setleadCand(const CandidatePtr&);
 
     /// Signed transverse impact parameter significance of the Track
     /// associated to the leading charged PFCandidate
     float leadPFChargedHadrCandsignedSipt() const;
     void setleadPFChargedHadrCandsignedSipt(const float&);
 
-    /// PFCandidates in signal region
-    const std::vector<reco::PFCandidatePtr>& signalPFCands() const;
-    void setsignalPFCands(const std::vector<reco::PFCandidatePtr>&);
+    /// Candidates in signal region
+    const std::vector<reco::CandidatePtr>& signalCands() const;
+    void setsignalCands(const std::vector<reco::CandidatePtr>&);
 
     /// Charged hadrons in signal region
-    const std::vector<reco::PFCandidatePtr>& signalPFChargedHadrCands() const;
-    void setsignalPFChargedHadrCands(const std::vector<reco::PFCandidatePtr>&);
+    const std::vector<reco::CandidatePtr>& signalChargedHadrCands() const;
+    void setsignalChargedHadrCands(const std::vector<reco::CandidatePtr>&);
 
     /// Neutral hadrons in signal region
-    const std::vector<reco::PFCandidatePtr>& signalPFNeutrHadrCands() const;
-    void setsignalPFNeutrHadrCands(const std::vector<reco::PFCandidatePtr>&);
+    const std::vector<reco::CandidatePtr>& signalNeutrHadrCands() const;
+    void setsignalNeutrHadrCands(const std::vector<reco::CandidatePtr>&);
 
     /// Gamma candidates in signal region
-    const std::vector<reco::PFCandidatePtr>& signalPFGammaCands() const;
-    void setsignalPFGammaCands(const std::vector<reco::PFCandidatePtr>&);
+    const std::vector<reco::CandidatePtr>& signalGammaCands() const;
+    void setsignalGammaCands(const std::vector<reco::CandidatePtr>&);
 
-    /// PFCandidates in isolation region
-    const std::vector<reco::PFCandidatePtr>& isolationPFCands() const;
-    void setisolationPFCands(const std::vector<reco::PFCandidatePtr>&);
+    /// Candidates in isolation region
+    const std::vector<reco::CandidatePtr>& isolationCands() const;
+    void setisolationCands(const std::vector<reco::CandidatePtr>&);
 
     /// Charged candidates in isolation region
-    const std::vector<reco::PFCandidatePtr>& isolationPFChargedHadrCands() const;
-    void setisolationPFChargedHadrCands(const std::vector<reco::PFCandidatePtr>&);
+    const std::vector<reco::CandidatePtr>& isolationChargedHadrCands() const;
+    void setisolationChargedHadrCands(const std::vector<reco::CandidatePtr>&);
 
     //// Neutral hadrons in isolation region
-    const std::vector<reco::PFCandidatePtr>& isolationPFNeutrHadrCands() const;
-    void setisolationPFNeutrHadrCands(const std::vector<reco::PFCandidatePtr>&);
+    const std::vector<reco::CandidatePtr>& isolationNeutrHadrCands() const;
+    void setisolationNeutrHadrCands(const std::vector<reco::CandidatePtr>&);
 
     /// Gamma candidates in isolation region
+    const std::vector<reco::CandidatePtr>& isolationGammaCands() const;
+    void setisolationGammaCands(const std::vector<reco::CandidatePtr>&);
+
+    /// Getters for different PFCandidates for PFTaus made from PFCandidates
+    const PFCandidatePtr leadPFChargedHadrCand() const;
+    const PFCandidatePtr leadPFNeutralCand() const;
+    const PFCandidatePtr leadPFCand() const;
+    const std::vector<reco::PFCandidatePtr>& signalPFCands() const;
+    const std::vector<reco::PFCandidatePtr>& signalPFChargedHadrCands() const;
+    const std::vector<reco::PFCandidatePtr>& signalPFNeutrHadrCands() const;
+    const std::vector<reco::PFCandidatePtr>& signalPFGammaCands() const;
+    const std::vector<reco::PFCandidatePtr>& isolationPFCands() const;
+    const std::vector<reco::PFCandidatePtr>& isolationPFChargedHadrCands() const;
+    const std::vector<reco::PFCandidatePtr>& isolationPFNeutrHadrCands() const;
     const std::vector<reco::PFCandidatePtr>& isolationPFGammaCands() const;
-    void setisolationPFGammaCands(const std::vector<reco::PFCandidatePtr>&);
 
     /// Sum of charged hadron candidate PT in isolation cone; returns NaN
     /// if isolation region is undefined.
@@ -244,24 +257,39 @@ class PFTau : public BaseTau {
 
     float signalConeSize_; 
 
-    reco::PFJetRef jetRef_;
+    reco::JetBaseRef jetRef_;
     PFTauTagInfoRef PFTauTagInfoRef_;
-    reco::PFCandidatePtr leadPFChargedHadrCand_;
-    reco::PFCandidatePtr leadPFNeutralCand_;
-    reco::PFCandidatePtr leadPFCand_;
+    reco::CandidatePtr leadChargedHadrCand_;
+    reco::CandidatePtr leadNeutralCand_;
+    reco::CandidatePtr leadCand_;
     reco::TrackRef electronPreIDTrack_;
 
     // Signal candidates
-    std::vector<reco::PFCandidatePtr> selectedSignalPFCands_;
-    std::vector<reco::PFCandidatePtr> selectedSignalPFChargedHadrCands_;
-    std::vector<reco::PFCandidatePtr> selectedSignalPFNeutrHadrCands_;
-    std::vector<reco::PFCandidatePtr> selectedSignalPFGammaCands_;
+    std::vector<reco::CandidatePtr> selectedSignalCands_;
+    std::vector<reco::CandidatePtr> selectedSignalChargedHadrCands_;
+    std::vector<reco::CandidatePtr> selectedSignalNeutrHadrCands_;
+    std::vector<reco::CandidatePtr> selectedSignalGammaCands_;
 
     // Isolation candidates
-    std::vector<reco::PFCandidatePtr> selectedIsolationPFCands_;
-    std::vector<reco::PFCandidatePtr> selectedIsolationPFChargedHadrCands_;
-    std::vector<reco::PFCandidatePtr> selectedIsolationPFNeutrHadrCands_;
-    std::vector<reco::PFCandidatePtr> selectedIsolationPFGammaCands_;
+    std::vector<reco::CandidatePtr> selectedIsolationCands_;
+    std::vector<reco::CandidatePtr> selectedIsolationChargedHadrCands_;
+    std::vector<reco::CandidatePtr> selectedIsolationNeutrHadrCands_;
+    std::vector<reco::CandidatePtr> selectedIsolationGammaCands_;
+
+    // Transient caches for PFCandidate-based accessors
+    edm::AtomicPtrCache<reco::PFCandidatePtr> leadPFChargedHadrCand_;
+    edm::AtomicPtrCache<reco::PFCandidatePtr> leadPFNeutralCand_;
+    edm::AtomicPtrCache<reco::PFCandidatePtr> leadPFCand_;
+
+    edm::AtomicPtrCache<std::vector<reco::PFCandidatePtr> > selectedTransientSignalPFCands_;
+    edm::AtomicPtrCache<std::vector<reco::PFCandidatePtr> > selectedTransientSignalPFChargedHadrCands_;
+    edm::AtomicPtrCache<std::vector<reco::PFCandidatePtr> > selectedTransientSignalPFNeutrHadrCands_;
+    edm::AtomicPtrCache<std::vector<reco::PFCandidatePtr> > selectedTransientSignalPFGammaCands_;
+
+    edm::AtomicPtrCache<std::vector<reco::PFCandidatePtr> > selectedTransientIsolationPFCands_;
+    edm::AtomicPtrCache<std::vector<reco::PFCandidatePtr> > selectedTransientIsolationPFChargedHadrCands_;
+    edm::AtomicPtrCache<std::vector<reco::PFCandidatePtr> > selectedTransientIsolationPFNeutrHadrCands_;
+    edm::AtomicPtrCache<std::vector<reco::PFCandidatePtr> > selectedTransientIsolationPFGammaCands_;
 
     RecoTauPiZeroRefVector signalPiZeroCandidatesRefs_;
     RecoTauPiZeroRefVector isolationPiZeroCandidatesRefs_;