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"


namespace reco {

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

    Photon ( const Photon&); 

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

    ~Photon() override;

    Photon * clone() const override;

    reco::PhotonCoreRef photonCore() const { return photonCore_;}
    void setPhotonCore(const reco::PhotonCoreRef &photonCore) { photonCore_ = photonCore; }
    
    //
    //
    // retrieve provenance
    bool isPFlowPhoton() const {return this->photonCore()->isPFlowPhoton();}
    bool isStandardPhoton() const {return this->photonCore()->isStandardPhoton();}
    reco::SuperClusterRef superCluster() const override;
    reco::SuperClusterRef parentSuperCluster() const {return this->photonCore()->parentSuperCluster();}
    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().empty() || !this->photonCore()->conversionsOneLeg().empty())  return true; else return false;}
    reco::ElectronSeedRefVector electronPixelSeeds() const {return this->photonCore()->electronPixelSeeds();}
    bool hasPixelSeed() const { if (!(this->photonCore()->electronPixelSeeds()).empty() ) 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) override;
    bool isPhoton() const override { 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;
      bool  invalidHcal;
      float effSigmaRR;
      float sigmaIetaIphi;
      float sigmaIphiIphi;
      float e2nd;
      float eTop;
      float eLeft;
      float eRight;
      float eBottom;
      float e1x3;
      float e2x2;
      float e2x5Max;
      float e2x5Left;
      float e2x5Right;
      float e2x5Top;
      float e2x5Bottom;
      ShowerShape()
    : sigmaEtaEta(std::numeric_limits<float>::max()),
       sigmaIetaIeta(std::numeric_limits<float>::max()),
       e1x5(0.f), 
       e2x5(0.f), 
       e3x3(0.f), 
       e5x5(0.f), 
       maxEnergyXtal(0.f),           
      hcalDepth1OverEcal(0),
      hcalDepth2OverEcal(0),
      hcalDepth1OverEcalBc(0),
          hcalDepth2OverEcalBc(0),
          invalidHcal(false),
          effSigmaRR(std::numeric_limits<float>::max()),
          sigmaIetaIphi(std::numeric_limits<float>::max()),
          sigmaIphiIphi(std::numeric_limits<float>::max()),
          e2nd(0.f),
          eTop(0.f),
          eLeft(0.f),
          eRight(0.f),
          eBottom(0.f),
          e1x3(0.f),
          e2x2(0.f),
          e2x5Max(0.f),
          e2x5Left(0.f),
          e2x5Right(0.f),
          e2x5Top(0.f),
          e2x5Bottom(0.f)      
      {}
    } ;
    const ShowerShape& showerShapeVariables() const { return showerShapeBlock_; }
    const ShowerShape& full5x5_showerShapeVariables() const { return full5x5_showerShapeBlock_; }

    void setShowerShapeVariables ( const ShowerShape& a )     { showerShapeBlock_ = a ;}
    void full5x5_setShowerShapeVariables ( const ShowerShape& a )     { full5x5_showerShapeBlock_ = a ;}
    
    float hadronicOverEm() const {return   showerShapeBlock_.hcalDepth1OverEcal + showerShapeBlock_.hcalDepth2OverEcal  ;}
    float hadronicDepth1OverEm() const {return  showerShapeBlock_.hcalDepth1OverEcal  ;}
    float hadronicDepth2OverEm() const {return  showerShapeBlock_.hcalDepth2OverEcal  ;}
    float hadronicOverEmValid() const {return !showerShapeBlock_.invalidHcal  ;}

    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 hadTowOverEmValid() const {return !showerShapeBlock_.invalidHcal  ;}

    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();}  
    
    float full5x5_e1x5()            const {return full5x5_showerShapeBlock_.e1x5;}
    float full5x5_e2x5()            const {return full5x5_showerShapeBlock_.e2x5;}
    float full5x5_e3x3()            const {return full5x5_showerShapeBlock_.e3x3;}
    float full5x5_e5x5()            const {return full5x5_showerShapeBlock_.e5x5;}
    float full5x5_maxEnergyXtal()   const {return full5x5_showerShapeBlock_.maxEnergyXtal;}
    float full5x5_sigmaEtaEta()     const {return full5x5_showerShapeBlock_.sigmaEtaEta;}
    float full5x5_sigmaIetaIeta()   const {return full5x5_showerShapeBlock_.sigmaIetaIeta;}
    float full5x5_r1x5 ()           const {return full5x5_showerShapeBlock_.e1x5/full5x5_showerShapeBlock_.e5x5;}
    float full5x5_r2x5 ()           const {return full5x5_showerShapeBlock_.e2x5/full5x5_showerShapeBlock_.e5x5;}
    float full5x5_r9 ()             const {return full5x5_showerShapeBlock_.e3x3/this->superCluster()->rawEnergy();}      

  //=======================================================
  // SaturationInfo
  //=======================================================

    struct SaturationInfo {
      int nSaturatedXtals;
      bool isSeedSaturated;
      SaturationInfo() 
      : nSaturatedXtals(0), isSeedSaturated(false) {};
     } ;

    // accessors
    float nSaturatedXtals() const { return saturationInfo_.nSaturatedXtals; }
    float isSeedSaturated() const { return saturationInfo_.isSeedSaturated; }
    const SaturationInfo& saturationInfo() const { return saturationInfo_; }
    void setSaturationInfo(const SaturationInfo &s) { saturationInfo_ = s; }

    //=======================================================
    // 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;
      //HcalTower isolation
      float hcalTowerSumEt;
      //HcalDepth1Tower isolation
      float hcalDepth1TowerSumEt;
      //HcalDepth2Tower isolation
      float hcalDepth2TowerSumEt;
      //HcalTower isolation subtracting the hadronic energy in towers behind the BCs in the SC
      float hcalTowerSumEtBc; 
      //HcalDepth1Tower isolation subtracting the hadronic energy in towers behind the BCs in the SC
      float hcalDepth1TowerSumEtBc;
      //HcalDepth2Tower isolation subtracting the hadronic energy in towers behind the BCs in the SC
      float hcalDepth2TowerSumEtBc;
      //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),
    hcalTowerSumEtBc(0),
    hcalDepth1TowerSumEtBc(0),
    hcalDepth2TowerSumEtBc(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;}
    float hcalTowerSumEtBcConeDR04()      const{return  isolationR04_.hcalTowerSumEtBc ;}
    float hcalDepth1TowerSumEtBcConeDR04()      const{return  isolationR04_.hcalDepth1TowerSumEtBc;}
    float hcalDepth2TowerSumEtBcConeDR04()      const{return  isolationR04_.hcalDepth2TowerSumEtBc;}
    //  Track pT sum 
    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;}
    float hcalTowerSumEtBcConeDR03()      const{return  isolationR03_.hcalTowerSumEtBc ;}
    float hcalDepth1TowerSumEtBcConeDR03()      const{return  isolationR03_.hcalDepth1TowerSumEtBc;}
    float hcalDepth2TowerSumEtBcConeDR03()      const{return  isolationR03_.hcalDepth2TowerSumEtBc;}
    //  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; //  equivalent to sumChargedHadronPt in  DataFormats/MuonReco/interface/MuonPFIsolation.h
      float chargedHadronIsoWrongVtx; //  equivalent to sumChargedHadronPt in  DataFormats/MuonReco/interface/MuonPFIsolation.h
      float neutralHadronIso; //  equivalent to sumNeutralHadronPt in  DataFormats/MuonReco/interface/MuonPFIsolation.h
      float photonIso ;       //  equivalent to sumPhotonPt in  DataFormats/MuonReco/interface/MuonPFIsolation.h
      float modFrixione ;      
      float sumChargedParticlePt; 
      float sumNeutralHadronEtHighThreshold;  
      float sumPhotonEtHighThreshold;  
      float sumPUPt;  
      float sumEcalClusterEt; //sum pt of ecal clusters, vetoing clusters part of photon
      float sumHcalClusterEt; //sum pt of hcal clusters, vetoing clusters part of photon
      PflowIsolationVariables():
    
    chargedHadronIso(0),
    chargedHadronIsoWrongVtx(0),
    neutralHadronIso(0),
    photonIso(0),
        modFrixione(0),
    sumChargedParticlePt(0),
        sumNeutralHadronEtHighThreshold(0),
    sumPhotonEtHighThreshold(0),
    sumPUPt(0),
    sumEcalClusterEt(0),
    sumHcalClusterEt(0)
      {}
      
      
    };

    float chargedHadronIso() const {return  pfIsolation_.chargedHadronIso;}
    float chargedHadronIsoWrongVtx() const {return  pfIsolation_.chargedHadronIsoWrongVtx;}
    float neutralHadronIso() const {return  pfIsolation_.neutralHadronIso;}
    float photonIso() const {return  pfIsolation_.photonIso;}
    float sumChargedParticlePt() const {return pfIsolation_.sumChargedParticlePt;}
    float sumNeutralHadronEtHighThreshold() const {return pfIsolation_.sumNeutralHadronEtHighThreshold;}
    float sumPhotonEtHighThreshold() const {return pfIsolation_.sumPhotonEtHighThreshold;}
    float sumPUPt() const {return pfIsolation_.sumPUPt;} 
    
    //backwards compat functions for pat::Photon
    float ecalPFClusterIso() const { return pfIsolation_.sumEcalClusterEt; };
    float hcalPFClusterIso() const { return pfIsolation_.sumHcalClusterEt; };

    const PflowIsolationVariables& getPflowIsolationVariables() const { return pfIsolation_; }

    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:
    bool overlap( const Candidate & ) const override;
    math::XYZPointF caloPosition_;
    reco::PhotonCoreRef photonCore_;
    //
    bool pixelSeed_;
    //
    FiducialFlags fiducialFlagBlock_;
    IsolationVariables isolationR04_;
    IsolationVariables isolationR03_;
    ShowerShape        showerShapeBlock_;
    ShowerShape        full5x5_showerShapeBlock_;
    SaturationInfo saturationInfo_;
    EnergyCorrections eCorrections_; 
    MIPVariables        mipVariableBlock_; 
    PflowIsolationVariables pfIsolation_;
    PflowIDVariables pfID_;    
  };

}

#endif