JPTJet.h

Go to the documentation of this file.

#ifndef JetReco_JPTJet_h
#define JetReco_JPTJet_h

#include "DataFormats/JetReco/interface/Jet.h"
#include "DataFormats/JetReco/interface/JetCollection.h"
#include "DataFormats/JetReco/interface/CaloJet.h"
#include "DataFormats/JetReco/interface/CaloJetCollection.h"
#include "DataFormats/TrackReco/interface/Track.h"
#include "DataFormats/TrackReco/interface/TrackFwd.h"
#include "DataFormats/CaloTowers/interface/CaloTowerCollection.h"
#include "DataFormats/Common/interface/Ref.h"
#include "DataFormats/Common/interface/RefVector.h"

namespace reco {
  class JPTJet : public Jet {
  public:
    struct Specific {
      Specific()
          : mZSPCor(0),
            mChargedHadronEnergy(0),
            mNeutralHadronEnergy(0),
            mChargedEmEnergy(0),
            mNeutralEmEnergy(0),
            mResponseOfChargedWithEff(0),
            mResponseOfChargedWithoutEff(0),
            mSumPtOfChargedWithEff(0),
            mSumPtOfChargedWithoutEff(0),
            mSumEnergyOfChargedWithEff(0),
            mSumEnergyOfChargedWithoutEff(0),
            R2momtr(0),
            Eta2momtr(0),
            Phi2momtr(0),
            Pout(0),
            Zch(0) {}
      float mZSPCor;
      edm::RefToBase<reco::Jet> theCaloJetRef;
      reco::TrackRefVector pionsInVertexInCalo;
      reco::TrackRefVector pionsInVertexOutCalo;
      reco::TrackRefVector pionsOutVertexInCalo;
      reco::TrackRefVector muonsInVertexInCalo;
      reco::TrackRefVector muonsInVertexOutCalo;
      reco::TrackRefVector muonsOutVertexInCalo;
      reco::TrackRefVector elecsInVertexInCalo;
      reco::TrackRefVector elecsInVertexOutCalo;
      reco::TrackRefVector elecsOutVertexInCalo;
      float mChargedHadronEnergy;
      float mNeutralHadronEnergy;
      float mChargedEmEnergy;
      float mNeutralEmEnergy;
      float mResponseOfChargedWithEff;
      float mResponseOfChargedWithoutEff;
      float mSumPtOfChargedWithEff;
      float mSumPtOfChargedWithoutEff;
      float mSumEnergyOfChargedWithEff;
      float mSumEnergyOfChargedWithoutEff;
      float R2momtr;
      float Eta2momtr;
      float Phi2momtr;
      float Pout;
      float Zch;
    };

    JPTJet() {}

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

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

    ~JPTJet() override{};

    float chargedHadronEnergy() const { return mspecific.mChargedHadronEnergy; }
    float chargedHadronEnergyFraction() const { return chargedHadronEnergy() / energy(); }
    float neutralHadronEnergy() const { return mspecific.mNeutralHadronEnergy; }
    float neutralHadronEnergyFraction() const { return neutralHadronEnergy() / energy(); }
    float chargedEmEnergy() const { return mspecific.mChargedEmEnergy; }
    float chargedEmEnergyFraction() const { return chargedEmEnergy() / energy(); }
    float neutralEmEnergy() const { return mspecific.mNeutralEmEnergy; }
    float neutralEmEnergyFraction() const { return neutralEmEnergy() / energy(); }
    int chargedMultiplicity() const {
      return mspecific.muonsInVertexInCalo.size() + mspecific.muonsInVertexOutCalo.size() +
             mspecific.pionsInVertexInCalo.size() + mspecific.pionsInVertexOutCalo.size() +
             mspecific.elecsInVertexInCalo.size() + mspecific.elecsInVertexOutCalo.size();
    }
    int muonMultiplicity() const {
      return mspecific.muonsInVertexInCalo.size() + mspecific.muonsInVertexOutCalo.size();
    }
    int elecMultiplicity() const {
      return mspecific.elecsInVertexInCalo.size() + mspecific.elecsInVertexOutCalo.size();
    }
    const reco::TrackRefVector& getPionsInVertexInCalo() const { return mspecific.pionsInVertexInCalo; }
    const reco::TrackRefVector& getPionsInVertexOutCalo() const { return mspecific.pionsInVertexOutCalo; }
    const reco::TrackRefVector& getPionsOutVertexInCalo() const { return mspecific.pionsOutVertexInCalo; }
    const reco::TrackRefVector& getMuonsInVertexInCalo() const { return mspecific.muonsInVertexInCalo; }
    const reco::TrackRefVector& getMuonsInVertexOutCalo() const { return mspecific.muonsInVertexOutCalo; }
    const reco::TrackRefVector& getMuonsOutVertexInCalo() const { return mspecific.muonsOutVertexInCalo; }
    const reco::TrackRefVector& getElecsInVertexInCalo() const { return mspecific.elecsInVertexInCalo; }
    const reco::TrackRefVector& getElecsInVertexOutCalo() const { return mspecific.elecsInVertexOutCalo; }
    const reco::TrackRefVector& getElecsOutVertexInCalo() const { return mspecific.elecsOutVertexInCalo; }

    const float& getZSPCor() const { return mspecific.mZSPCor; }

    const edm::RefToBase<reco::Jet>& getCaloJetRef() const { return mspecific.theCaloJetRef; }

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

    JPTJet* clone() const override;

    virtual void printJet() const;

    std::string print() const override;

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

    //Variables specific to to the JPTJet class

    Specific mspecific;
    //reco::CaloJetRef theCaloJetRef;
  };

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