Photon.h

Go to the documentation of this file.

//
//

#ifndef DataFormats_PatCandidates_Photon_h
#define DataFormats_PatCandidates_Photon_h

#include "DataFormats/PatCandidates/interface/PATObject.h"
#include "DataFormats/EgammaCandidates/interface/Photon.h"
#include "DataFormats/EgammaReco/interface/SuperClusterFwd.h"
#include "DataFormats/EgammaReco/interface/SuperCluster.h"
#include "DataFormats/PatCandidates/interface/Isolation.h"
#include "DataFormats/PatCandidates/interface/PackedCandidate.h"
#include "DataFormats/EcalRecHit/interface/EcalRecHitCollections.h"
#include "DataFormats/Common/interface/AtomicPtrCache.h"


// Define typedefs for convenience
namespace pat {
  class Photon;
  typedef std::vector<Photon>              PhotonCollection; 
  typedef edm::Ref<PhotonCollection>       PhotonRef; 
  typedef edm::RefVector<PhotonCollection> PhotonRefVector; 
}

namespace reco {
  std::ostream& operator<<(std::ostream& out, const pat::Photon& obj);
}

// Class definition
namespace pat {
  class PATPhotonSlimmer;

  class Photon : public PATObject<reco::Photon> {

    public:

      typedef std::pair<std::string,Bool_t> IdPair;

      Photon();
      Photon(const reco::Photon & aPhoton);
      Photon(const edm::RefToBase<reco::Photon> & aPhotonRef);
      Photon(const edm::Ptr<reco::Photon> & aPhotonRef);
      ~Photon() override;

      Photon * clone() const override { return new Photon(*this); }

      // ---- methods for content embedding ----
      reco::SuperClusterRef superCluster() const override;
      reco::CaloClusterPtr seed() const; 

      //method to access the basic clusters
      const std::vector<reco::CaloCluster>& basicClusters() const { return basicClusters_ ; }
      //method to access the preshower clusters
      const std::vector<reco::CaloCluster>& preshowerClusters() const { return preshowerClusters_ ; }      
      
      //method to access embedded ecal RecHits
      const EcalRecHitCollection * recHits() const { return &recHits_;}      
      
      void embedSuperCluster();
      void embedSeedCluster();
      void embedBasicClusters();
      void embedPreshowerClusters();
      void embedRecHits(const EcalRecHitCollection * rechits); 
      
      
      // ---- methods for access the generated photon ----
      const reco::Candidate * genPhoton() const { return genParticle(); }
      void setGenPhoton(const reco::GenParticleRef & gp, bool embed=false) { setGenParticleRef(gp, embed); }

      // ---- methods for photon ID ----
      Bool_t photonID(const std::string & name) const;
      bool isPhotonIDAvailable(const std::string & name) const;
      const std::vector<IdPair> &  photonIDs() const { return photonIDs_; }
      void setPhotonIDs(const std::vector<IdPair> & ids) { photonIDs_ = ids; }


      // ---- methods for photon isolation ----
      float trackIso() const { return trkSumPtSolidConeDR04(); }
      float ecalIso()  const { return ecalRecHitSumEtConeDR04(); }
      float hcalIso()  const { return hcalTowerSumEtConeDR04(); }
      float caloIso()  const { return ecalIso()+hcalIso(); }

      float patParticleIso() const { return userIsolation(pat::PfAllParticleIso); }
      float chargedHadronIso() const { return reco::Photon::chargedHadronIso(); }
      float neutralHadronIso() const { return reco::Photon::neutralHadronIso(); }
      float photonIso() const { return reco::Photon::photonIso(); }
      float puChargedHadronIso() const { return userIsolation(pat::PfPUChargedHadronIso); }        

      float userIso(uint8_t index=0)  const { return userIsolation(IsolationKeys(UserBaseIso + index)); }
      float userIsolation(IsolationKeys key) const { 
          if (key >= 0) {
        //if (key >= isolations_.size()) throw cms::Excepton("Missing Data") 
        //<< "Isolation corresponding to key " << key 
        //<< " was not stored for this particle.";
              if (size_t(key) >= isolations_.size()) return -1.0;
              return isolations_[key];
          } else switch (key) {
      case pat::CaloIso:  
        //if (isolations_.size() <= pat::HcalIso) throw cms::Excepton("Missing Data") 
        //<< "CalIsoo Isolation was not stored for this particle.";
        if (isolations_.size() <= pat::HcalIso) return -1.0; 
        return isolations_[pat::EcalIso] + isolations_[pat::HcalIso];
      default:
        return -1.0;
        //throw cms::Excepton("Missing Data") << "Isolation corresponding to key " 
        //<< key << " was not stored for this particle.";
          }
      }

      float puppiChargedHadronIso() const {return puppiChargedHadronIso_; }
      float puppiNeutralHadronIso() const {return puppiNeutralHadronIso_; }
      float puppiPhotonIso() const {return puppiPhotonIso_; }

      void setIsolation(IsolationKeys key, float value) {
          if (key >= 0) {
              if (size_t(key) >= isolations_.size()) isolations_.resize(key+1, -1.0);
              isolations_[key] = value;
          } else {
              throw cms::Exception("Illegal Argument") << 
                  "The key for which you're setting isolation does not correspond " <<
                  "to an individual isolation but to the sum of more independent isolations " <<
                  "(e.g. Calo = Ecal + Hcal), so you can't SET the value, just GET it.\n" <<
                  "Please set up each component independly.\n";
          }
      }
      void setTrackIso(float trackIso) { setIsolation(TrackIso, trackIso); }
      void setEcalIso(float caloIso)   { setIsolation(EcalIso,  caloIso);  } 
      void setHcalIso(float caloIso)   { setIsolation(HcalIso,  caloIso);  }
      void setUserIso(float value, uint8_t index=0)  { setIsolation(IsolationKeys(UserBaseIso + index), value); }
      void setIsolationPUPPI(float chargedhadrons_, float neutralhadrons_, float photons_)
      {  
         puppiChargedHadronIso_ = chargedhadrons_;
         puppiNeutralHadronIso_ = neutralhadrons_;
         puppiPhotonIso_ = photons_;

      }

      // ---- methods for photon isolation deposits ----
      const IsoDeposit * isoDeposit(IsolationKeys key) const {
          for (IsoDepositPairs::const_iterator it = isoDeposits_.begin(), ed = isoDeposits_.end(); 
                  it != ed; ++it) 
          {
              if (it->first == key) return & it->second;
          }
          return nullptr;
      } 
      const IsoDeposit * trackIsoDeposit() const { return isoDeposit(pat::TrackIso); }
      const IsoDeposit * ecalIsoDeposit()  const { return isoDeposit(pat::EcalIso ); }
      const IsoDeposit * hcalIsoDeposit()  const { return isoDeposit(pat::HcalIso ); }
      const IsoDeposit * userIsoDeposit(uint8_t index=0) const { return isoDeposit(IsolationKeys(UserBaseIso + index)); }
      void setIsoDeposit(IsolationKeys key, const IsoDeposit &dep) {
          IsoDepositPairs::iterator it = isoDeposits_.begin(), ed = isoDeposits_.end();
          for (; it != ed; ++it) {
              if (it->first == key) { it->second = dep; return; }
          }
          isoDeposits_.push_back(std::make_pair(key,dep));
      } 
      void trackIsoDeposit(const IsoDeposit &dep) { setIsoDeposit(pat::TrackIso, dep); }
      void ecalIsoDeposit(const IsoDeposit &dep)  { setIsoDeposit(pat::EcalIso,  dep); }
      void hcalIsoDeposit(const IsoDeposit &dep)  { setIsoDeposit(pat::HcalIso,  dep); }
      void userIsoDeposit(const IsoDeposit &dep, uint8_t index=0) { setIsoDeposit(IsolationKeys(UserBaseIso + index), dep); }
      bool passElectronVeto() const { return passElectronVeto_; }
      void setPassElectronVeto( bool flag ) { passElectronVeto_ = flag; }
      //pixel seed to veto electron (not recommended by EGM POG but it seems very efficient)
      bool hasPixelSeed() const { return hasPixelSeed_; }
      void setHasPixelSeed( bool flag ) { hasPixelSeed_ = flag; }

      float seedEnergy() const { return seedEnergy_;}
      void setSeedEnergy( float e ){ seedEnergy_ = e; }

      float eMax() const { return eMax_;}
      void setEMax( float e ){ eMax_ = e;}
      float e2nd() const { return e2nd_;}
      void setE2nd( float e ){ e2nd_ = e;}
      float e3x3() const { return e3x3_;}
      void setE3x3( float e ){ e3x3_ = e;}
      float eTop() const { return eTop_;}
      void setETop( float e ){ eTop_ = e;}
      float eBottom() const { return eBottom_;}
      void setEBottom( float e ){ eBottom_ = e;}
      float eLeft() const { return eLeft_;}
      void setELeft( float e ){ eLeft_ = e;}
      float eRight() const { return eRight_;}
      void setERight( float e ){ eRight_ = e;}
  
      float see() const { return see_;}
      void setSee( float s ){ see_ = s;}
      float spp() const { return spp_;}
      void setSpp( float s ){ spp_ = s;}
      float sep() const { return sep_;}
      void setSep( float s ){ sep_ = s;}

      float maxDR() const { return maxDR_;}
      void setMaxDR( float m ){ maxDR_ = m;}
      float maxDRDPhi() const { return maxDRDPhi_;}
      void setMaxDRDPhi( float m ){ maxDRDPhi_ = m;}
      float maxDRDEta() const { return maxDRDEta_;}
      void setMaxDRDEta( float m ){ maxDRDEta_ = m;}
      float maxDRRawEnergy() const { return maxDRRawEnergy_;}
      void setMaxDRRawEnergy( float m ){ maxDRRawEnergy_ = m;}

      float subClusRawE1() const { return subClusRawE1_;}
      void setSubClusRawE1( float s ){ subClusRawE1_ = s;}
      float subClusRawE2() const { return subClusRawE2_;}
      void setSubClusRawE2( float s ){ subClusRawE2_ = s;}
      float subClusRawE3() const { return subClusRawE3_;}
      void setSubClusRawE3( float s ){ subClusRawE3_ = s;}

      float subClusDPhi1() const { return subClusDPhi1_;}
      void setSubClusDPhi1( float s ){ subClusDPhi1_ = s;}
      float subClusDPhi2() const { return subClusDPhi2_;}
      void setSubClusDPhi2( float s ){ subClusDPhi2_ = s;}
      float subClusDPhi3() const { return subClusDPhi3_;}
      void setSubClusDPhi3( float s ){ subClusDPhi3_ = s;}

      float subClusDEta1() const { return subClusDEta1_;}
      void setSubClusDEta1( float s ){ subClusDEta1_ = s;}
      float subClusDEta2() const { return subClusDEta2_;}
      void setSubClusDEta2( float s ){ subClusDEta2_ = s;}
      float subClusDEta3() const { return subClusDEta3_;}
      void setSubClusDEta3( float s ){ subClusDEta3_ = s;}

      float cryPhi() const { return cryPhi_;}
      void setCryPhi( float c ){ cryPhi_ = c;}
      float cryEta() const { return cryEta_;}
      void setCryEta( float c ){ cryEta_ = c;}

      float iPhi() const { return iPhi_;}
      void setIPhi( float i ){ iPhi_ = i;}
      float iEta() const { return iEta_;}
      void setIEta( float i ){ iEta_ = i;}

      friend std::ostream& reco::operator<<(std::ostream& out, const pat::Photon& obj);

      edm::RefVector<pat::PackedCandidateCollection> associatedPackedPFCandidates() const ;
      template<typename T>
      void setAssociatedPackedPFCandidates(const edm::RefProd<pat::PackedCandidateCollection> & refprod,
                                           T beginIndexItr,
                                           T endIndexItr) {
        packedPFCandidates_ = refprod;
        associatedPackedFCandidateIndices_.clear();
        associatedPackedFCandidateIndices_.insert(associatedPackedFCandidateIndices_.begin(),
                                                  beginIndexItr,
                                                  endIndexItr);
      }
 
      size_t numberOfSourceCandidatePtrs() const override { return associatedPackedFCandidateIndices_.size(); }
      reco::CandidatePtr sourceCandidatePtr( size_type i ) const override;

      friend class PATPhotonSlimmer;

    protected:

      // ---- for content embedding ----
      bool embeddedSuperCluster_;
      std::vector<reco::SuperCluster> superCluster_;
      edm::AtomicPtrCache<std::vector<reco::SuperCluster> > superClusterRelinked_;
      std::vector<reco::CaloCluster> basicClusters_;
      std::vector<reco::CaloCluster> preshowerClusters_;      
      bool embeddedSeedCluster_;
      std::vector<reco::CaloCluster> seedCluster_;
      bool embeddedRecHits_;    
      EcalRecHitCollection recHits_;      
      // ---- photon ID's holder ----
      std::vector<IdPair> photonIDs_;
      // ---- Isolation and IsoDeposit related datamebers ----
      typedef std::vector<std::pair<IsolationKeys, pat::IsoDeposit> > IsoDepositPairs;
      IsoDepositPairs    isoDeposits_;
      std::vector<float> isolations_;

      bool passElectronVeto_;
      bool hasPixelSeed_;
      
      float seedEnergy_;
      float eMax_;
      float e2nd_;
      float e3x3_;
      float eTop_;
      float eBottom_;
      float eLeft_;
      float eRight_;

      float see_;
      float spp_;
      float sep_;

      float maxDR_;
      float maxDRDPhi_;
      float maxDRDEta_;
      float maxDRRawEnergy_;
   
      float subClusRawE1_;
      float subClusRawE2_;
      float subClusRawE3_;

      float subClusDPhi1_;
      float subClusDPhi2_;
      float subClusDPhi3_;

      float subClusDEta1_;
      float subClusDEta2_;
      float subClusDEta3_;

      float cryEta_;
      float cryPhi_;
      float iEta_;
      float iPhi_;

      //PUPPI isolations
      float puppiChargedHadronIso_;
      float puppiNeutralHadronIso_;
      float puppiPhotonIso_;

      // ---- link to PackedPFCandidates
      edm::RefProd<pat::PackedCandidateCollection> packedPFCandidates_;
      std::vector<uint16_t> associatedPackedFCandidateIndices_;
  };


}

#endif