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


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

    virtual ~PFCandidate();

    PFCandidate& operator=(PFCandidate const&);

    virtual PFCandidate * clone() const;


    /*    /// 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 { 
      return 1;
    }
    
    CandidatePtr sourceCandidatePtr( size_type i ) const {
      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;

    virtual const reco::Track * bestTrack() const {
      if ( (abs(pdgId()) == 11 || pdgId() == 22) && gsfTrackRef().isNonnull() && gsfTrackRef().isAvailable() )
        return &(*gsfTrackRef());
      else if ( trackRef().isNonnull() && trackRef().isAvailable() )
        return &(*trackRef());
      else
        return nullptr;
    }

    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) vertex_=Point(0.,0.,0.);}

    virtual void setVertex( const math::XYZPoint& p) {
      vertex_=p; vertexType_ = kCandVertex;
    }

    virtual const Point & vertex() const;
    virtual double vx() const {return vertex().x();}
    virtual double vy() const {return vertex().y();}
    virtual double vz() const {return vertex().z();}

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

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

  };

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

  
}

#endif