GenericParticle.h

Go to the documentation of this file.

//
//
 
#ifndef DataFormats_PatCandidates_GenericParticle_h
#define DataFormats_PatCandidates_GenericParticle_h
 
#include "DataFormats/PatCandidates/interface/PATObject.h"
#include "DataFormats/RecoCandidate/interface/RecoCandidate.h"
#include "DataFormats/EgammaReco/interface/SuperClusterFwd.h"
#include "DataFormats/EgammaReco/interface/SuperCluster.h"
#include "DataFormats/GsfTrackReco/interface/GsfTrackFwd.h"
#include "DataFormats/GsfTrackReco/interface/GsfTrack.h"
#include "DataFormats/PatCandidates/interface/Isolation.h"
#include "DataFormats/PatCandidates/interface/Vertexing.h"
#include "DataFormats/HepMCCandidate/interface/GenParticle.h"
 
// Define typedefs for convenience
namespace pat {
  class GenericParticle;
  typedef std::vector<GenericParticle> GenericParticleCollection;
  typedef edm::Ref<GenericParticleCollection> GenericParticleRef;
  typedef edm::RefVector<GenericParticleCollection> GenericParticleRefVector;
}  // namespace pat
 
// Class definition
namespace pat {
 
  class GenericParticle : public PATObject<reco::RecoCandidate> {
  public:
    GenericParticle();
    GenericParticle(const reco::Candidate &aGenericParticle);
    GenericParticle(const edm::RefToBase<reco::Candidate> &aGenericParticleRef);
    GenericParticle(const edm::Ptr<reco::Candidate> &aGenericParticleRef);
    ~GenericParticle() override;
 
    GenericParticle *clone() const override { return new GenericParticle(*this); }
 
    bool overlap(const Candidate &) const override;
 
    reco::TrackRef track() const override { return track_.empty() ? trackRef_ : reco::TrackRef(&track_, 0); }
    reco::TrackRef track(size_t idx) const override {
      if (idx >= numberOfTracks())
        throw cms::Exception("Index out of bounds")
            << "Requested track " << idx << " out of " << numberOfTracks() << ".\n";
      return (tracks_.empty() ? trackRefs_[idx] : reco::TrackRef(&tracks_, idx));
    }
    size_t numberOfTracks() const override { return tracks_.empty() ? trackRefs_.size() : tracks_.size(); }
    reco::GsfTrackRef gsfTrack() const override {
      return (gsfTrack_.empty() ? gsfTrackRef_ : reco::GsfTrackRef(&gsfTrack_, 0));
    }
    reco::TrackRef standAloneMuon() const override {
      return (standaloneTrack_.empty() ? standaloneTrackRef_ : reco::TrackRef(&standaloneTrack_, 0));
    }
    reco::TrackRef combinedMuon() const override {
      return (combinedTrack_.empty() ? combinedTrackRef_ : reco::TrackRef(&combinedTrack_, 0));
    }
    reco::SuperClusterRef superCluster() const override {
      return superCluster_.empty() ? superClusterRef_ : reco::SuperClusterRef(&superCluster_, 0);
    }
    CaloTowerRef caloTower() const override {
      return caloTower_.empty() ? caloTowerRef_ : CaloTowerRef(&caloTower_, 0);
    }
 
    virtual void setTrack(const reco::TrackRef &ref, bool embed = false);
    virtual void setTracks(const reco::TrackRefVector &refs, bool embed = false);
    virtual void setStandAloneMuon(const reco::TrackRef &ref, bool embed = false);
    virtual void setCombinedMuon(const reco::TrackRef &ref, bool embed = false);
    virtual void setGsfTrack(const reco::GsfTrackRef &ref, bool embed = false);
    virtual void setSuperCluster(const reco::SuperClusterRef &ref, bool embed = false);
    virtual void setCaloTower(const CaloTowerRef &ref, bool embed = false);
 
    void embedTrack();
    void embedTracks();
    void embedStandalone();
    void embedCombined();
    void embedGsfTrack();
    void embedSuperCluster();
    void embedCaloTower();
 
    float quality() { return quality_; }
    void setQuality(float quality) { quality_ = quality; }
 
    //============ BEGIN ISOLATION BLOCK =====
    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 userIsolation(const std::string &key) const {
      // remove leading namespace specifier
      std::string prunedKey = (key.find("pat::") == 0) ? std::string(key, 5) : key;
      if (prunedKey == "TrackIso")
        return userIsolation(pat::TrackIso);
      if (prunedKey == "EcalIso")
        return userIsolation(pat::EcalIso);
      if (prunedKey == "HcalIso")
        return userIsolation(pat::HcalIso);
      if (prunedKey == "PfAllParticleIso")
        return userIsolation(pat::PfAllParticleIso);
      if (prunedKey == "PfChargedHadronIso")
        return userIsolation(pat::PfChargedHadronIso);
      if (prunedKey == "PfNeutralHadronIso")
        return userIsolation(pat::PfNeutralHadronIso);
      if (prunedKey == "PfGammaIso")
        return userIsolation(pat::PfGammaIso);
      if (prunedKey == "User1Iso")
        return userIsolation(pat::User1Iso);
      if (prunedKey == "User2Iso")
        return userIsolation(pat::User2Iso);
      if (prunedKey == "User3Iso")
        return userIsolation(pat::User3Iso);
      if (prunedKey == "User4Iso")
        return userIsolation(pat::User4Iso);
      if (prunedKey == "User5Iso")
        return userIsolation(pat::User5Iso);
      if (prunedKey == "UserBaseIso")
        return userIsolation(pat::UserBaseIso);
      if (prunedKey == "CaloIso")
        return userIsolation(pat::CaloIso);
      //throw cms::Excepton("Missing Data")
      //<< "Isolation corresponding to key "
      //<< key << " was not stored for this particle.";
      return -1.0;
    }
    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";
      }
    }
 
    // ---- specific getters ----
    float trackIso() const { return userIsolation(pat::TrackIso); }
    float caloIso() const { return userIsolation(pat::CaloIso); }
    float ecalIso() const { return userIsolation(pat::EcalIso); }
    float hcalIso() const { return userIsolation(pat::HcalIso); }
 
    // ---- specific setters ----
    void setTrackIso(float trackIso) { setIsolation(pat::TrackIso, trackIso); }
    void setEcalIso(float caloIso) { setIsolation(pat::EcalIso, caloIso); }
    void setHcalIso(float caloIso) { setIsolation(pat::HcalIso, caloIso); }
    void setUserIso(float value, uint8_t index = 0) { setIsolation(IsolationKeys(UserBaseIso + index), value); }
 
    //============ BEGIN ISODEPOSIT BLOCK =====
    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;
    }
 
    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));
    }
 
    // ---- specific getters ----
    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)); }
 
    // ---- specific setters ----
    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);
    }
 
    const pat::VertexAssociation *vertexAssociation(size_t index = 0) const {
      return vtxAss_.size() > index ? &vtxAss_[index] : nullptr;
    }
    const std::vector<pat::VertexAssociation> &vertexAssociations() const { return vtxAss_; }
    void setVertexAssociation(const pat::VertexAssociation &assoc) {
      vtxAss_ = std::vector<pat::VertexAssociation>(1, assoc);
    }
    void setVertexAssociations(const std::vector<pat::VertexAssociation> &assocs) { vtxAss_ = assocs; }
 
  protected:
    // Any sort of single tracks
    reco::TrackRef trackRef_, standaloneTrackRef_, combinedTrackRef_;  // ref
    reco::TrackCollection track_, standaloneTrack_, combinedTrack_;    // embedded
 
    // GsfTrack
    reco::GsfTrackRef gsfTrackRef_;      // normal
    reco::GsfTrackCollection gsfTrack_;  // embedded
 
    // CaloTower
    CaloTowerRef caloTowerRef_;      // ref
    CaloTowerCollection caloTower_;  // embedded
 
    // SuperCluster
    reco::SuperClusterRef superClusterRef_;      // ref
    reco::SuperClusterCollection superCluster_;  // embedded
 
    // Multiple tracks
    reco::TrackRefVector trackRefs_;  // by ref
    reco::TrackCollection tracks_;    // embedded
 
    // information originally in external branches
    // some quality variable
    float quality_;
 
    // --- Isolation and IsoDeposit related datamebers ---
    typedef std::vector<std::pair<IsolationKeys, pat::IsoDeposit> > IsoDepositPairs;
    IsoDepositPairs isoDeposits_;
    std::vector<float> isolations_;
 
    // --- Vertexing information
    std::vector<pat::VertexAssociation> vtxAss_;
 
    void fillInFrom(const reco::Candidate &cand);
  };
 
}  // namespace pat
 
#endif