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 0;
        return genParticleTrail_[genParticleTrail_.size()-1];
    }
    
    const reco::GenParticle * recoGenParticle() const
    {
        if ( recoGenParticleTrail_.empty() ) return 0;
        return recoGenParticleTrail_[recoGenParticleTrail_.size()-1];
    }

protected:

    // History cointainers
    GenVertexTrail genVertexTrail_;
    GenParticleTrail genParticleTrail_;
    RecoGenParticleTrail recoGenParticleTrail_;
    SimVertexTrail simVertexTrail_;
    SimParticleTrail simParticleTrail_;

    // Helper function to speedup search
    GenVertexTrailHelper genVertexTrailHelper_;
    RecoGenParticleTrailHelper recoGenParticleTrailHelper_;

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

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