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