CaloParticle.h

Go to the documentation of this file.

#ifndef SimDataFormats_CaloParticle_h
#define SimDataFormats_CaloParticle_h
 
#include "DataFormats/HepMCCandidate/interface/GenParticle.h"
#include "DataFormats/Math/interface/LorentzVector.h"
#include "DataFormats/Math/interface/Point3D.h"
#include "DataFormats/Math/interface/Vector3D.h"
#include "SimDataFormats/CaloAnalysis/interface/SimClusterFwd.h"
#include "SimDataFormats/CaloHit/interface/PCaloHit.h"
#include "SimDataFormats/Track/interface/SimTrack.h"
#include <vector>
 
class SimTrack;
class EncodedEventId;
 
class CaloParticle {
  friend std::ostream &operator<<(std::ostream &s, CaloParticle 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;
  typedef SimClusterRefVector::iterator sc_iterator;
 
  CaloParticle();
 
  CaloParticle(const SimTrack &simtrk);
  CaloParticle(EncodedEventId eventID, uint32_t particleID);  // for PU
 
  // destructor
  ~CaloParticle();
 
  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 addSimCluster(const SimClusterRef &ref) { simClusters_.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(); }
  sc_iterator simCluster_begin() const { return simClusters_.begin(); }
  sc_iterator simCluster_end() const { return simClusters_.end(); }
 
  // Getters for Embd and Sim Tracks
  const reco::GenParticleRefVector &genParticles() const { return genParticles_; }
  const SimClusterRefVector &simClusters() const { return simClusters_; }
  // Only for clusters from the signal vertex
  const std::vector<SimTrack> &g4Tracks() const { return g4Tracks_; }
 
  void clearSimClusters() { simClusters_.clear(); }
 
  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;
  }
 
  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_;
 
  SimClusterRefVector simClusters_;
};
 
#endif  // SimDataFormats_CaloParticle_H