PFCandidate.h

Go to the documentation of this file.

#ifndef ParticleFlowCandidate_PFCandidate_h
#define ParticleFlowCandidate_PFCandidate_h
 
#if !defined(__CINT__) && !defined(__MAKECINT__) && !defined(__REFLEX__)
#include <atomic>
#endif
#include <iosfwd>
#include <array>
 
#include "DataFormats/Math/interface/Point3D.h"
 
#include "DataFormats/Candidate/interface/CompositeCandidate.h"
#include "DataFormats/ParticleFlowReco/interface/PFBlockFwd.h"
#include "DataFormats/TrackReco/interface/TrackFwd.h"
#include "DataFormats/GsfTrackReco/interface/GsfTrack.h"
#include "DataFormats/GsfTrackReco/interface/GsfTrackFwd.h"
#include "DataFormats/MuonReco/interface/Muon.h"
#include "DataFormats/MuonReco/interface/MuonFwd.h"
#include "DataFormats/ParticleFlowCandidate/interface/PFCandidateFwd.h"
#include "DataFormats/ParticleFlowCandidate/interface/PFCandidateElectronExtraFwd.h"
#include "DataFormats/EgammaCandidates/interface/GsfElectronFwd.h"
#include "DataFormats/ParticleFlowReco/interface/PFDisplacedVertexFwd.h"
#include "DataFormats/EgammaCandidates/interface/ConversionFwd.h"
#include "DataFormats/Candidate/interface/VertexCompositeCandidate.h"
#include "DataFormats/ParticleFlowCandidate/interface/PFCandidatePhotonExtraFwd.h"
#include "DataFormats/ParticleFlowCandidate/interface/PFCandidateEGammaExtraFwd.h"
#include "DataFormats/EgammaCandidates/interface/PhotonFwd.h"
namespace reco {
  class PFCandidate : public CompositeCandidate {
  public:
    enum ParticleType {
      X = 0,     // undefined
      h,         // charged hadron
      e,         // electron
      mu,        // muon
      gamma,     // photon
      h0,        // neutral hadron
      h_HF,      // HF tower identified as a hadron
      egamma_HF  // HF tower identified as an EM particle
    };
 
    enum Flags {
      NORMAL = 0,
      E_PHI_SMODULES,
      E_ETA_0,
      E_ETA_MODULES,
      E_BARREL_ENDCAP,
      E_PRESHOWER_EDGE,
      E_PRESHOWER,
      E_ENDCAP_EDGE,
      H_ETA_0,
      H_BARREL_ENDCAP,
      H_ENDCAP_VFCAL,
      H_VFCAL_EDGE,
      T_TO_DISP,
      T_FROM_DISP,
      T_FROM_V0,
      T_FROM_GAMMACONV,
      GAMMA_TO_GAMMACONV
    };
 
    enum PFVertexType {
      kCandVertex = 0,
      kTrkVertex = 1,
      kComMuonVertex = 2,
      kSAMuonVertex = 3,
      kTrkMuonVertex = 4,
      kGSFVertex = 5,
      kTPFMSMuonVertex = 6,
      kPickyMuonVertex = 7,
      kDYTMuonVertex = 8
    };
 
    PFCandidate();
 
    PFCandidate(const PFCandidatePtr& sourcePtr);
 
    /*     PFCandidate( Charge q,  */
    /*                  const LorentzVector & p4,  */
    /*                  ParticleType particleId,  */
    /*                  reco::PFBlockRef blockRef ); */
    PFCandidate(Charge q, const LorentzVector& p4, ParticleType particleId);
 
    PFCandidate(const PFCandidate&);
 
    ~PFCandidate() override;
 
    PFCandidate& operator=(PFCandidate const&);
 
    PFCandidate* clone() const override;
 
    /*    /// set source ref */
    /*     void setSourceRef(const PFCandidateRef& ref) { sourceRef_ = ref; } */
 
    /*     size_type numberOfSourceCandidateRefs() const {return 1;} */
 
    /*     CandidateBaseRef sourceCandidateRef( size_type i ) const { */
    /*       return  CandidateBaseRef(sourceRef_); */
    /*     } */
 
    using reco::Candidate::setSourceCandidatePtr;
    void setSourceCandidatePtr(const PFCandidatePtr& ptr) { sourcePtr_ = ptr; }
 
    size_t numberOfSourceCandidatePtrs() const override { return 1; }
 
    CandidatePtr sourceCandidatePtr(size_type i) const override { return sourcePtr_; }
 
    int translateTypeToPdgId(ParticleType type) const;
    ParticleType translatePdgIdToType(int pdgid) const;
 
    void setParticleType(ParticleType type);
 
    /*     void addElement( const reco::PFBlockElement* element ); */
 
    void addElementInBlock(const reco::PFBlockRef& blockref, unsigned elementIndex);
 
    void setTrackRef(const reco::TrackRef& ref);
 
    reco::TrackRef trackRef() const;
 
    const reco::Track* bestTrack() const override {
      if ((abs(pdgId()) == 11 || pdgId() == 22) && gsfTrackRef().isNonnull() && gsfTrackRef().isAvailable())
        return &(*gsfTrackRef());
      else if (trackRef().isNonnull() && trackRef().isAvailable())
        return &(*trackRef());
      else
        return nullptr;
    }
    float dzError() const override {
      const Track* tr = bestTrack();
      if (tr != nullptr)
        return tr->dzError();
      else
        return 0;
    }
    float dxyError() const override {
      const Track* tr = bestTrack();
      if (tr != nullptr)
        return tr->dxyError();
      else
        return 0;
    }
 
    void setGsfTrackRef(const reco::GsfTrackRef& ref);
 
    reco::GsfTrackRef gsfTrackRef() const;
 
    void setMuonRef(const reco::MuonRef& ref);
 
    reco::MuonRef muonRef() const;
 
    void setDisplacedVertexRef(const reco::PFDisplacedVertexRef& ref, Flags flag);
 
    reco::PFDisplacedVertexRef displacedVertexRef(Flags type) const;
 
    void setConversionRef(const reco::ConversionRef& ref);
 
    reco::ConversionRef conversionRef() const;
 
    void setV0Ref(const reco::VertexCompositeCandidateRef& ref);
 
    reco::VertexCompositeCandidateRef v0Ref() const;
 
    reco::GsfElectronRef gsfElectronRef() const;
 
    reco::PFCandidateElectronExtraRef electronExtraRef() const;
 
    void setEcalEnergy(float eeRaw, float eeCorr) {
      rawEcalEnergy_ = eeRaw;
      ecalERatio_ = std::abs(eeRaw) < 1.e-6 ? 1.0 : eeCorr / eeRaw;
    }
 
    double ecalEnergy() const { return ecalERatio_ * rawEcalEnergy_; }
 
    double rawEcalEnergy() const { return rawEcalEnergy_; }
 
    void setHcalEnergy(float ehRaw, float ehCorr) {
      rawHcalEnergy_ = ehRaw;
      hcalERatio_ = std::abs(ehRaw) < 1.e-6 ? 1.0 : ehCorr / ehRaw;
    }
 
    double hcalEnergy() const { return hcalERatio_ * rawHcalEnergy_; }
 
    double rawHcalEnergy() const { return rawHcalEnergy_; }
 
    void setHoEnergy(float eoRaw, float eoCorr) {
      rawHoEnergy_ = eoRaw;
      hoERatio_ = std::abs(eoRaw) < 1.e-6 ? 1.0 : eoCorr / eoRaw;
    }
 
    double hoEnergy() const { return hoERatio_ * rawHoEnergy_; }
 
    double rawHoEnergy() const { return rawHoEnergy_; }
 
    void setGsfElectronRef(const reco::GsfElectronRef& ref);
 
    void setSuperClusterRef(const reco::SuperClusterRef& scRef);
 
    reco::SuperClusterRef superClusterRef() const;
 
    void setPhotonRef(const reco::PhotonRef& phRef);
 
    reco::PhotonRef photonRef() const;
 
    void setPFPhotonExtraRef(const reco::PFCandidatePhotonExtraRef& ref);
 
    reco::PFCandidatePhotonExtraRef photonExtraRef() const;
 
    void setPFEGammaExtraRef(const reco::PFCandidateEGammaExtraRef& ref);
 
    reco::PFCandidateEGammaExtraRef egammaExtraRef() const;
 
    void setPs1Energy(float e1) { ps1Energy_ = e1; }
 
    double pS1Energy() const { return ps1Energy_; }
 
    void setPs2Energy(float e2) { ps2Energy_ = e2; }
 
    double pS2Energy() const { return ps2Energy_; }
 
    void rescaleMomentum(double rescaleFactor);
 
    void setFlag(Flags theFlag, bool value);
 
    bool flag(Flags theFlag) const;
 
    void setDeltaP(double dp) { deltaP_ = dp; }
 
    double deltaP() const { return deltaP_; }
 
    //  int pdgId() const { return translateTypeToPdgId( particleId_ ); }
 
 
    void set_mva_Isolated(float mvaI) { mva_Isolated_ = mvaI; }
    // mva for isolated electrons
    float mva_Isolated() const { return mva_Isolated_; }
 
    void set_mva_e_pi(float mvaNI) { mva_e_pi_ = mvaNI; }
    float mva_e_pi() const { return mva_e_pi_; }
 
    void set_mva_e_mu(float mva) { mva_e_mu_ = mva; }
 
    float mva_e_mu() const { return mva_e_mu_; }
 
    void set_mva_pi_mu(float mva) { mva_pi_mu_ = mva; }
 
    float mva_pi_mu() const { return mva_pi_mu_; }
 
    void set_mva_nothing_gamma(float mva) { mva_nothing_gamma_ = mva; }
 
    float mva_nothing_gamma() const { return mva_nothing_gamma_; }
 
    void set_mva_nothing_nh(float mva) { mva_nothing_nh_ = mva; }
 
    float mva_nothing_nh() const { return mva_nothing_nh_; }
 
    void set_mva_gamma_nh(float mva) { mva_gamma_nh_ = mva; }
 
    float mva_gamma_nh() const { return mva_gamma_nh_; }
 
    void setPositionAtECALEntrance(const math::XYZPointF& pos) { positionAtECALEntrance_ = pos; }
 
    void setPFElectronExtraRef(const reco::PFCandidateElectronExtraRef& ref);
 
    void setMuonTrackType(const reco::Muon::MuonTrackType& type) { muonTrackType_ = type; }
 
 
    const reco::Muon::MuonTrackType bestMuonTrackType() const { return muonTrackType_; }
 
    const math::XYZPointF& positionAtECALEntrance() const { return positionAtECALEntrance_; }
 
    virtual ParticleType particleId() const { return translatePdgIdToType(pdgId()); }
 
    /*     const std::vector<unsigned>& elementIndices() const {  */
    /*       return elementIndices_; */
    /*     } */
    /*     const edm::OwnVector< reco::PFBlockElement >& elements() const  */
    /*       {return elements_;} */
 
    typedef std::pair<reco::PFBlockRef, unsigned> ElementInBlock;
    typedef std::vector<ElementInBlock> ElementsInBlocks;
 
    typedef edm::RefVector<reco::PFBlockCollection> Blocks;
    typedef std::vector<unsigned> Elements;
 
    const ElementsInBlocks& elementsInBlocks() const;
 
    static const float bigMva_;
 
    friend std::ostream& operator<<(std::ostream& out, const PFCandidate& c);
 
    //Tips on setting the vertex efficiently
    //There are two choices: a) use the vertex_ data member, or b) point to the vertex
    //of one of the refs stored by this class. The PFVertexType enum gives the current list
    //of possible references. For these references, use the setVeretxSource method and NOT
    //the setVertex method. If none of the available refs have the vertex that you want for this
    //PFCandidate, use the setVertex method. If you find that you are using frequently two store a
    // vertex that is the same as one of the refs in this class, you should just extend the enum
    // and modify the vertex() method accordingly.
    void setVertexSource(PFVertexType vt) {
      vertexType_ = vt;
      if (vertexType_ != kCandVertex)
        LeafCandidate::setVertex(Point(0., 0., 0.));
    }
 
    void setVertex(const math::XYZPoint& p) override {
      LeafCandidate::setVertex(p);
      vertexType_ = kCandVertex;
    }
 
    const Point& vertex() const override;
    double vx() const override { return vertex().x(); }
    double vy() const override { return vertex().y(); }
    double vz() const override { return vertex().z(); }
 
    bool isTimeValid() const { return timeError_ >= 0.f; }
    float time() const { return time_; }
    float timeError() const { return timeError_; }
    void setTime(float time, float timeError = 0.f) {
      time_ = time;
      timeError_ = timeError;
    }
 
    float hcalDepthEnergyFraction(unsigned int depth) const { return hcalDepthEnergyFractions_[depth - 1]; }
    const std::array<float, 7>& hcalDepthEnergyFractions() const { return hcalDepthEnergyFractions_; }
    void setHcalDepthEnergyFractions(const std::array<float, 7>& fracs) { hcalDepthEnergyFractions_ = fracs; }
 
  private:
    bool overlap(const Candidate&) const override;
 
    void setFlag(unsigned shift, unsigned flag, bool value);
 
    bool flag(unsigned shift, unsigned flag) const;
 
#if !defined(__CINT__) && !defined(__MAKECINT__) && !defined(__REFLEX__)
    mutable std::atomic<ElementsInBlocks*> elementsInBlocks_;
#else
    mutable ElementsInBlocks* elementsInBlocks_;
#endif
    Blocks blocksStorage_;
    Elements elementsStorage_;
 
    /*     PFCandidateRef sourceRef_; */
    PFCandidatePtr sourcePtr_;
 
    reco::Muon::MuonTrackType muonTrackType_;
 
    float ecalERatio_;
 
    float hcalERatio_;
 
    float hoERatio_;
 
    float rawEcalEnergy_;
 
    float rawHcalEnergy_;
 
    float rawHoEnergy_;
 
    float ps1Energy_;
 
    float ps2Energy_;
 
    unsigned flags_;
 
    float deltaP_;
 
    PFVertexType vertexType_;
 
    // mva for isolated electrons
    float mva_Isolated_;
 
    float mva_e_pi_;
 
    float mva_e_mu_;
 
    float mva_pi_mu_;
 
    float mva_nothing_gamma_;
 
    float mva_nothing_nh_;
 
    float mva_gamma_nh_;
 
    math::XYZPointF positionAtECALEntrance_;
 
    //more efficiently stored refs
    void storeRefInfo(unsigned int iMask,
                      unsigned int iBit,
                      bool iIsValid,
                      const edm::RefCore& iCore,
                      size_t iKey,
                      const edm::EDProductGetter*);
    bool getRefInfo(
        unsigned int iMask, unsigned int iBit, edm::ProductID& oProdID, size_t& oIndex, size_t& aIndex) const;
 
    const edm::EDProductGetter* getter_;  //transient
    unsigned short storedRefsBitPattern_;
    std::vector<unsigned long long> refsInfo_;
    std::vector<const void*> refsCollectionCache_;
 
    float time_;
    float timeError_;
 
    std::array<float, 7> hcalDepthEnergyFractions_;
  };
 
  struct PFParticleIdTag {};
 
  /*   GET_DEFAULT_CANDIDATE_COMPONENT( PFCandidate, PFBlockRef, block ); */
 
  GET_CANDIDATE_COMPONENT(PFCandidate, PFCandidate::ParticleType, particleId, PFParticleIdTag);
 
  std::ostream& operator<<(std::ostream& out, const PFCandidate& c);
 
}  // namespace reco
 
#endif