DataFormats/PatCandidates/interface/Jet.h - master - githubmirror/cmssw

DataFormats/PatCandidates/interface/Jet.h
766 строк36 KB
Matti Kortelainen
Move stored types in io_v1 namespace, reset class versions to 3
22 май 2026, 18:18
22 май 2026, 18:18909f324
//
//

#ifndef DataFormats_PatCandidates_Jet_h
#define DataFormats_PatCandidates_Jet_h

/**
  \class    pat::Jet Jet.h "DataFormats/PatCandidates/interface/Jet.h"
  \brief    Analysis-level calorimeter jet class

   Jet implements the analysis-level calorimeter jet class within the
   'pat' namespace

  \author   Steven Lowette, Giovanni Petrucciani, Roger Wolf, Christian Autermann
*/

#include "DataFormats/JetReco/interface/CaloJet.h"
#include "DataFormats/JetReco/interface/BasicJet.h"
#include "DataFormats/JetReco/interface/JPTJet.h"
#include "DataFormats/JetReco/interface/PFJet.h"
#include "DataFormats/CaloTowers/interface/CaloTower.h"
#include "DataFormats/JetReco/interface/GenJet.h"
#include "DataFormats/Candidate/interface/Particle.h"
#include "DataFormats/TrackReco/interface/Track.h"
#include "DataFormats/TrackReco/interface/TrackFwd.h"
#include "DataFormats/BTauReco/interface/JetTag.h"
#include "DataFormats/PatCandidates/interface/PATObject.h"
#include "DataFormats/BTauReco/interface/CandIPTagInfo.h"
#include "DataFormats/BTauReco/interface/TrackIPTagInfo.h"
#include "DataFormats/BTauReco/interface/TrackProbabilityTagInfo.h"
#include "DataFormats/BTauReco/interface/TrackCountingTagInfo.h"
#include "DataFormats/BTauReco/interface/CandSoftLeptonTagInfo.h"
#include "DataFormats/BTauReco/interface/SoftLeptonTagInfo.h"
#include "DataFormats/JetMatching/interface/JetFlavourInfo.h"
#include "DataFormats/BTauReco/interface/PixelClusterTagInfo.h"
#include "DataFormats/BTauReco/interface/CandSecondaryVertexTagInfo.h"
#include "DataFormats/BTauReco/interface/SecondaryVertexTagInfo.h"
#include "DataFormats/BTauReco/interface/BoostedDoubleSVTagInfo.h"
#include "DataFormats/PatCandidates/interface/JetCorrFactors.h"
#include "DataFormats/JetReco/interface/JetID.h"

#include "DataFormats/ParticleFlowCandidate/interface/PFCandidateFwd.h"
#include "DataFormats/ParticleFlowCandidate/interface/PFCandidate.h"

#include "DataFormats/Common/interface/Ptr.h"
#include "DataFormats/Common/interface/OwnVector.h"
#include "DataFormats/Common/interface/AtomicPtrCache.h"

#include <numeric>

// Forward declaration for scouting
class Run3ScoutingPFJet;

// Define typedefs for convenience
namespace pat {
  namespace io_v1 {
    class Jet;
  }
  using Jet = io_v1::Jet;
  typedef std::vector<Jet> JetCollection;
  typedef edm::Ref<JetCollection> JetRef;
  typedef edm::RefVector<JetCollection> JetRefVector;
}  // namespace pat

namespace reco {
  /// pipe operator (introduced to use pat::Jet with PFTopProjectors)
  std::ostream& operator<<(std::ostream& out, const pat::Jet& obj);
}  // namespace reco

// Class definition
namespace pat {

  class PATJetProducer;
  class PATJetSlimmer;
  class PATJetUpdater;

  typedef reco::CaloJet::Specific CaloSpecific;
  typedef reco::JPTJet::Specific JPTSpecific;
  typedef reco::PFJet::Specific PFSpecific;
  typedef std::vector<edm::FwdPtr<reco::BaseTagInfo> > TagInfoFwdPtrCollection;
  typedef std::vector<edm::FwdPtr<reco::PFCandidate> > PFCandidateFwdPtrCollection;
  typedef std::vector<edm::FwdPtr<CaloTower> > CaloTowerFwdPtrCollection;
  typedef std::vector<edm::Ptr<pat::Jet> > JetPtrCollection;

  namespace io_v1 {
    class Jet : public PATObject<reco::Jet> {
      /// make friends with PATJetProducer so that it can set the an initial
      /// jet energy scale unequal to raw calling the private initializeJEC
      /// function, which should be non accessible to any other user
      friend class pat::PATJetProducer;
      friend class pat::PATJetSlimmer;
      friend class pat::PATJetUpdater;

    public:
      /// default constructor
      Jet();
      /// constructor from a reco::Jet
      Jet(const reco::Jet& aJet);
      /// constructor from ref to reco::Jet
      Jet(const edm::RefToBase<reco::Jet>& aJetRef);
      /// constructor from ref to reco::Jet
      Jet(const edm::Ptr<reco::Jet>& aJetRef);
      /// constructure from ref to pat::Jet
      Jet(const edm::RefToBase<pat::Jet>& aJetRef);
      /// constructure from ref to pat::Jet
      Jet(const edm::Ptr<pat::Jet>& aJetRef);
      /// constructor from Run3ScoutingPFJet
      Jet(const Run3ScoutingPFJet& scoutingJet);
      /// destructor
      ~Jet() override;
      /// required reimplementation of the Candidate's clone method
      Jet* clone() const override { return new Jet(*this); }

      /// ---- methods for MC matching ----

      /// return the matched generated parton
      const reco::GenParticle* genParton() const { return genParticle(); }
      /// return the matched generated jet
      const reco::GenJet* genJet() const;
      /// return the parton-based flavour of the jet
      int partonFlavour() const;
      /// return the hadron-based flavour of the jet
      int hadronFlavour() const;
      /// return the JetFlavourInfo of the jet
      const reco::JetFlavourInfo& jetFlavourInfo() const;

    public:
      /// ---- methods for jet corrections ----

      /// returns the labels of all available sets of jet energy corrections
      const std::vector<std::string> availableJECSets() const;
      // returns the available JEC Levels for a given jecSet
      const std::vector<std::string> availableJECLevels(const int& set = 0) const;
      // returns the available JEC Levels for a given jecSet
      const std::vector<std::string> availableJECLevels(const std::string& set) const {
        return availableJECLevels(jecSet(set));
      };
      /// returns true if the jet carries jet energy correction information
      /// at all
      bool jecSetsAvailable() const { return !jec_.empty(); }
      /// returns true if the jet carries a set of jet energy correction
      /// factors with the given label
      bool jecSetAvailable(const std::string& set) const { return (jecSet(set) >= 0); };
      /// returns true if the jet carries a set of jet energy correction
      /// factors with the given label
      bool jecSetAvailable(const unsigned int& set) const { return (set < jec_.size()); };
      /// returns the label of the current set of jet energy corrections
      std::string currentJECSet() const {
        return currentJECSet_ < jec_.size() ? jec_.at(currentJECSet_).jecSet() : std::string("ERROR");
      }
      /// return the name of the current step of jet energy corrections
      std::string currentJECLevel() const {
        return currentJECSet_ < jec_.size() ? jec_.at(currentJECSet_).jecLevel(currentJECLevel_) : std::string("ERROR");
      };
      /// return flavour of the current step of jet energy corrections
      JetCorrFactors::Flavor currentJECFlavor() const { return currentJECFlavor_; };
      /// correction factor to the given level for a specific set
      /// of correction factors, starting from the current level
      float jecFactor(const std::string& level, const std::string& flavor = "none", const std::string& set = "") const;
      /// correction factor to the given level for a specific set
      /// of correction factors, starting from the current level
      float jecFactor(const unsigned int& level,
                      const JetCorrFactors::Flavor& flavor = JetCorrFactors::NONE,
                      const unsigned int& set = 0) const;
      /// copy of the jet corrected up to the given level for the set
      /// of jet energy correction factors, which is currently in use
      Jet correctedJet(const std::string& level, const std::string& flavor = "none", const std::string& set = "") const;
      /// copy of the jet corrected up to the given level for the set
      /// of jet energy correction factors, which is currently in use
      Jet correctedJet(const unsigned int& level,
                       const JetCorrFactors::Flavor& flavor = JetCorrFactors::NONE,
                       const unsigned int& set = 0) const;
      /// p4 of the jet corrected up to the given level for the set
      /// of jet energy correction factors, which is currently in use
      const LorentzVector correctedP4(const std::string& level,
                                      const std::string& flavor = "none",
                                      const std::string& set = "") const {
        return correctedJet(level, flavor, set).p4();
      };
      /// p4 of the jet corrected up to the given level for the set
      /// of jet energy correction factors, which is currently in use
      const LorentzVector correctedP4(const unsigned int& level,
                                      const JetCorrFactors::Flavor& flavor = JetCorrFactors::NONE,
                                      const unsigned int& set = 0) const {
        return correctedJet(level, flavor, set).p4();
      };
      /// Scale energy and correspondingly adjust raw jec factors
      void scaleEnergy(double fScale) override { scaleEnergy(fScale, "Unscaled"); }
      void scaleEnergy(double fScale, const std::string& level);

    private:
      /// index of the set of jec factors with given label; returns -1 if no set
      /// of jec factors exists with the given label
      int jecSet(const std::string& label) const;
      /// update the current JEC set; used by correctedJet
      void currentJECSet(const unsigned int& set) { currentJECSet_ = set; };
      /// update the current JEC level; used by correctedJet
      void currentJECLevel(const unsigned int& level) { currentJECLevel_ = level; };
      /// update the current JEC flavor; used by correctedJet
      void currentJECFlavor(const JetCorrFactors::Flavor& flavor) { currentJECFlavor_ = flavor; };
      /// add more sets of energy correction factors
      void addJECFactors(const JetCorrFactors& jec) { jec_.push_back(jec); };
      /// initialize the jet to a given JEC level during creation starting from Uncorrected
      void initializeJEC(unsigned int level,
                         const JetCorrFactors::Flavor& flavor = JetCorrFactors::NONE,
                         unsigned int set = 0);

    public:
      /// ---- methods for accessing b-tagging info ----

      /// get b discriminant from label name
      float bDiscriminator(const std::string& theLabel) const;
      /// get vector of paire labelname-disciValue
      const std::vector<std::pair<std::string, float> >& getPairDiscri() const;
      /// get list of tag info labels
      std::vector<std::string> const& tagInfoLabels() const { return tagInfoLabels_; }
      /// check to see if the given tag info is nonzero
      bool hasTagInfo(const std::string label) const { return tagInfo(label) != nullptr; }
      /// get a tagInfo with the given name, or NULL if none is found.
      /// You should omit the 'TagInfos' part from the label
      const reco::BaseTagInfo* tagInfo(const std::string& label) const;
      /// get a tagInfo with the given name and type or NULL if none is found.
      /// If the label is empty or not specified, it returns the first tagInfo of that type (if any one exists)
      /// you should omit the 'TagInfos' part from the label
      const reco::CandIPTagInfo* tagInfoCandIP(const std::string& label = "") const;
      const reco::TrackIPTagInfo* tagInfoTrackIP(const std::string& label = "") const;
      /// get a tagInfo with the given name and type or NULL if none is found.
      /// If the label is empty or not specified, it returns the first tagInfo of that type (if any one exists)
      /// you should omit the 'TagInfos' part from the label
      const reco::CandSoftLeptonTagInfo* tagInfoCandSoftLepton(const std::string& label = "") const;
      const reco::SoftLeptonTagInfo* tagInfoSoftLepton(const std::string& label = "") const;
      /// get a tagInfo with the given name and type or NULL if none is found.
      /// If the label is empty or not specified, it returns the first tagInfo of that type (if any one exists)
      /// you should omit the 'TagInfos' part from the label
      const reco::CandSecondaryVertexTagInfo* tagInfoCandSecondaryVertex(const std::string& label = "") const;
      const reco::SecondaryVertexTagInfo* tagInfoSecondaryVertex(const std::string& label = "") const;
      const reco::BoostedDoubleSVTagInfo* tagInfoBoostedDoubleSV(const std::string& label = "") const;
      /// get a tagInfo with the given name and type or NULL if none is found.
      /// If the label is empty or not specified, it returns the first tagInfo of that type (if any one exists)
      /// you should omit the 'TagInfos' part from the label
      const reco::PixelClusterTagInfo* tagInfoPixelCluster(const std::string& label = "") const;
      /// method to add a algolabel-discriminator pair
      void addBDiscriminatorPair(const std::pair<std::string, float>& thePair);
      /// sets a tagInfo with the given name from an edm::Ptr<T> to it.
      /// If the label ends with 'TagInfos', the 'TagInfos' is stripped out.
      void addTagInfo(const std::string& label, const TagInfoFwdPtrCollection::value_type& info);

      // ---- track related methods ----

      /// method to return the JetCharge computed when creating the Jet
      float jetCharge() const;
      /// method to return a vector of refs to the tracks associated to this jet
      const reco::TrackRefVector& associatedTracks() const;
      /// method to set the jet charge
      void setJetCharge(float jetCharge);
      /// method to set the vector of refs to the tracks associated to this jet
      void setAssociatedTracks(const reco::TrackRefVector& tracks);

      // ---- methods for content embedding ----

      /// method to store the CaloJet constituents internally
      void setCaloTowers(const CaloTowerFwdPtrCollection& caloTowers);
      /// method to store the PFCandidate constituents internally
      void setPFCandidates(const PFCandidateFwdPtrCollection& pfCandidates);
      /// method to set the matched parton
      void setGenParton(const reco::GenParticleRef& gp, bool embed = false) { setGenParticleRef(gp, embed); }
      /// method to set the matched generated jet reference, embedding if requested
      void setGenJetRef(const edm::FwdRef<reco::GenJetCollection>& gj);
      /// method to set the parton-based flavour of the jet
      void setPartonFlavour(int partonFl);
      /// method to set the hadron-based flavour of the jet
      void setHadronFlavour(int hadronFl);
      /// method to set the JetFlavourInfo of the jet
      void setJetFlavourInfo(const reco::JetFlavourInfo& jetFlavourInfo);

      /// methods for jet ID
      void setJetID(reco::JetID const& id) { jetID_ = id; }

      // ---- jet specific methods ----

      /// check to see if the jet is a reco::CaloJet
      bool isCaloJet() const { return !specificCalo_.empty() && !isJPTJet(); }
      /// check to see if the jet is a reco::JPTJet
      bool isJPTJet() const { return !specificJPT_.empty(); }
      /// check to see if the jet is a reco::PFJet
      bool isPFJet() const { return !specificPF_.empty(); }
      /// check to see if the jet is no more than a reco::BasicJet
      bool isBasicJet() const { return !(isCaloJet() || isPFJet() || isJPTJet()); }
      /// retrieve the calo specific part of the jet
      const CaloSpecific& caloSpecific() const {
        if (specificCalo_.empty())
          throw cms::Exception("Type Mismatch") << "This PAT jet was not made from a CaloJet.\n";
        return specificCalo_[0];
      }
      /// retrieve the jpt specific part of the jet
      const JPTSpecific& jptSpecific() const {
        if (specificJPT_.empty())
          throw cms::Exception("Type Mismatch") << "This PAT jet was not made from a JPTJet.\n";
        return specificJPT_[0];
      }
      /// check to see if the PFSpecific object is stored
      bool hasPFSpecific() const { return !specificPF_.empty(); }
      /// retrieve the pf specific part of the jet
      const PFSpecific& pfSpecific() const {
        if (specificPF_.empty())
          throw cms::Exception("Type Mismatch") << "This PAT jet was not made from a PFJet.\n";
        return specificPF_[0];
      }
      /// set the calo specific part of the jet
      void setCaloSpecific(const CaloSpecific& newCaloSpecific) {
        if (specificCalo_.empty())
          throw cms::Exception("Type Mismatch") << "This PAT jet was not made from a CaloJet.\n";
        specificCalo_[0] = newCaloSpecific;
      }
      /// set the jpt specific part of the jet
      void setJPTSpecific(const JPTSpecific& newJPTSpecific) {
        if (specificJPT_.empty())
          throw cms::Exception("Type Mismatch") << "This PAT jet was not made from a JPTJet.\n";
        specificJPT_[0] = newJPTSpecific;
      }
      /// set the pf specific part of the jet
      void setPFSpecific(const PFSpecific& newPFSpecific) {
        if (specificPF_.empty())
          throw cms::Exception("Type Mismatch") << "This PAT jet was not made from a PFJet.\n";
        specificPF_[0] = newPFSpecific;
      }

      // ---- Calo Jet specific information ----

      /// returns the maximum energy deposited in ECAL towers
      float maxEInEmTowers() const { return caloSpecific().mMaxEInEmTowers; }
      /// returns the maximum energy deposited in HCAL towers
      float maxEInHadTowers() const { return caloSpecific().mMaxEInHadTowers; }
      /// returns the jet hadronic energy fraction
      float energyFractionHadronic() const { return caloSpecific().mEnergyFractionHadronic; }
      /// returns the jet electromagnetic energy fraction
      float emEnergyFraction() const { return caloSpecific().mEnergyFractionEm; }
      /// returns the jet hadronic energy in HB
      float hadEnergyInHB() const { return caloSpecific().mHadEnergyInHB; }
      /// returns the jet hadronic energy in HO
      float hadEnergyInHO() const { return caloSpecific().mHadEnergyInHO; }
      /// returns the jet hadronic energy in HE
      float hadEnergyInHE() const { return caloSpecific().mHadEnergyInHE; }
      /// returns the jet hadronic energy in HF
      float hadEnergyInHF() const { return caloSpecific().mHadEnergyInHF; }
      /// returns the jet electromagnetic energy in EB
      float emEnergyInEB() const { return caloSpecific().mEmEnergyInEB; }
      /// returns the jet electromagnetic energy in EE
      float emEnergyInEE() const { return caloSpecific().mEmEnergyInEE; }
      /// returns the jet electromagnetic energy extracted from HF
      float emEnergyInHF() const { return caloSpecific().mEmEnergyInHF; }
      /// returns area of contributing towers
      float towersArea() const { return caloSpecific().mTowersArea; }
      /// returns the number of constituents carrying a 90% of the total Jet energy*/
      int n90() const { return nCarrying(0.9); }
      /// returns the number of constituents carrying a 60% of the total Jet energy*/
      int n60() const { return nCarrying(0.6); }

      /// convert generic constituent to specific type
      //  static CaloTowerPtr caloTower (const reco::Candidate* fConstituent);
      /// get specific constituent of the CaloJet.
      /// if the caloTowers were embedded, this reference is transient only and must not be persisted
      CaloTowerPtr getCaloConstituent(unsigned fIndex) const;
      /// get the constituents of the CaloJet.
      /// If the caloTowers were embedded, these reference are transient only and must not be persisted
      std::vector<CaloTowerPtr> const& getCaloConstituents() const;

      // ---- JPT Jet specific information ----

      /// pions fully contained in cone
      const reco::TrackRefVector& pionsInVertexInCalo() const { return jptSpecific().pionsInVertexInCalo; }
      /// pions that curled out
      const reco::TrackRefVector& pionsInVertexOutCalo() const { return jptSpecific().pionsInVertexOutCalo; }
      /// pions that curled in
      const reco::TrackRefVector& pionsOutVertexInCalo() const { return jptSpecific().pionsOutVertexInCalo; }
      /// muons fully contained in cone
      const reco::TrackRefVector& muonsInVertexInCalo() const { return jptSpecific().muonsInVertexInCalo; }
      /// muons that curled out
      const reco::TrackRefVector& muonsInVertexOutCalo() const { return jptSpecific().muonsInVertexOutCalo; }
      /// muons that curled in
      const reco::TrackRefVector& muonsOutVertexInCalo() const { return jptSpecific().muonsOutVertexInCalo; }
      /// electrons fully contained in cone
      const reco::TrackRefVector& elecsInVertexInCalo() const { return jptSpecific().elecsInVertexInCalo; }
      /// electrons that curled out
      const reco::TrackRefVector& elecsInVertexOutCalo() const { return jptSpecific().elecsInVertexOutCalo; }
      /// electrons that curled in
      const reco::TrackRefVector& elecsOutVertexInCalo() const { return jptSpecific().elecsOutVertexInCalo; }
      /// chargedMultiplicity
      float elecMultiplicity() const {
        return jptSpecific().elecsInVertexInCalo.size() + jptSpecific().elecsInVertexOutCalo.size();
      }

      // ---- JPT or PF Jet specific information ----

      /// muonMultiplicity
      int muonMultiplicity() const;
      /// chargedMultiplicity
      int chargedMultiplicity() const;
      /// chargedEmEnergy
      float chargedEmEnergy() const;
      /// neutralEmEnergy
      float neutralEmEnergy() const;
      /// chargedHadronEnergy
      float chargedHadronEnergy() const;
      /// neutralHadronEnergy
      float neutralHadronEnergy() const;

      /// chargedHadronEnergyFraction (relative to uncorrected jet energy)
      float chargedHadronEnergyFraction() const {
        return chargedHadronEnergy() / ((jecSetsAvailable() ? jecFactor(0) : 1.) * energy());
      }
      /// neutralHadronEnergyFraction (relative to uncorrected jet energy)
      float neutralHadronEnergyFraction() const {
        return neutralHadronEnergy() / ((jecSetsAvailable() ? jecFactor(0) : 1.) * energy());
      }
      /// chargedEmEnergyFraction (relative to uncorrected jet energy)
      float chargedEmEnergyFraction() const {
        return chargedEmEnergy() / ((jecSetsAvailable() ? jecFactor(0) : 1.) * energy());
      }
      /// neutralEmEnergyFraction (relative to uncorrected jet energy)
      float neutralEmEnergyFraction() const {
        return neutralEmEnergy() / ((jecSetsAvailable() ? jecFactor(0) : 1.) * energy());
      }

      // ---- PF Jet specific information ----
      /// photonEnergy
      float photonEnergy() const { return pfSpecific().mPhotonEnergy; }
      /// photonEnergyFraction (relative to corrected jet energy)
      float photonEnergyFraction() const {
        return photonEnergy() / ((jecSetsAvailable() ? jecFactor(0) : 1.) * energy());
      }
      /// electronEnergy
      float electronEnergy() const { return pfSpecific().mElectronEnergy; }
      /// electronEnergyFraction (relative to corrected jet energy)
      float electronEnergyFraction() const {
        return electronEnergy() / ((jecSetsAvailable() ? jecFactor(0) : 1.) * energy());
      }
      /// muonEnergy
      float muonEnergy() const { return pfSpecific().mMuonEnergy; }
      /// muonEnergyFraction (relative to corrected jet energy)
      float muonEnergyFraction() const { return muonEnergy() / ((jecSetsAvailable() ? jecFactor(0) : 1.) * energy()); }
      /// HFHadronEnergy
      float HFHadronEnergy() const { return pfSpecific().mHFHadronEnergy; }
      /// HFHadronEnergyFraction (relative to corrected jet energy)
      float HFHadronEnergyFraction() const {
        return HFHadronEnergy() / ((jecSetsAvailable() ? jecFactor(0) : 1.) * energy());
      }
      /// HFEMEnergy
      float HFEMEnergy() const { return pfSpecific().mHFEMEnergy; }
      /// HFEMEnergyFraction (relative to corrected jet energy)
      float HFEMEnergyFraction() const { return HFEMEnergy() / ((jecSetsAvailable() ? jecFactor(0) : 1.) * energy()); }

      /// chargedHadronMultiplicity
      int chargedHadronMultiplicity() const { return pfSpecific().mChargedHadronMultiplicity; }
      /// neutralHadronMultiplicity
      int neutralHadronMultiplicity() const { return pfSpecific().mNeutralHadronMultiplicity; }
      /// photonMultiplicity
      int photonMultiplicity() const { return pfSpecific().mPhotonMultiplicity; }
      /// electronMultiplicity
      int electronMultiplicity() const { return pfSpecific().mElectronMultiplicity; }

      /// HFHadronMultiplicity
      int HFHadronMultiplicity() const { return pfSpecific().mHFHadronMultiplicity; }
      /// HFEMMultiplicity
      int HFEMMultiplicity() const { return pfSpecific().mHFEMMultiplicity; }

      /// chargedMuEnergy
      float chargedMuEnergy() const { return pfSpecific().mChargedMuEnergy; }
      /// chargedMuEnergyFraction
      float chargedMuEnergyFraction() const {
        return chargedMuEnergy() / ((jecSetsAvailable() ? jecFactor(0) : 1.) * energy());
      }

      /// neutralMultiplicity
      int neutralMultiplicity() const { return pfSpecific().mNeutralMultiplicity; }

      /// hoEnergy
      float hoEnergy() const { return pfSpecific().mHOEnergy; }
      /// hoEnergyFraction (relative to corrected jet energy)
      float hoEnergyFraction() const { return hoEnergy() / ((jecSetsAvailable() ? jecFactor(0) : 1.) * energy()); }
      /// convert generic constituent to specific type

      //  static CaloTowerPtr caloTower (const reco::Candidate* fConstituent);
      /// get specific constituent of the CaloJet.
      /// if the caloTowers were embedded, this reference is transient only and must not be persisted
      reco::PFCandidatePtr getPFConstituent(unsigned fIndex) const;
      /// get the constituents of the CaloJet.
      /// If the caloTowers were embedded, these reference are transient only and must not be persisted
      std::vector<reco::PFCandidatePtr> const& getPFConstituents() const;

      /// get a pointer to a Candididate constituent of the jet
      ///    If using refactorized PAT, return that. (constituents size > 0)
      ///    Else check the old version of PAT (embedded constituents size > 0)
      ///    Else return the reco Jet number of constituents
      const reco::Candidate* daughter(size_t i) const override;

      reco::CandidatePtr daughterPtr(size_t i) const override;
      const reco::CompositePtrCandidate::daughters& daughterPtrVector() const override;

      using reco::LeafCandidate::daughter;  // avoid hiding the base implementation

      /// Return number of daughters:
      ///    If using refactorized PAT, return that. (constituents size > 0)
      ///    Else check the old version of PAT (embedded constituents size > 0)
      ///    Else return the reco Jet number of constituents
      size_t numberOfDaughters() const override;

      /// clear daughter references
      void clearDaughters() override {
        PATObject<reco::Jet>::clearDaughters();
        daughtersTemp_.reset();  // need to reset daughtersTemp_ as well
      }

      /// accessing Jet ID information
      reco::JetID const& jetID() const { return jetID_; }

      /// Access to bare FwdPtr collections
      CaloTowerFwdPtrVector const& caloTowersFwdPtr() const { return caloTowersFwdPtr_; }
      reco::PFCandidateFwdPtrVector const& pfCandidatesFwdPtr() const { return pfCandidatesFwdPtr_; }
      edm::FwdRef<reco::GenJetCollection> const& genJetFwdRef() const { return genJetFwdRef_; }
      TagInfoFwdPtrCollection const& tagInfosFwdPtr() const { return tagInfosFwdPtr_; }

      /// Update bare FwdPtr and FwdRef "forward" pointers while keeping the
      /// "back" pointers the same (i.e. the ref "forwarding")
      void updateFwdCaloTowerFwdPtr(unsigned int index, const edm::Ptr<CaloTower>& updateFwd) {
        if (index < caloTowersFwdPtr_.size()) {
          caloTowersFwdPtr_[index] = CaloTowerFwdPtrVector::value_type(updateFwd, caloTowersFwdPtr_[index].backPtr());
        } else {
          throw cms::Exception("OutOfRange") << "Index " << index << " is out of range" << std::endl;
        }
      }

      void updateFwdPFCandidateFwdPtr(unsigned int index, const edm::Ptr<reco::PFCandidate>& updateFwd) {
        if (index < pfCandidatesFwdPtr_.size()) {
          pfCandidatesFwdPtr_[index] =
              reco::PFCandidateFwdPtrVector::value_type(updateFwd, pfCandidatesFwdPtr_[index].backPtr());
        } else {
          throw cms::Exception("OutOfRange") << "Index " << index << " is out of range" << std::endl;
        }
      }

      void updateFwdTagInfoFwdPtr(unsigned int index, const edm::Ptr<reco::BaseTagInfo>& updateFwd) {
        if (index < tagInfosFwdPtr_.size()) {
          tagInfosFwdPtr_[index] = TagInfoFwdPtrCollection::value_type(updateFwd, tagInfosFwdPtr_[index].backPtr());
        } else {
          throw cms::Exception("OutOfRange") << "Index " << index << " is out of range" << std::endl;
        }
      }

      void updateFwdGenJetFwdRef(edm::Ref<reco::GenJetCollection> updateRef) {
        genJetFwdRef_ = edm::FwdRef<reco::GenJetCollection>(updateRef, genJetFwdRef_.backRef());
      }

      /// pipe operator (introduced to use pat::Jet with PFTopProjectors)
      friend std::ostream& reco::operator<<(std::ostream& out, const pat::Jet& obj);

      /// Access to subjet list
      pat::JetPtrCollection const& subjets(unsigned int index = 0) const;

      /// String access to subjet list
      pat::JetPtrCollection const& subjets(std::string const& label) const;

      /// Add new set of subjets
      void addSubjets(pat::JetPtrCollection const& pieces, std::string const& label = "");

      /// Check to see if the subjet collection exists
      bool hasSubjets(std::string const& label) const {
        return find(subjetLabels_.begin(), subjetLabels_.end(), label) != subjetLabels_.end();
      }

      /// Number of subjet collections
      unsigned int nSubjetCollections() const { return subjetCollections_.size(); }

      /// Subjet collection names
      std::vector<std::string> const& subjetCollectionNames() const { return subjetLabels_; }

      /// Access to mass of subjets
      double groomedMass(unsigned int index = 0) const {
        auto const& sub = subjets(index);
        return nSubjetCollections() > index && !sub.empty()
                   ? std::accumulate(sub.begin(),
                                     sub.end(),
                                     reco::Candidate::LorentzVector(),
                                     [](reco::Candidate::LorentzVector const& a, reco::CandidatePtr const& b) {
                                       return a + b->p4();
                                     })
                         .mass()
                   : -1.0;
      }
      double groomedMass(std::string const& label) const {
        auto const& sub = subjets(label);
        return hasSubjets(label) && !sub.empty()
                   ? std::accumulate(sub.begin(),
                                     sub.end(),
                                     reco::Candidate::LorentzVector(),
                                     [](reco::Candidate::LorentzVector const& a, reco::CandidatePtr const& b) {
                                       return a + b->p4();
                                     })
                         .mass()
                   : -1.0;
      }

    protected:
      // ---- for content embedding ----

      bool embeddedCaloTowers_;
      edm::AtomicPtrCache<std::vector<CaloTowerPtr> > caloTowersTemp_;  // to simplify user interface
      CaloTowerCollection caloTowers_;                                  // Compatibility embedding
      CaloTowerFwdPtrVector caloTowersFwdPtr_;                          // Refactorized content embedding

      bool embeddedPFCandidates_;
      edm::AtomicPtrCache<std::vector<reco::PFCandidatePtr> > pfCandidatesTemp_;  // to simplify user interface
      reco::PFCandidateCollection pfCandidates_;                                  // Compatibility embedding
      reco::PFCandidateFwdPtrVector pfCandidatesFwdPtr_;                          // Refactorized content embedding

      // ---- Jet Substructure ----
      std::vector<pat::JetPtrCollection> subjetCollections_;
      std::vector<std::string> subjetLabels_;
      edm::AtomicPtrCache<std::vector<reco::CandidatePtr> > daughtersTemp_;

      // ---- MC info ----

      std::vector<reco::GenJet> genJet_;
      reco::GenJetRefVector genJetRef_;
      edm::FwdRef<reco::GenJetCollection> genJetFwdRef_;
      reco::JetFlavourInfo jetFlavourInfo_;

      // ---- energy scale correction factors ----

      // energy scale correction factors; the string carries a potential label if
      // more then one set of correction factors is embedded. The label corresponds
      // to the label of the jetCorrFactors module that has been embedded.
      std::vector<pat::JetCorrFactors> jec_;
      // currently applied set of jet energy correction factors (i.e. the index in
      // jetEnergyCorrections_)
      unsigned int currentJECSet_;
      // currently applied jet energy correction level
      unsigned int currentJECLevel_;
      // currently applied jet energy correction flavor (can be NONE, GLUON, UDS,
      // CHARM or BOTTOM)
      JetCorrFactors::Flavor currentJECFlavor_;

      // ---- b-tag related members ----

      std::vector<std::pair<std::string, float> > pairDiscriVector_;
      std::vector<std::string> tagInfoLabels_;
      edm::OwnVector<reco::BaseTagInfo> tagInfos_;  // Compatibility embedding
      TagInfoFwdPtrCollection tagInfosFwdPtr_;      // Refactorized embedding

      // ---- track related members ----

      float jetCharge_;
      reco::TrackRefVector associatedTracks_;

      // ---- specific members ----

      std::vector<CaloSpecific> specificCalo_;
      std::vector<JPTSpecific> specificJPT_;
      std::vector<PFSpecific> specificPF_;

      // ---- id functions ----
      reco::JetID jetID_;

    private:
      // ---- helper functions ----

      void tryImportSpecific(const reco::Jet& source);

      template <typename T>
      const T* tagInfoByType() const {
        // First check the factorized PAT version
        for (size_t i = 0, n = tagInfosFwdPtr_.size(); i < n; ++i) {
          TagInfoFwdPtrCollection::value_type const& val = tagInfosFwdPtr_[i];
          reco::BaseTagInfo const* baseTagInfo = val.get();
          if (typeid(*baseTagInfo) == typeid(T)) {
            return static_cast<const T*>(baseTagInfo);
          }
        }
        // Then check compatibility version
        for (size_t i = 0, n = tagInfos_.size(); i < n; ++i) {
          edm::OwnVector<reco::BaseTagInfo>::value_type const& val = tagInfos_[i];
          reco::BaseTagInfo const* baseTagInfo = &val;
          if (typeid(*baseTagInfo) == typeid(T)) {
            return static_cast<const T*>(baseTagInfo);
          }
        }
        return nullptr;
      }

      template <typename T>
      const T* tagInfoByTypeOrLabel(const std::string& label = "") const {
        return (label.empty() ? tagInfoByType<T>() : dynamic_cast<const T*>(tagInfo(label)));
      }

      /// return the jet correction factors of a different set, for systematic studies
      const JetCorrFactors* corrFactors_(const std::string& set) const;
      /// return the correction factor for this jet. Throws if they're not available.
      const JetCorrFactors* corrFactors_() const;

      /// cache calo towers
      void cacheCaloTowers() const;
      void cachePFCandidates() const;
      void cacheDaughters() const;
    };
  }  // namespace io_v1
}  // namespace pat

inline float pat::io_v1::Jet::chargedHadronEnergy() const {
  if (isPFJet()) {
    return pfSpecific().mChargedHadronEnergy;
  } else if (isJPTJet()) {
    return jptSpecific().mChargedHadronEnergy;
  } else {
    throw cms::Exception("Type Mismatch") << "This PAT jet was not made from a JPTJet nor from PFJet.\n";
  }
}

inline float pat::io_v1::Jet::neutralHadronEnergy() const {
  if (isPFJet()) {
    return pfSpecific().mNeutralHadronEnergy;
  } else {
    throw cms::Exception("Type Mismatch") << "This PAT jet was not made from a JPTJet nor from PFJet.\n";
  }
}

inline float pat::io_v1::Jet::chargedEmEnergy() const {
  if (isPFJet()) {
    return pfSpecific().mChargedEmEnergy;
  } else if (isJPTJet()) {
    return jptSpecific().mChargedEmEnergy;
  } else {
    throw cms::Exception("Type Mismatch") << "This PAT jet was not made from a JPTJet nor from PFJet.\n";
  }
}

inline float pat::io_v1::Jet::neutralEmEnergy() const {
  if (isPFJet()) {
    return pfSpecific().mNeutralEmEnergy;
  } else {
    throw cms::Exception("Type Mismatch") << "This PAT jet was not made from a JPTJet nor from PFJet.\n";
  }
}

inline int pat::io_v1::Jet::muonMultiplicity() const {
  if (isPFJet()) {
    return pfSpecific().mMuonMultiplicity;
  } else if (isJPTJet()) {
    return jptSpecific().muonsInVertexInCalo.size() + jptSpecific().muonsInVertexOutCalo.size();
  } else {
    throw cms::Exception("Type Mismatch") << "This PAT jet was not made from a JPTJet nor from PFJet.\n";
  }
}

inline int pat::io_v1::Jet::chargedMultiplicity() const {
  if (isPFJet()) {
    return pfSpecific().mChargedMultiplicity;
  } else if (isJPTJet()) {
    return jptSpecific().muonsInVertexInCalo.size() + jptSpecific().muonsInVertexOutCalo.size() +
           jptSpecific().pionsInVertexInCalo.size() + jptSpecific().pionsInVertexOutCalo.size() +
           jptSpecific().elecsInVertexInCalo.size() + jptSpecific().elecsInVertexOutCalo.size();
  } else {
    throw cms::Exception("Type Mismatch") << "This PAT jet was not made from a JPTJet nor from PFJet.\n";
  }
}

#endif