---

Photon.h

Go to the documentation of this file.

//
// $Id: Photon.h,v 1.16 2008/10/08 11:44:31 fronga Exp $
//

#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/EgammaCandidates/interface/PhotonID.h"

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


// Class definition
namespace pat {


  typedef reco::Photon PhotonType;


  class Photon : public PATObject<PhotonType> {

    public:

      Photon();
      Photon(const PhotonType & aPhoton);
      Photon(const edm::RefToBase<PhotonType> & aPhotonRef);
      Photon(const edm::Ptr<PhotonType> & aPhotonRef);
      virtual ~Photon();

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

      // ---- methods for content embedding ----
      reco::SuperClusterRef superCluster() const;
      void embedSuperCluster();

      // ---- methods for access the generated photon ----
      const reco::Particle * genPhoton() const { return genParticle(); }
      void setGenPhoton(const reco::GenParticleRef & gp, bool embed=false) { setGenParticleRef(gp, embed); }

      // ---- methods for photon ID ----
      const reco::PhotonID * photonID() const { return photonID_.empty() ? 0 : & photonID_[0]; }
      void setPhotonID(const reco::PhotonID & photonID) { photonID_.clear(); photonID_.push_back(photonID); }
      bool isLooseEM() const { return photonIDOrThrow().isLooseEM(); }
      bool isLoosePhoton() const { return photonIDOrThrow().isLoosePhoton(); }
      bool isTightPhoton() const { return photonIDOrThrow().isTightPhoton(); }
      float isolationEcalRecHit() const { return photonIDOrThrow().isolationEcalRecHit(); }
      float isolationHcalRecHit() const { return photonIDOrThrow().isolationHcalRecHit(); }
      float isolationSolidTrkCone() const { return photonIDOrThrow().isolationSolidTrkCone(); }
      float isolationHollowTrkCone() const { return photonIDOrThrow().isolationHollowTrkCone(); }
      int nTrkSolidCone() const { return photonIDOrThrow().nTrkSolidCone(); }
      int nTrkHollowCone() const { return photonIDOrThrow().nTrkHollowCone(); }
      float r9() const { return photonIDOrThrow().r9(); }
      bool isEBPho() const { return photonIDOrThrow().isEBPho(); }
      bool isEEPho() const { return photonIDOrThrow().isEEPho(); }
      bool isEBGap() const { return photonIDOrThrow().isEBGap(); }
      bool isEEGap() const { return photonIDOrThrow().isEEGap(); }
      bool isEBEEGap() const { return photonIDOrThrow().isEBEEGap(); }
      bool isAlsoElectron() const { return photonIDOrThrow().isAlsoElectron(); }

      // ---- methods for photon isolation ----
      float isolation(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 CaloIso:  
                  //if (isolations_.size() <= HCalIso) throw cms::Excepton("Missing Data") << "CalIsoo Isolation was not stored for this particle.";
                  if (isolations_.size() <= HCalIso) return -1.0; 
                  return isolations_[ECalIso] + isolations_[HCalIso];
              default:
                  return -1.0;
                  //throw cms::Excepton("Missing Data") << "Isolation corresponding to key " << key << " was not stored for this particle.";
          }
      }
      float trackIso() const { return isolation(TrackerIso); }
      float caloIso()  const { return isolation(CaloIso); }
      float ecalIso()  const { return isolation(ECalIso); }
      float hcalIso()  const { return isolation(HCalIso); }
      float userIso(uint8_t index=0)  const { return isolation(IsolationKeys(UserBaseIso + index)); }
      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(TrackerIso, 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); }

      // ---- 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 0;
      } 
      const IsoDeposit * trackerIsoDeposit() const { return isoDeposit(TrackerIso); }
      const IsoDeposit * ecalIsoDeposit()    const { return isoDeposit(ECalIso); }
      const IsoDeposit * hcalIsoDeposit()    const { return isoDeposit(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 trackerIsoDeposit(const IsoDeposit &dep) { setIsoDeposit(TrackerIso, dep); }
      void ecalIsoDeposit(const IsoDeposit &dep)    { setIsoDeposit(ECalIso, dep); }
      void hcalIsoDeposit(const IsoDeposit &dep)    { setIsoDeposit(HCalIso, dep); }
      void userIsoDeposit(const IsoDeposit &dep, uint8_t index=0) { setIsoDeposit(IsolationKeys(UserBaseIso + index), dep); }

    protected:

      const reco::PhotonID & photonIDOrThrow() const {
        if (photonID_.empty()) throw cms::Exception("Missing Data") << "This pat::Photon doesn't include a reco::PhotonID.\n";
        return photonID_[0];
      }

    protected:

      // ---- for content embedding ----
      bool embeddedSuperCluster_;
      std::vector<reco::SuperCluster> superCluster_;
      // ---- holder for a reco::PhotonID object ----
      std::vector<reco::PhotonID> photonID_;
      // ---- Isolation and IsoDeposit related datamebers ----
      typedef std::vector<std::pair<IsolationKeys, pat::IsoDeposit> > IsoDepositPairs;
      IsoDepositPairs    isoDeposits_;
      std::vector<float> isolations_;

  };


}

#endif

---