/data/refman/pasoursint/CMSSW_4_1_8_patch13/src/DataFormats/ParticleFlowCandidate/interface/PFCandidate.h

Go to the documentation of this file.

#ifndef ParticleFlowCandidate_PFCandidate_h
#define ParticleFlowCandidate_PFCandidate_h

#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/GsfTrackFwd.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/EgammaReco/interface/SuperClusterFwd.h"
#include "DataFormats/ParticleFlowReco/interface/PFDisplacedVertexFwd.h"
#include "DataFormats/EgammaCandidates/interface/ConversionFwd.h"
#include "DataFormats/Candidate/interface/VertexCompositeCandidate.h"
// to be removed
#include "DataFormats/VertexReco/interface/NuclearInteractionFwd.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
    };
    


    PFCandidate();

    PFCandidate( const PFCandidatePtr& sourcePtr );
    
    /*     PFCandidate( Charge q,  */
    /*                  const LorentzVector & p4,  */
    /*                  ParticleType particleId,  */
    /*                  reco::PFBlockRef blockRef ); */
    PFCandidate( Charge q, 
                 const LorentzVector & p4, 
                 ParticleType particleId );

    virtual ~PFCandidate() {}

    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;

    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 { return trackRef_; }

    void setGsfTrackRef(const reco::GsfTrackRef& ref);   

    reco::GsfTrackRef gsfTrackRef() const { return gsfTrackRef_; }     

    void setMuonRef(const reco::MuonRef& ref);

    reco::MuonRef muonRef() const { return muonRef_; }    

    void setDisplacedVertexRef(const reco::PFDisplacedVertexRef& ref, Flags flag);

    reco::PFDisplacedVertexRef displacedVertexRef(Flags type) const { 
      if (type == T_TO_DISP) return displacedVertexDaughterRef_; 
      else if (type == T_FROM_DISP) return displacedVertexMotherRef_; 
      return reco::PFDisplacedVertexRef();
    }

    void setConversionRef(const reco::ConversionRef& ref);

    reco::ConversionRef conversionRef() const { return conversionRef_; }

    void setV0Ref(const reco::VertexCompositeCandidateRef& ref);

    reco::VertexCompositeCandidateRef v0Ref() const { return v0Ref_; }

    reco::GsfElectronRef gsfElectronRef() const {return gsfElectronRef_;} 

    reco::SuperClusterRef superClusterRef() const {return superClusterRef_;} 

    reco::PFCandidateElectronExtraRef electronExtraRef() const {return pfElectronExtraRef_;}

    void setEcalEnergy( float ee ) {ecalEnergy_ = ee;}

    double ecalEnergy() const { return ecalEnergy_;}
    
    void setHcalEnergy( float eh ) {hcalEnergy_ = eh;}

    double hcalEnergy() const { return hcalEnergy_;}

    void setRawEcalEnergy( float ee ) {rawEcalEnergy_ = ee;}

    double rawEcalEnergy() const { return rawEcalEnergy_;}
    
    void setRawHcalEnergy( float eh ) {rawHcalEnergy_ = eh;}

    void setGsfElectronRef (const reco::GsfElectronRef & ref) {gsfElectronRef_ = ref; }

    double rawHcalEnergy() const { return rawHcalEnergy_;}

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

    void set_mva_e_pi( float mva ) { mva_e_pi_ = mva; } 
    
    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) {
      pfElectronExtraRef_=ref ;
    }

    const math::XYZPointF& positionAtECALEntrance() const {
      return positionAtECALEntrance_;
    }
    
    virtual  ParticleType particleId() const { return particleId_;}

    
    /*     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;
    const ElementsInBlocks& elementsInBlocks() const { 
      return elementsInBlocks_;
    }
    
  

    static const float bigMva_;

    friend std::ostream& operator<<( std::ostream& out, 
                                     const PFCandidate& c );
  
  private:
    virtual bool overlap( const Candidate & ) const;

    void setFlag(unsigned shift, unsigned flag, bool value);

    bool flag(unsigned shift, unsigned flag) const;
   
    ParticleType  particleId_; 
    
  
    ElementsInBlocks elementsInBlocks_;

    /*     PFCandidateRef sourceRef_; */
    PFCandidatePtr sourcePtr_;

    reco::TrackRef trackRef_;
    
    reco::GsfTrackRef gsfTrackRef_;  

    reco::MuonRef  muonRef_;

    // unused data member only here for backward compatibility
    reco::NuclearInteractionRef nuclearRef_;

    // unused data member only here for backward compatibility
    reco::ConversionRef conversionRef_;

    float       ecalEnergy_;

    float       hcalEnergy_;

    float       rawEcalEnergy_;

    float       rawHcalEnergy_;

    float       ps1Energy_;

    float       ps2Energy_;

    unsigned    flags_;

    double      deltaP_;

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


    reco::PFDisplacedVertexRef displacedVertexMotherRef_;

    reco::PFDisplacedVertexRef displacedVertexDaughterRef_;


    // Reference to a mother V0
    reco::VertexCompositeCandidateRef v0Ref_;

    // Reference to the corresponding GsfElectron if any
    reco::GsfElectronRef gsfElectronRef_;

    // Reference to the corresponding SuperCluster if any
    reco::SuperClusterRef superClusterRef_;

    // Reference to the PFCandidateElectronExtra
    reco::PFCandidateElectronExtraRef pfElectronExtraRef_;
  };

  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