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

    // set DNN for electron PFID
    // mva for ele PFID DNN sigIsolated class
    float dnn_e_sigIsolated() const { return dnn_e_sigIsolated_; }
    void set_dnn_e_sigIsolated(float mva) { dnn_e_sigIsolated_ = mva; }

    // mva for ele PFID DNN sigNonIsolated class
    float dnn_e_sigNonIsolated() const { return dnn_e_sigNonIsolated_; }
    void set_dnn_e_sigNonIsolated(float mva) { dnn_e_sigNonIsolated_ = mva; }

    // mva for ele PFID DNN bkgNonIsolated class
    float dnn_e_bkgNonIsolated() const { return dnn_e_bkgNonIsolated_; }
    void set_dnn_e_bkgNonIsolated(float mva) { dnn_e_bkgNonIsolated_ = mva; }

    // mva for ele PFID DNN bkgTau class
    float dnn_e_bkgTau() const { return dnn_e_bkgTau_; }
    void set_dnn_e_bkgTau(float mva) { dnn_e_bkgTau_ = mva; }

    // mva for ele PFID DNN bkgPhoton class
    float dnn_e_bkgPhoton() const { return dnn_e_bkgPhoton_; }
    void set_dnn_e_bkgPhoton(float mva) { dnn_e_bkgPhoton_ = mva; }

    // set DNN for gamma PFID
    float dnn_gamma() const { return dnn_gamma_; }
    void set_dnn_gamma(float mva) { dnn_gamma_ = 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 constexpr float bigMva_ = -999.;

    friend std::ostream& operator<<(std::ostream& out, const PFCandidate& c);

    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:
    //function used before PR #31456, retained for backwards compatibility with old AOD where the vertex was not embedded
    const math::XYZPoint& vertexLegacy(PFCandidate::PFVertexType vertexType) const;

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

    //legacy vertex type to read AOD created before PR #31456
    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_;

    float dnn_e_sigIsolated_;

    float dnn_e_sigNonIsolated_;

    float dnn_e_bkgNonIsolated_;

    float dnn_e_bkgTau_;

    float dnn_e_bkgPhoton_;

    // DNN for gamma PFid
    float dnn_gamma_;

    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