PFJet.h

Go to the documentation of this file.

#ifndef JetReco_PFJet_h
#define JetReco_PFJet_h

#include "DataFormats/JetReco/interface/Jet.h"
#include "DataFormats/ParticleFlowCandidate/interface/PFCandidateFwd.h"
#include "DataFormats/TrackReco/interface/TrackFwd.h"

namespace reco {
  class PFJet : public Jet {
  public:
    typedef reco::PFCandidatePtr ConstituentTypePtr;
    typedef reco::PFCandidateFwdPtr ConstituentTypeFwdPtr;

    struct Specific {
      Specific()
          : mChargedHadronEnergy(0),
            mNeutralHadronEnergy(0),
            mPhotonEnergy(0),
            mElectronEnergy(0),
            mMuonEnergy(0),
            mHFHadronEnergy(0),
            mHFEMEnergy(0),

            mChargedHadronMultiplicity(0),
            mNeutralHadronMultiplicity(0),
            mPhotonMultiplicity(0),
            mElectronMultiplicity(0),
            mMuonMultiplicity(0),
            mHFHadronMultiplicity(0),
            mHFEMMultiplicity(0),

            mChargedEmEnergy(0),
            mChargedMuEnergy(0),
            mNeutralEmEnergy(0),

            mChargedMultiplicity(0),
            mNeutralMultiplicity(0),

            mHOEnergy(0) {}
      float mChargedHadronEnergy;
      float mNeutralHadronEnergy;
      float mPhotonEnergy;
      float mElectronEnergy;
      float mMuonEnergy;
      float mHFHadronEnergy;
      float mHFEMEnergy;

      int mChargedHadronMultiplicity;
      int mNeutralHadronMultiplicity;
      int mPhotonMultiplicity;
      int mElectronMultiplicity;
      int mMuonMultiplicity;
      int mHFHadronMultiplicity;
      int mHFEMMultiplicity;

      //old (deprecated) data members
      //kept only for backwards compatibility:
      float mChargedEmEnergy;
      float mChargedMuEnergy;
      float mNeutralEmEnergy;
      int mChargedMultiplicity;
      int mNeutralMultiplicity;

      float mHOEnergy;
    };

    PFJet() {}

    PFJet(const LorentzVector& fP4,
          const Point& fVertex,
          const Specific& fSpecific,
          const Jet::Constituents& fConstituents);

    PFJet(const LorentzVector& fP4, const Point& fVertex, const Specific& fSpecific);

    PFJet(const LorentzVector& fP4, const Specific& fSpecific, const Jet::Constituents& fConstituents);

    ~PFJet() override{};

    float chargedHadronEnergy() const { return m_specific.mChargedHadronEnergy; }
    float chargedHadronEnergyFraction() const { return chargedHadronEnergy() / energy(); }
    float neutralHadronEnergy() const { return m_specific.mNeutralHadronEnergy; }
    float neutralHadronEnergyFraction() const { return neutralHadronEnergy() / energy(); }
    float photonEnergy() const { return m_specific.mPhotonEnergy; }
    float photonEnergyFraction() const { return photonEnergy() / energy(); }
    float electronEnergy() const { return m_specific.mElectronEnergy; }
    float electronEnergyFraction() const { return electronEnergy() / energy(); }
    float muonEnergy() const { return m_specific.mMuonEnergy; }
    float muonEnergyFraction() const { return muonEnergy() / energy(); }
    float HFHadronEnergy() const { return m_specific.mHFHadronEnergy; }
    float HFHadronEnergyFraction() const { return HFHadronEnergy() / energy(); }
    float HFEMEnergy() const { return m_specific.mHFEMEnergy; }
    float HFEMEnergyFraction() const { return HFEMEnergy() / energy(); }

    int chargedHadronMultiplicity() const { return m_specific.mChargedHadronMultiplicity; }
    int neutralHadronMultiplicity() const { return m_specific.mNeutralHadronMultiplicity; }
    int photonMultiplicity() const { return m_specific.mPhotonMultiplicity; }
    int electronMultiplicity() const { return m_specific.mElectronMultiplicity; }
    int muonMultiplicity() const { return m_specific.mMuonMultiplicity; }
    int HFHadronMultiplicity() const { return m_specific.mHFHadronMultiplicity; }
    int HFEMMultiplicity() const { return m_specific.mHFEMMultiplicity; }

    float chargedEmEnergy() const { return m_specific.mChargedEmEnergy; }
    float chargedEmEnergyFraction() const { return chargedEmEnergy() / energy(); }
    float chargedMuEnergy() const { return m_specific.mChargedMuEnergy; }
    float chargedMuEnergyFraction() const { return chargedMuEnergy() / energy(); }
    float neutralEmEnergy() const { return m_specific.mNeutralEmEnergy; }
    float neutralEmEnergyFraction() const { return neutralEmEnergy() / energy(); }

    int chargedMultiplicity() const { return m_specific.mChargedMultiplicity; }
    int neutralMultiplicity() const { return m_specific.mNeutralMultiplicity; }

    float hoEnergy() const { return m_specific.mHOEnergy; }
    float hoEnergyFraction() const { return hoEnergy() / energy(); }

    virtual reco::PFCandidatePtr getPFConstituent(unsigned fIndex) const;

    virtual std::vector<reco::PFCandidatePtr> getPFConstituents() const;

    reco::TrackRefVector getTrackRefs() const;

    // block accessors

    const Specific& getSpecific() const { return m_specific; }

    PFJet* clone() const override;

    std::string print() const override;

  private:
    bool overlap(const Candidate&) const override;

    //Variables specific to to the PFJet class
    Specific m_specific;
  };

  // streamer
  std::ostream& operator<<(std::ostream& out, const reco::PFJet& jet);
}  // namespace reco
// temporary fix before include_checcker runs globally
#include "DataFormats/JetReco/interface/PFJetCollection.h"  //INCLUDECHECKER:SKIP
#endif