Jet.h

Go to the documentation of this file.

//
//

#ifndef DataFormats_PatCandidates_Jet_h
#define DataFormats_PatCandidates_Jet_h

#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 "SimDataFormats/JetMatching/interface/JetFlavourInfo.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>


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

namespace reco {
  std::ostream& operator<<(std::ostream& out, const pat::Jet& obj);
}

// Class definition
namespace pat {

   class PATJetSlimmer;

  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;


  class Jet : public PATObject<reco::Jet> {
    friend class PATJetProducer;
    friend class PATJetSlimmer;
    friend class PATJetUpdater;

    public:

      Jet();
      Jet(const reco::Jet & aJet);
      Jet(const edm::RefToBase<reco::Jet> & aJetRef);
      Jet(const edm::Ptr<reco::Jet> & aJetRef);
      Jet(const edm::RefToBase<pat::Jet> & aJetRef);
      Jet(const edm::Ptr<pat::Jet> & aJetRef);
      ~Jet() override;
      Jet * clone() const override { return new Jet(*this); }


      const reco::GenParticle * genParton() const { return genParticle(); }
      const reco::GenJet * genJet() const;
      int partonFlavour() const;
      int hadronFlavour() const;
      const reco::JetFlavourInfo & jetFlavourInfo() const;

  public:

      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)); };
      bool jecSetsAvailable() const { return !jec_.empty(); }
      bool jecSetAvailable(const std::string& set) const {return (jecSet(set)>=0); };
      bool jecSetAvailable(const unsigned int& set) const {return (set<jec_.size()); };
      std::string currentJECSet() const { return currentJECSet_<jec_.size() ? jec_.at(currentJECSet_).jecSet() : std::string("ERROR"); }
      std::string currentJECLevel() const { return currentJECSet_<jec_.size() ? jec_.at(currentJECSet_).jecLevel(currentJECLevel_) : std::string("ERROR"); };
      JetCorrFactors::Flavor currentJECFlavor() const { return currentJECFlavor_; };
      float jecFactor(const std::string& level, const std::string& flavor="none", const std::string& set="") const;
      float jecFactor(const unsigned int& level, const JetCorrFactors::Flavor& flavor=JetCorrFactors::NONE, const unsigned int& set=0) const;
      Jet correctedJet(const std::string& level, const std::string& flavor="none", const std::string& set="") const;
      Jet correctedJet(const unsigned int& level, const JetCorrFactors::Flavor& flavor=JetCorrFactors::NONE, const unsigned int& set=0) const;
      const LorentzVector correctedP4(const std::string& level, const std::string& flavor="none", const std::string& set="") const { return correctedJet(level, flavor, set).p4(); };
      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(); };
      void scaleEnergy(double fScale) override { scaleEnergy(fScale, "Unscaled"); }
      void scaleEnergy(double fScale, const std::string& level);

  private:
      int jecSet(const std::string& label) const;
      void currentJECSet(const unsigned int& set) { currentJECSet_=set; };
      void currentJECLevel(const unsigned int& level) { currentJECLevel_=level; };
      void currentJECFlavor(const JetCorrFactors::Flavor& flavor) { currentJECFlavor_=flavor; };
      void addJECFactors(const JetCorrFactors& jec) {jec_.push_back(jec); };
      void initializeJEC(unsigned int level, const JetCorrFactors::Flavor& flavor=JetCorrFactors::NONE, unsigned int set=0);

  public:

      float bDiscriminator(const std::string &theLabel) const;
      const std::vector<std::pair<std::string, float> > & getPairDiscri() const;
      std::vector<std::string> const & tagInfoLabels() const { return tagInfoLabels_; }
      bool hasTagInfo( const std::string label) const { return tagInfo(label) != nullptr; }
      const reco::BaseTagInfo            * tagInfo(const std::string &label) const;
      const reco::CandIPTagInfo          * tagInfoCandIP(const std::string &label="") const;
      const reco::TrackIPTagInfo         * tagInfoTrackIP(const std::string &label="") const;
      const reco::CandSoftLeptonTagInfo  * tagInfoCandSoftLepton(const std::string &label="") const;
      const reco::SoftLeptonTagInfo      * tagInfoSoftLepton(const std::string &label="") const;
      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;
      void addBDiscriminatorPair(const std::pair<std::string, float> & thePair);
      void  addTagInfo(const std::string &label,
               const TagInfoFwdPtrCollection::value_type &info) ;


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

      float jetCharge() const;
      const reco::TrackRefVector & associatedTracks() const;
      void setJetCharge(float jetCharge);
      void setAssociatedTracks(const reco::TrackRefVector &tracks);

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

      void setCaloTowers(const CaloTowerFwdPtrCollection & caloTowers);
      void setPFCandidates(const PFCandidateFwdPtrCollection & pfCandidates);
      void setGenParton(const reco::GenParticleRef & gp, bool embed=false) { setGenParticleRef(gp, embed); }
      void setGenJetRef(const edm::FwdRef<reco::GenJetCollection> & gj);
      void setPartonFlavour(int partonFl);
      void setHadronFlavour(int hadronFl);
      void setJetFlavourInfo(const reco::JetFlavourInfo & jetFlavourInfo);


      void setJetID( reco::JetID const & id ) { jetID_ = id; }

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

      bool isCaloJet()  const { return !specificCalo_.empty() && !isJPTJet(); }
      bool isJPTJet()   const { return !specificJPT_.empty(); }
      bool isPFJet()    const { return !specificPF_.empty(); }
      bool isBasicJet() const { return !(isCaloJet() || isPFJet() || isJPTJet()); }
      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];
      }
      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];
      }
      bool hasPFSpecific() const { return !specificPF_.empty(); }
      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];
      }
      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;
      }
      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;
      }
      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 ----

      float maxEInEmTowers() const {return caloSpecific().mMaxEInEmTowers;}
      float maxEInHadTowers() const {return caloSpecific().mMaxEInHadTowers;}
      float energyFractionHadronic () const {return caloSpecific().mEnergyFractionHadronic;}
      float emEnergyFraction() const {return caloSpecific().mEnergyFractionEm;}
      float hadEnergyInHB() const {return caloSpecific().mHadEnergyInHB;}
      float hadEnergyInHO() const {return caloSpecific().mHadEnergyInHO;}
      float hadEnergyInHE() const {return caloSpecific().mHadEnergyInHE;}
      float hadEnergyInHF() const {return caloSpecific().mHadEnergyInHF;}
      float emEnergyInEB() const {return caloSpecific().mEmEnergyInEB;}
      float emEnergyInEE() const {return caloSpecific().mEmEnergyInEE;}
      float emEnergyInHF() const {return caloSpecific().mEmEnergyInHF;}
      float towersArea() const {return caloSpecific().mTowersArea;}
      int n90() const {return nCarrying (0.9);}
      int n60() const {return nCarrying (0.6);}

      //  static CaloTowerPtr caloTower (const reco::Candidate* fConstituent);
      CaloTowerPtr getCaloConstituent (unsigned fIndex) const;
      std::vector<CaloTowerPtr> const & getCaloConstituents () const;

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

      const reco::TrackRefVector& pionsInVertexInCalo () const{return jptSpecific().pionsInVertexInCalo; }
      const reco::TrackRefVector& pionsInVertexOutCalo() const{return jptSpecific().pionsInVertexOutCalo;}
      const reco::TrackRefVector& pionsOutVertexInCalo() const{return jptSpecific().pionsOutVertexInCalo;}
      const reco::TrackRefVector& muonsInVertexInCalo () const{return jptSpecific().muonsInVertexInCalo; }
      const reco::TrackRefVector& muonsInVertexOutCalo() const{return jptSpecific().muonsInVertexOutCalo;}
      const reco::TrackRefVector& muonsOutVertexInCalo() const{return jptSpecific().muonsOutVertexInCalo;}
      const reco::TrackRefVector& elecsInVertexInCalo () const{return jptSpecific().elecsInVertexInCalo; }
      const reco::TrackRefVector& elecsInVertexOutCalo() const{return jptSpecific().elecsInVertexOutCalo;}
      const reco::TrackRefVector& elecsOutVertexInCalo() const{return jptSpecific().elecsOutVertexInCalo;}
      const float& zspCorrection() const {return jptSpecific().mZSPCor;}
      float elecMultiplicity () const {return jptSpecific().elecsInVertexInCalo.size()+jptSpecific().elecsInVertexOutCalo.size();}

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

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

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

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

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

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

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

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

      float hoEnergy () const {return pfSpecific().mHOEnergy;}
      float hoEnergyFraction () const {return hoEnergy()/((jecSetsAvailable() ? jecFactor(0) : 1.)*energy());}

      //  static CaloTowerPtr caloTower (const reco::Candidate* fConstituent);
      reco::PFCandidatePtr getPFConstituent (unsigned fIndex) const;
      std::vector<reco::PFCandidatePtr> const & getPFConstituents () const;

      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

      size_t numberOfDaughters() const override;

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

      reco::JetID const & jetID () const { return jetID_;}


      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_; }

      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() );
      }

      friend std::ostream& reco::operator<<(std::ostream& out, const pat::Jet& obj);



      pat::JetPtrCollection const & subjets( unsigned int index = 0 ) const;


      pat::JetPtrCollection const & subjets( std::string const & label ) const ;

      void addSubjets( pat::JetPtrCollection const & pieces, std::string const & label = ""  );

      bool hasSubjets( std::string const & label ) const { return find( subjetLabels_.begin(), subjetLabels_.end(), label) != subjetLabels_.end(); }

      unsigned int nSubjetCollections(  ) const { return  subjetCollections_.size(); }

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

      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)) );
      }

      const JetCorrFactors * corrFactors_(const std::string& set) const ;
      const JetCorrFactors * corrFactors_() const;

      void cacheCaloTowers() const;
      void cachePFCandidates() const;
      void cacheDaughters() const;

  };
}

inline float pat::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::Jet::neutralHadronEnergy() const
{
  if(isPFJet()){ return pfSpecific().mNeutralHadronEnergy; }
  else if( isJPTJet() ){ return jptSpecific().mNeutralHadronEnergy; }
  else{ throw cms::Exception("Type Mismatch") << "This PAT jet was not made from a JPTJet nor from PFJet.\n"; }
}

inline float pat::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::Jet::neutralEmEnergy() const
{
  if(isPFJet()){ return pfSpecific().mNeutralEmEnergy; }
  else if( isJPTJet() ){ return jptSpecific().mNeutralEmEnergy;}
  else{ throw cms::Exception("Type Mismatch") << "This PAT jet was not made from a JPTJet nor from PFJet.\n"; }
}

inline int pat::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::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