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; 
}


// 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);
      virtual ~GenericParticle();

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

      virtual bool overlap( const Candidate & ) const ;

      virtual reco::TrackRef track() const    { return track_.empty() ? trackRef_ : reco::TrackRef(&track_, 0); }
      virtual reco::TrackRef track( size_t idx ) const {  
            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) );
      }
      virtual size_t numberOfTracks() const { return tracks_.empty() ? trackRefs_.size() : tracks_.size(); }
      virtual reco::GsfTrackRef gsfTrack() const    { return (gsfTrack_.empty() ? gsfTrackRef_ : reco::GsfTrackRef(&gsfTrack_, 0)); }
      virtual reco::TrackRef standAloneMuon() const { return (standaloneTrack_.empty() ? standaloneTrackRef_ : reco::TrackRef(&standaloneTrack_, 0)); }
      virtual reco::TrackRef combinedMuon()   const { return (combinedTrack_.empty() ? combinedTrackRef_ : reco::TrackRef(&combinedTrack_, 0)); }
      virtual reco::SuperClusterRef superCluster() const { return superCluster_.empty() ? superClusterRef_ : reco::SuperClusterRef(&superCluster_, 0); }
      virtual CaloTowerRef caloTower() const { 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 0;
      } 

      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] : 0; }
      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); 
    
  };


}

#endif