HistoryBase.h

Go to the documentation of this file.

#ifndef HistoryBase_h
#define HistoryBase_h
 
#include <set>
 
#include "SimDataFormats/TrackingAnalysis/interface/TrackingParticle.h"
#include "SimDataFormats/TrackingAnalysis/interface/TrackingParticleFwd.h"
#include "SimDataFormats/TrackingAnalysis/interface/TrackingVertex.h"
#include "SimDataFormats/TrackingAnalysis/interface/TrackingVertexContainer.h"
 
class HistoryBase {
public:
  typedef std::vector<const HepMC::GenParticle *> GenParticleTrail;
 
  typedef std::vector<const reco::GenParticle *> RecoGenParticleTrail;
 
  typedef std::set<const reco::GenParticle *> RecoGenParticleTrailHelper;
 
  typedef std::vector<const HepMC::GenVertex *> GenVertexTrail;
 
  typedef std::set<const HepMC::GenVertex *> GenVertexTrailHelper;
 
  typedef std::vector<TrackingParticleRef> SimParticleTrail;
 
  typedef std::vector<TrackingVertexRef> SimVertexTrail;
 
  // Default constructor
  HistoryBase() {
    // Default depth
    depth_ = -1;
  }
 
  /* Set TrackHistory to given depth. Positive values
     constrain the number of TrackingVertex visit in the history.
     Negatives values set the limit of the iteration over generated
     information i.e. (-1 -> status 1 or -2 -> status 2 particles).
 
     /param[in] depth the history
  */
  void depth(int d) { depth_ = d; }
 
  SimVertexTrail const &simVertexTrail() const { return simVertexTrail_; }
 
  SimParticleTrail const &simParticleTrail() const { return simParticleTrail_; }
 
  GenVertexTrail const &genVertexTrail() const { return genVertexTrail_; }
 
  GenParticleTrail const &genParticleTrail() const { return genParticleTrail_; }
 
  RecoGenParticleTrail const &recoGenParticleTrail() const { return recoGenParticleTrail_; }
 
  const TrackingParticleRef &simParticle() const { return simParticleTrail_[0]; }
 
  const TrackingVertexRef &simVertex() const { return simVertexTrail_[0]; }
 
  const HepMC::GenParticle *genParticle() const {
    if (genParticleTrail_.empty())
      return nullptr;
    return genParticleTrail_[genParticleTrail_.size() - 1];
  }
 
  const reco::GenParticle *recoGenParticle() const {
    if (recoGenParticleTrail_.empty())
      return nullptr;
    return recoGenParticleTrail_[recoGenParticleTrail_.size() - 1];
  }
 
  /* Return false when the history cannot be determined upto a given depth.
     If not depth is pass to the function no restriction are apply to it.
 
     /param[in] TrackingParticleRef of a simulated track
     /param[in] depth of the track history
     /param[out] boolean that is true when history can be determined
  */
  bool evaluate(TrackingParticleRef tpr) {
    resetTrails(tpr);
    return traceSimHistory(tpr, depth_);
  }
 
  /* Return false when the history cannot be determined upto a given depth.
     If not depth is pass to the function no restriction are apply to it.
 
     /param[in] TrackingVertexRef of a simulated vertex
     /param[in] depth of the track history
     /param[out] boolean that is true when history can be determined
  */
  bool evaluate(TrackingVertexRef tvr) {
    resetTrails();
    return traceSimHistory(tvr, depth_);
  }
 
protected:
  // History cointainers
  GenVertexTrail genVertexTrail_;
  GenParticleTrail genParticleTrail_;
  RecoGenParticleTrail recoGenParticleTrail_;
  SimVertexTrail simVertexTrail_;
  SimParticleTrail simParticleTrail_;
 
  // Helper function to speedup search
  GenVertexTrailHelper genVertexTrailHelper_;
  RecoGenParticleTrailHelper recoGenParticleTrailHelper_;
 
private:
  int depth_;
 
  bool traceSimHistory(TrackingParticleRef const &, int);
 
  bool traceSimHistory(TrackingVertexRef const &, int);
 
  void traceGenHistory(HepMC::GenParticle const *);
 
  void traceRecoGenHistory(reco::GenParticle const *);
 
  void traceGenHistory(HepMC::GenVertex const *);
 
  void resetTrails() {
    simParticleTrail_.clear();
    simVertexTrail_.clear();
    genVertexTrail_.clear();
    genParticleTrail_.clear();
    recoGenParticleTrail_.clear();
    recoGenParticleTrailHelper_.clear();
    genVertexTrailHelper_.clear();
  }
 
  void resetTrails(TrackingParticleRef tpr) {
    resetTrails();
    simParticleTrail_.push_back(tpr);
  }
};
 
#endif