---

GenericParticle.h

Go to the documentation of this file.

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

#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 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.";
          }
      }

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

      // ---- specific setters ----
      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); }


      //============ 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 * 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)); }

      // ---- specific setters ----
      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); }

      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

---