SimCluster.h

Go to the documentation of this file.

#ifndef SimDataFormats_SimCluster_h
#define SimDataFormats_SimCluster_h

#include <vector>
#include "SimDataFormats/Track/interface/SimTrack.h"
#include "SimDataFormats/CaloHit/interface/PCaloHit.h"
#include "DataFormats/Math/interface/Point3D.h"
#include "DataFormats/Math/interface/Vector3D.h"
#include "DataFormats/Math/interface/LorentzVector.h"
#include "DataFormats/HepMCCandidate/interface/GenParticle.h"

//
// Forward declarations
//
class SimTrack;
class EncodedEventId;

class SimCluster
{
    friend std::ostream& operator<< (std::ostream& s, SimCluster const& tp);
public:
    typedef int Charge; 
    typedef math::XYZTLorentzVectorD LorentzVector; 
    typedef math::PtEtaPhiMLorentzVector PolarLorentzVector; 
    typedef math::XYZPointD Point; 
    typedef math::XYZVectorD Vector; 

    typedef reco::GenParticleRefVector::iterator   genp_iterator;
    typedef std::vector<SimTrack>::const_iterator  g4t_iterator;

    SimCluster();

    SimCluster( const SimTrack& simtrk );
    SimCluster( EncodedEventId eventID, uint32_t particleID ); // for PU

    // destructor
    ~SimCluster();

    int pdgId() const {
      if( genParticles_.empty() ) return g4Tracks_[0].type();
      else return (*genParticles_.begin())->pdgId();
    }

    EncodedEventId eventId() const {
      return event_;
    }

    uint64_t particleId() const {
      return particleId_;
    }

    // Setters for G4 and reco::GenParticle
    void addGenParticle( const reco::GenParticleRef& ref) { genParticles_.push_back( ref ); }
    void addG4Track( const SimTrack& t) { g4Tracks_.push_back(t); }
    genp_iterator genParticle_begin() const { return genParticles_.begin(); }
    genp_iterator genParticle_end()   const { return genParticles_.end(); }
    g4t_iterator g4Track_begin() const { return g4Tracks_.begin(); } 
    g4t_iterator g4Track_end()   const { return g4Tracks_.end(); }
    
    // Getters for Embd and Sim Tracks
    const reco::GenParticleRefVector& genParticles() const { return genParticles_; }
    // Only for clusters from the signal vertex
    const std::vector<SimTrack>& g4Tracks() const { return g4Tracks_; }
    
    float charge() const { return g4Tracks_[0].charge(); }
    int threeCharge() const { return lrintf(3.f*charge()); }

    const math::XYZTLorentzVectorF& p4() const {
      return theMomentum_;
    }

    math::XYZVectorF momentum() const {
      return p4().Vect();
    }

    math::XYZVectorF boostToCM() const {
      return p4().BoostToCM();
    }

    float p() const {
      return p4().P();
    }

    float energy() const {
      return p4().E();
    }

    float et() const {
      return p4().Et();
    }

    float mass() const {
      return p4().M();
    }

    float massSqr() const {
      return pow( mass(), 2 );
    }

    float mt() const {
      return p4().Mt();
    }

    float mtSqr() const {
      return p4().Mt2();
    }

    float px() const {
      return p4().Px();
    }

    float py() const {
      return p4().Py();
    }

    float pz() const {
      return p4().Pz();
    }

    float pt() const {
      return p4().Pt();
    }

    float phi() const {
      return p4().Phi();
    }

    float theta() const {
      return p4().Theta();
    }

    float eta() const {
      return p4().Eta();
    }

    float rapidity() const {
      return p4().Rapidity();
    }

    float y() const {
      return rapidity();
    }

    int status() const {
      return genParticles_.empty() ? -99 : (*genParticles_[0]).status();
    }

    static const unsigned int longLivedTag; 

    bool longLived() const { return status()&longLivedTag;}

    int numberOfSimHits() const {return nsimhits_;}
    
    int numberOfRecHits() const {return hits_.size();}

    void addRecHitAndFraction(uint32_t hit, float fraction) {
      hits_.emplace_back(hit);
      fractions_.emplace_back(fraction);
    }

    std::vector<std::pair<uint32_t,float> > hits_and_fractions() const {
      std::vector<std::pair<uint32_t,float> > result;
      for(size_t i = 0; i < hits_.size(); ++i) { 
        result.emplace_back(hits_[i],fractions_[i]);
      }
      return result;
    }

    void clearHitsAndFractions() {
      std::vector<uint32_t>().swap(hits_);
      std::vector<float>().swap(fractions_);
    }
   
    float simEnergy() const { return simhit_energy_; }

    void addSimHit(const PCaloHit& hit) { simhit_energy_ += hit.energy(); }
    
private:
    uint64_t nsimhits_;
    EncodedEventId event_;
    
    uint32_t particleId_; 
    float simhit_energy_;
    std::vector<uint32_t> hits_;
    std::vector<float> fractions_;
    
    math::XYZTLorentzVectorF theMomentum_;
    
    std::vector<SimTrack> g4Tracks_;
    reco::GenParticleRefVector genParticles_;
    
};

#endif // SimDataFormats_SimCluster_H