/home/bes3soft/bes3soft/Boss/7.0.2/dist/7.0.2/Event/EventNavigator/EventNavigator-00-01-03/EventNavigator/EventNavigator.h

Go to the documentation of this file.

#ifndef EventNavigator_H
#define EventNavigator_H 

#include <map>

#include "GaudiKernel/Kernel.h"
#include "GaudiKernel/StreamBuffer.h"
#include "GaudiKernel/DataObject.h"

#include "EventModel/EventModel.h"

// Monte-Carlo data
#include "McTruth/McParticle.h"
#include "McTruth/MdcMcHit.h"
#include "McTruth/EmcMcHit.h"
#include "McTruth/TofMcHit.h"
#include "McTruth/MucMcHit.h"

// MDC reconstructed data
#include "MdcRecEvent/RecMdcTrack.h"
#include "MdcRecEvent/RecMdcKalTrack.h"
#include "MdcRecEvent/RecMdcHit.h"

// EMC reconstructed data
#include "EmcRecEventModel/RecEmcShower.h"

// TOF reconstructed data
class RecBTofTrack;
class RecBTofHit;
class RecETofTrack;
class RecETofHit;

// MUC reconstructed data
class RecMucTrack;
class RecMucHit;

// Digi information
class MdcDigi;

class BesNavigatorInit;

//using namespace Event;

typedef std::multimap <int, int> IndexMap;
typedef std::vector < pair<const Event::McParticle*,int> > McParticleVectorP;
typedef std::vector < pair<const RecMdcTrack*,int> >    RecMdcTrackVectorP;
typedef std::vector < pair<const RecMdcKalTrack*,int> > RecMdcKalTrackVectorP;
typedef std::vector < pair<const RecEmcShower*,int> > RecEmcShowerVectorP;
typedef std::vector <const Event::McParticle*>       McParticleVector;
typedef std::vector <const RecMdcTrack*>      RecMdcTrackVector;
typedef std::vector <const RecMdcKalTrack*>   RecMdcKalTrackVector;
typedef std::vector <const Event::MdcMcHit*>  MdcMcHitVector;
typedef std::vector <const RecMdcHit*>        RecMdcHitVector;
typedef std::vector <const MdcDigi*>          MdcDigiVector;
typedef std::vector <const Event::EmcMcHit*>  EmcMcHitVector;
typedef std::vector <const RecEmcShower*>     RecEmcShowerVector;

static const CLID CLID_EventNavigator = 5101;

// Class EventNavigator

// Provides relation tables to make correspondence between BES3 
// reconstructed data and Monte-Carlo truth

// History: A.Zhemchugov. Created with MDC navigation, 20 Jan 2006 
//          A.Zhemchugov. EMC navigation  added,       23 Nov 2006
//          A.Zhemchugov. Migrated to new EventModel,  03 Apr 2008
//          A.Zhemchugov. Cut on number of common hits in MDC introduced, 13 Jun 2009
//          A.Zhemchugov. Store Event Navigator to DST, 17 Aug 2011 
//          A.Zhemchugov. Add methods to access McParticle relevance, 07 Aug 2012

class EventNavigator : public DataObject                                                {
    
 public:
    
  EventNavigator() : DataObject() 
    {
        m_mdcCut = 7;
    }
    
  virtual ~EventNavigator() {}
    
  virtual const CLID& clID() const { return EventNavigator::classID(); }
  static const CLID& classID() { return CLID_EventNavigator; }

  void Print();

  // Set cut on the minimum number of common hits of 
  // the MDC tracks and McParticles to make correspondence (default is 2)
  void setMdcCut( int cut ) { m_mdcCut = cut; };

  //******** Methods to retrieve objPtr via id *******
  const Event::McParticle* getMcParticle ( int id ) { return m_mcParticleId[id]; };
  // MDC
  const RecMdcTrack*   getMdcTrack   ( int id ) { return m_mdcTrackId[id]; };
  const RecMdcKalTrack*   getMdcKalTrack   ( int id ) { return m_mdcKalTrackId[id]; };

  // return MdcMcHits corresponding given detector Id
  MdcMcHitVector    getMdcMcHits   ( int id );

  const RecMdcHit*  getMdcRecHit  ( int id ) { return m_mdcRecHitId[id]; };
  const MdcDigi*    getMdcDigi    ( int id ) { return m_mdcDigiId[id]; };
  // EMC
  RecEmcShowerVector getEmcRecShowers ( int id );
  EmcMcHitVector     getEmcMcHits     ( int id );
  
  //******** Methods to handle persistency ************
  IndexMap& getMcMdcMcHitsIdx(){return m_mcMdcMcHitsIdx;}
  IndexMap& getMcMdcTracksIdx(){return m_mcMdcTracksIdx;}
  IndexMap& getMcEmcMcHitsIdx(){return m_mcEmcMcHitsIdx;}
  IndexMap& getMcEmcRecShowersIdx(){return m_mcEmcRecShowersIdx;}
  void setMcMdcMcHitsIdx(IndexMap& map){m_mcMdcMcHitsIdx=map;}
  void setMcMdcTracksIdx(IndexMap& map){m_mcMdcTracksIdx=map;}
  void setMcEmcMcHitsIdx(IndexMap& map){m_mcEmcMcHitsIdx=map;}
  void setMcEmcRecShowersIdx(IndexMap& map){m_mcEmcRecShowersIdx=map;}

  //******** Main methods to retrieve relations *******
  // MC particle
  McParticleVector& getMcParticles  ( const RecMdcTrack* key ); 
  McParticleVector& getMcParticles  ( const RecMdcKalTrack* key ); 
  McParticleVector& getMcParticles  ( const RecEmcShower* key );

  int getMcParticleRelevance( const RecMdcTrack* key, const Event::McParticle* value );
  int getMcParticleRelevance( const RecMdcKalTrack* key, const Event::McParticle* value );
  int getMcParticleRelevance( const RecEmcShower* key, const Event::McParticle* value );

  // MDC Tracks
  RecMdcTrackVector&    getMdcTracks     ( const Event::McParticle* key );
  RecMdcKalTrackVector& getMdcKalTracks  ( const Event::McParticle* key );

  // Reconstructed EMC showers
  RecEmcShowerVector&   getEmcRecShowers ( const Event::McParticle* key );

  //******** Auxillary methods to retrieve relations **
  /*
  RecMdcHitVector&  getMdcRecHits   ( const McParticle* key );
  MdcMcHitVector&   getMdcMcHits    ( const RecMdcTrack* key );
  RecMdcHitVector&  getMdcRecHits   ( const MdcMcHit* key );
  MdcMcHitVector&   getMdcMcHits    ( const RecMdcHit* key );
  
  EmcMcHitVector& getEmcMcHits     ( const RecEmcShower* key ); 
  */


  friend class BesNavigatorInit;

 protected:
  
  // ==== Methods to store id->objPtr lookup maps ====
  void addIdLink ( int id, Event::McParticle* ptr ) { m_mcParticleId[id] = ptr; };
  
  // MDC info
  void addIdLink ( int id, RecMdcTrack* ptr ) { 
    m_mdcTrackId[id] = ptr; 
  };
  
  void addIdLink ( int id, RecMdcKalTrack* ptr ) { 
    m_mdcKalTrackId[id] = ptr; 
  };

  void addIdLink ( unsigned int id, RecEmcShower* ptr ) { 
    m_emcRecShowerId.insert(pair<int, RecEmcShower*>(id,ptr)); 
  };
  
  // ==== Methods to store relations ====
  // store list of MdcTracks corresponding given McParticle
  void addLink( const Event::McParticle* key, const RecMdcTrack* value );
  
  // store list of McParticles corresponding given MdcTrack
  void addLink( const RecMdcTrack* key, const Event::McParticle* value );
  
  // store list of MdcKalTracks corresponding given McParticle
  void addLink( const Event::McParticle* key, const RecMdcKalTrack* value );
  
  // store list of McParticles corresponding given MdcKalTrack
  void addLink( const RecMdcKalTrack* key, const Event::McParticle* value );

  // store list of McParticles corresponding given EmcRecShower
  void addLink( const RecEmcShower* key, const Event::McParticle* value );
  
  // store list of EmcShowers corresponding given McParticle
  void addLink( const Event::McParticle* key, const RecEmcShower* value );
  
 private:
  // === lookup maps of id->objPtr relations ===
  std::map <int, const Event::McParticle*> m_mcParticleId;

  // MDC info
  std::map <int, const RecMdcTrack*>  m_mdcTrackId;
  std::map <int, const RecMdcKalTrack*>  m_mdcKalTrackId;
  std::map <int, const MdcDigi*>   m_mdcDigiId;
  std::multimap <unsigned int, const Event::MdcMcHit*>  m_mdcMcHitId;
  std::map <unsigned int, const RecMdcHit*> m_mdcRecHitId;

  // ===== relations =====
  // relation tables to be returned by query
  std::map <int, RecMdcTrackVector>  m_mdcTracksWrtMcParticle;
  std::map <int, McParticleVector>   m_mcParticlesWrtMdcTrack;
  std::map <int, RecMdcKalTrackVector>  m_mdcKalTracksWrtMcParticle;
  std::map <int, McParticleVector>   m_mcParticlesWrtMdcKalTrack;

  // internal version of relation tables to keep number of the same hits for each pair McParticle-MdcTrack
  std::map <int, RecMdcTrackVectorP>    m_mdcTracksWrtMcParticleP;
  std::map <int, McParticleVectorP>     m_mcParticlesWrtMdcTrackP;
  std::map <int, RecMdcKalTrackVectorP> m_mdcKalTracksWrtMcParticleP;
  std::map <int, McParticleVectorP>     m_mcParticlesWrtMdcKalTrackP;
 
  // EMC info
  std::multimap <unsigned int, const RecEmcShower*>  m_emcRecShowerId;
  std::multimap <unsigned int, const Event::EmcMcHit*>      m_emcMcHitId;

  // ===== relations =====
  std::map <int, McParticleVector>      m_mcParticlesWrtRecShower;
  std::map <int, RecEmcShowerVector>    m_emcRecShowersWrtMcHit;
  std::map <int, RecEmcShowerVector>    m_emcRecShowersWrtMcParticle;
  std::map <int, EmcMcHitVector>        m_emcMcHitsWrtRecShower;
  // internal version of relation tables to keep number of the same hits for each pair McParticle-EmcRecShower
  std::map <int, RecEmcShowerVectorP>   m_emcRecShowersWrtMcParticleP;
  std::map <int, McParticleVectorP>     m_mcParticlesWrtRecEmcShowerP;

  // persistency
  IndexMap m_mcMdcTracksIdx; // id is the same for RecMdcTrack and RecMdcKalTrack
  IndexMap m_mcMdcMcHitsIdx;
  IndexMap m_mcEmcRecShowersIdx;
  IndexMap m_mcEmcMcHitsIdx;

  int m_mdcCut;
};

#endif    // EventNavigator_H

---