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 pat
 
namespace reco {
  std::ostream& operator<<(std::ostream& out, const pat::Photon& obj);
}  // namespace reco
 
// 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_;
  };
 
}  // namespace pat
 
#endif