/data/refman/pasoursint/CMSSW_5_2_9/src/DataFormats/EgammaCandidates/interface/Photon.h

Go to the documentation of this file.

#ifndef EgammaCandidates_Photon_h
#define EgammaCandidates_Photon_h

#include "DataFormats/RecoCandidate/interface/RecoCandidate.h"
#include "DataFormats/EgammaCandidates/interface/Conversion.h"
#include "DataFormats/EgammaCandidates/interface/ConversionFwd.h"
#include "DataFormats/EgammaCandidates/interface/PhotonCore.h"
#include "DataFormats/EgammaReco/interface/ElectronSeed.h"
#include "DataFormats/EgammaReco/interface/SuperCluster.h"
#include "DataFormats/ParticleFlowCandidate/interface/PFCandidateFwd.h"


namespace reco {

  class Photon : public RecoCandidate {
  public:
    struct  FiducialFlags;
    struct  IsolationVariables;
    struct  ShowerShape;
    struct  MIPVariables;  
    
    Photon() : RecoCandidate() { pixelSeed_=false; }

    Photon ( const Photon&); 

    Photon( const LorentzVector & p4, 
            Point caloPos, 
            const PhotonCoreRef & core,  
            const Point & vtx = Point( 0, 0, 0 ) );

    virtual ~Photon();

    virtual Photon * clone() const;

    reco::PhotonCoreRef photonCore() const { return photonCore_;}
    //
    //
    // retrieve provenance
    bool isPFlowPhoton() const {return this->photonCore()->isPFlowPhoton();}
    bool isStandardPhoton() const {return this->photonCore()->isStandardPhoton();}
    reco::SuperClusterRef superCluster() const;
    reco::SuperClusterRef pfSuperCluster() const {return this->photonCore()->pfSuperCluster();}
    reco::ConversionRefVector conversions() const {return this->photonCore()->conversions() ;}  
    enum ConversionProvenance {egamma=0, 
                               pflow=1, 
                               both=2};

    reco::ConversionRefVector conversionsOneLeg() const {return this->photonCore()->conversionsOneLeg() ;} 
    bool hasConversionTracks() const { if (this->photonCore()->conversions().size() > 0 || this->photonCore()->conversionsOneLeg().size() > 0)  return true; else return false;}
    reco::ElectronSeedRefVector electronPixelSeeds() const {return this->photonCore()->electronPixelSeeds();}
    bool hasPixelSeed() const { if ((this->photonCore()->electronPixelSeeds()).size() > 0 ) return true; else return false; }
    int conversionTrackProvenance(const edm::RefToBase<reco::Track>& convTrack) const;

 
    math::XYZPointF caloPosition() const {return caloPosition_;}
    void setVertex(const Point & vertex);
    bool isPhoton() const { return true ; }

    //=======================================================
    // Fiducial Flags
    //=======================================================
    struct  FiducialFlags
    {
      
      //Fiducial flags
      bool isEB;//Photon is in EB
      bool isEE;//Photon is in EE
      bool isEBEtaGap;//Photon is in supermodule/supercrystal eta gap in EB
      bool isEBPhiGap;//Photon is in supermodule/supercrystal phi gap in EB
      bool isEERingGap;//Photon is in crystal ring gap in EE
      bool isEEDeeGap;//Photon is in crystal dee gap in EE
      bool isEBEEGap;//Photon is in border between EB and EE.
      
      FiducialFlags():
        isEB(false),
           isEE(false),
           isEBEtaGap(false),
           isEBPhiGap(false),
           isEERingGap(false),
           isEEDeeGap(false),
           isEBEEGap(false)
           
      {}
      
      
    };

    void setFiducialVolumeFlags  ( const FiducialFlags&  a )  { fiducialFlagBlock_= a ;}
    bool isEB() const{return  fiducialFlagBlock_.isEB;}
    // true if photon is in ECAL endcap
    bool isEE() const{return fiducialFlagBlock_.isEE;}
    bool isEBGap() const { return (isEBEtaGap() || isEBPhiGap()); }
    bool isEBEtaGap() const{return fiducialFlagBlock_.isEBEtaGap;}
    bool isEBPhiGap() const{return fiducialFlagBlock_.isEBPhiGap;}
    bool isEEGap() const { return (isEERingGap() || isEEDeeGap()); }
    bool isEERingGap() const{return fiducialFlagBlock_.isEERingGap;}
    bool isEEDeeGap() const{return fiducialFlagBlock_.isEEDeeGap;}
    bool isEBEEGap() const{return fiducialFlagBlock_.isEBEEGap;}

    //=======================================================
    // Shower Shape Variables
    //=======================================================

    struct ShowerShape
    {
      float sigmaEtaEta ;
      float sigmaIetaIeta ;
      float e1x5 ;
      float e2x5 ;
      float e3x3 ;
      float e5x5 ;
      float maxEnergyXtal ; 
      float hcalDepth1OverEcal ; // hcal over ecal energy using first hcal depth
      float hcalDepth2OverEcal ; // hcal over ecal energy using 2nd hcal depth
      float hcalDepth1OverEcalBc;
      float hcalDepth2OverEcalBc;
      std::vector<CaloTowerDetId> hcalTowersBehindClusters;
      ShowerShape()
        : sigmaEtaEta(std::numeric_limits<float>::infinity()),
           sigmaIetaIeta(std::numeric_limits<float>::infinity()),
           e1x5(0), 
           e2x5(0), 
           e3x3(0), 
           e5x5(0), 
           maxEnergyXtal(0),
          hcalDepth1OverEcal(0),
          hcalDepth2OverEcal(0),
          hcalDepth1OverEcalBc(0),
          hcalDepth2OverEcalBc(0)
           
      {}
    } ;
    void setShowerShapeVariables ( const ShowerShape& a )     { showerShapeBlock_ = a ;}
    float hadronicOverEm() const {return   showerShapeBlock_.hcalDepth1OverEcal + showerShapeBlock_.hcalDepth2OverEcal  ;}
    float hadronicDepth1OverEm() const {return  showerShapeBlock_.hcalDepth1OverEcal  ;}
    float hadronicDepth2OverEm() const {return  showerShapeBlock_.hcalDepth2OverEcal  ;}

    float hadTowOverEm() const {return   showerShapeBlock_.hcalDepth1OverEcalBc + showerShapeBlock_.hcalDepth2OverEcalBc  ;}
    float hadTowDepth1OverEm() const {return  showerShapeBlock_.hcalDepth1OverEcalBc  ;}
    float hadTowDepth2OverEm() const {return  showerShapeBlock_.hcalDepth2OverEcalBc  ;}
    const std::vector<CaloTowerDetId> & hcalTowersBehindClusters() const { return showerShapeBlock_.hcalTowersBehindClusters ; }

    float e1x5()            const {return showerShapeBlock_.e1x5;}
    float e2x5()            const {return showerShapeBlock_.e2x5;}
    float e3x3()            const {return showerShapeBlock_.e3x3;}
    float e5x5()            const {return showerShapeBlock_.e5x5;}
    float maxEnergyXtal()   const {return showerShapeBlock_.maxEnergyXtal;}
    float sigmaEtaEta()     const {return showerShapeBlock_.sigmaEtaEta;}
    float sigmaIetaIeta()   const {return showerShapeBlock_.sigmaIetaIeta;}
    float r1x5 ()           const {return showerShapeBlock_.e1x5/showerShapeBlock_.e5x5;}
    float r2x5 ()           const {return showerShapeBlock_.e2x5/showerShapeBlock_.e5x5;}
    float r9 ()             const {return showerShapeBlock_.e3x3/this->superCluster()->rawEnergy();}  

    //=======================================================
    // Energy Determinations
    //=======================================================
    enum P4type { undefined=-1, ecal_standard=0, ecal_photons=1, regression1=2, regression2= 3 } ;

    struct EnergyCorrections {
      float scEcalEnergy;
      float scEcalEnergyError;
      LorentzVector scEcalP4;
      float phoEcalEnergy;
      float phoEcalEnergyError;
      LorentzVector phoEcalP4;
      float regression1Energy;
      float regression1EnergyError;
      LorentzVector regression1P4;
      float regression2Energy;
      float regression2EnergyError;
      LorentzVector regression2P4;
      P4type candidateP4type;
      EnergyCorrections() : 
        scEcalEnergy(0.), 
        scEcalEnergyError(999.),
        scEcalP4(0., 0., 0., 0.),
        phoEcalEnergy(0.), 
        phoEcalEnergyError(999.),
        phoEcalP4(0., 0., 0., 0.),
        regression1Energy(0.), 
        regression1EnergyError(999.),
        regression1P4(0.,0.,0.,0.),  
        regression2Energy(0.), 
        regression2EnergyError(999.),
        regression2P4(0.,0.,0.,0.),
        candidateP4type(undefined) 
      {}
    };

    using RecoCandidate::setP4 ;
    using RecoCandidate::p4 ;

    //sets both energy and its uncertainty
    void setCorrectedEnergy( P4type type, float E, float dE, bool toCand=true );        
    void setP4( P4type type, const LorentzVector & p4, float p4Error, bool setToRecoCandidate ) ;
    void setEnergyCorrections ( const EnergyCorrections& e) { eCorrections_=e;}
    void setCandidateP4type(const  P4type type) { eCorrections_.candidateP4type = type; }

    float getCorrectedEnergy( P4type type) const;
    float getCorrectedEnergyError( P4type type) const ;
    P4type getCandidateP4type() const {return eCorrections_.candidateP4type;}
    const LorentzVector& p4( P4type type ) const ;
    const EnergyCorrections & energyCorrections() const { return eCorrections_ ; }

    //=======================================================
    // MIP Variables
    //=======================================================
    
    struct MIPVariables
    {       
      float mipChi2;
      float mipTotEnergy;
      float mipSlope;
      float mipIntercept;
      int   mipNhitCone;
      bool  mipIsHalo;
      
      MIPVariables():
        
        mipChi2(0), 
        mipTotEnergy(0), 
        mipSlope(0), 
        mipIntercept(0), 
        mipNhitCone(0),
        mipIsHalo(false)        
      {}    
      
    } ;  
    
    float mipChi2()         const {return mipVariableBlock_.mipChi2;}
    float mipTotEnergy()    const {return mipVariableBlock_.mipTotEnergy;}
    float mipSlope()        const {return mipVariableBlock_.mipSlope;}
    float mipIntercept()    const {return mipVariableBlock_.mipIntercept;}
    int mipNhitCone()     const {return mipVariableBlock_.mipNhitCone;}
    bool  mipIsHalo()       const {return mipVariableBlock_.mipIsHalo;}
            
    void setMIPVariables ( const MIPVariables& mipVar) {mipVariableBlock_= mipVar;} 
    
    

    //=======================================================
    // Isolation Variables
    //=======================================================

    struct IsolationVariables
    {
      //These are analysis quantities calculated in the PhotonIDAlgo class
      
      //EcalRecHit isolation
      float ecalRecHitSumEt;
      //HcalDepth1Tower isolation
      float hcalTowerSumEt;
      //HcalDepth1Tower isolation
      float hcalDepth1TowerSumEt;
      //HcalDepth2Tower isolation
      float hcalDepth2TowerSumEt;
      //Sum of track pT in a cone of dR
      float trkSumPtSolidCone;
      //Sum of track pT in a hollow cone of outer radius, inner radius
      float trkSumPtHollowCone;
      //Number of tracks in a cone of dR
      int nTrkSolidCone;
      //Number of tracks in a hollow cone of outer radius, inner radius
      int nTrkHollowCone;
      
      IsolationVariables():
        
        ecalRecHitSumEt(0),
           hcalTowerSumEt(0),
           hcalDepth1TowerSumEt(0),
           hcalDepth2TowerSumEt(0),
           trkSumPtSolidCone(0),
           trkSumPtHollowCone(0),
           nTrkSolidCone(0),
           nTrkHollowCone(0)
           
      {}
      
      
    };

    
    void setIsolationVariables ( const IsolationVariables& isolInDr04, const IsolationVariables& isolInDr03) {  isolationR04_ = isolInDr04 ; isolationR03_ = isolInDr03 ;} 

    float ecalRecHitSumEtConeDR04()      const{return  isolationR04_.ecalRecHitSumEt;}
    float hcalTowerSumEtConeDR04()      const{return  isolationR04_.hcalTowerSumEt ;}
    float hcalDepth1TowerSumEtConeDR04()      const{return  isolationR04_.hcalDepth1TowerSumEt;}
    float hcalDepth2TowerSumEtConeDR04()      const{return  isolationR04_.hcalDepth2TowerSumEt;}
    //  Track pT sum c
    float trkSumPtSolidConeDR04()    const{return   isolationR04_.trkSumPtSolidCone;}
    //As above, excluding the core at the center of the cone
    float trkSumPtHollowConeDR04()   const{return   isolationR04_.trkSumPtHollowCone;}
    //Returns number of tracks in a cone of dR
    int nTrkSolidConeDR04()              const{return   isolationR04_.nTrkSolidCone;}
    //As above, excluding the core at the center of the cone
    int nTrkHollowConeDR04()            const{return   isolationR04_.nTrkHollowCone;}
    //
    float ecalRecHitSumEtConeDR03()      const{return  isolationR03_.ecalRecHitSumEt;}
    float hcalTowerSumEtConeDR03()      const{return isolationR03_.hcalTowerSumEt;}
    float hcalDepth1TowerSumEtConeDR03()      const{return isolationR03_.hcalDepth1TowerSumEt;}
    float hcalDepth2TowerSumEtConeDR03()      const{return isolationR03_.hcalDepth2TowerSumEt;}
    //  Track pT sum c
    float trkSumPtSolidConeDR03()    const{return  isolationR03_.trkSumPtSolidCone;}
    //As above, excluding the core at the center of the cone
    float trkSumPtHollowConeDR03()   const{return  isolationR03_.trkSumPtHollowCone;}
    //Returns number of tracks in a cone of dR
    int nTrkSolidConeDR03()              const{return  isolationR03_.nTrkSolidCone;}
    //As above, excluding the core at the center of the cone
    int nTrkHollowConeDR03()             const{return  isolationR03_.nTrkHollowCone;}


    //=======================================================
    // PFlow based Isolation Variables
    //=======================================================

    struct PflowIsolationVariables
    {

      float chargedHadronIso;
      float neutralHadronIso;
      float photonIso ;
      float modFrixione ;      
      
      PflowIsolationVariables():
        
        chargedHadronIso(0),
        neutralHadronIso(0),
        photonIso(0),
        modFrixione(0)
                   
      {}
      
      
    };

    float chargedHadronIso() const {return  pfIsolation_.chargedHadronIso;}
    float neutralHadronIso() const {return  pfIsolation_.neutralHadronIso;}
    float photonIso() const {return  pfIsolation_.photonIso;}

    void setPflowIsolationVariables ( const PflowIsolationVariables& pfisol ) {  pfIsolation_ = pfisol;} 

    struct PflowIDVariables
    {

      int nClusterOutsideMustache;
      float etOutsideMustache;
      float mva;

      PflowIDVariables():

        nClusterOutsideMustache(-1),
        etOutsideMustache(-999999999.),
        mva(-999999999.)
                   
      {}
    };
    
    // getters
    int nClusterOutsideMustache() const {return pfID_.nClusterOutsideMustache;}
    float etOutsideMustache() const {return pfID_.etOutsideMustache;}
    float pfMVA() const {return pfID_.mva;}
    // setters
    void setPflowIDVariables ( const PflowIDVariables& pfid ) {  pfID_ = pfid;}     


  private:
    virtual bool overlap( const Candidate & ) const;
    math::XYZPointF caloPosition_;
    reco::PhotonCoreRef photonCore_;
    //
    bool pixelSeed_;
    //
    FiducialFlags fiducialFlagBlock_;
    IsolationVariables isolationR04_;
    IsolationVariables isolationR03_;
    ShowerShape        showerShapeBlock_;
    EnergyCorrections eCorrections_; 
    MIPVariables        mipVariableBlock_; 
    PflowIsolationVariables pfIsolation_;
    PflowIDVariables pfID_;


  };
  
}

#endif