Simulation/BOOST/TruSim/include/TruSim/BesSensitiveManager.hh

Go to the documentation of this file.

//---------------------------------------------------------------------------//
////////      BOOST --- BESIII Object_Oriented Simulation Tool                     //
////////---------------------------------------------------------------------------//
////////Description:
////////Author : Dengzy
////
//// ////Created:  Aug, 2004
//// ////Modified:
//// ////Comment:
//// ////---------------------------------------------------------------------------//
//// //// $Id: BesSensitiveManager.hh
 
#ifndef BesSensitiveManager_hh
#define BesSensitiveManager_hh
 
#include "BesSensitiveDetector.hh"
#include "G4TrackingManager.hh"
#include "HepMC/GenEvent.h"
#include "globals.hh"
 
class G4Svc;
 
class G4VProcess;
class G4Track;
class G4Event;
 
class BesTruthVertex;
class BesTruthTrack;
// Since G4 lacks a "permanent stack" feature like GEANT3,
// we need to keep track of the complete parentage of particles
 
class BesTStats {
 
  friend class BesSensitiveManager;
 
public:
  BesTStats()
      : G4index( -1 )
      , p4( 0 )
      , time( 0 )
      , trackIndex( -1 )
      , originVertex( -1 )
      , savedByDefault( false )
      , vertices( 0 ) {
    ;
  }
  BesTStats( const G4int index, const CLHEP::HepLorentzVector theP4, G4double theTime )
      : G4index( index )
      , p4( theP4 )
      , time( theTime )
      , trackIndex( -1 )
      , originVertex( -1 )
      , savedByDefault( false )
      , vertices( 0 ) {
    ;
  }
  ~BesTStats() { ; }
 
  bool operator==( const BesTStats& other ) const { return G4index == other.G4index; }
 
private:
  G4int                   G4index;        // Index as in G4Track::fTrackID
  CLHEP::HepLorentzVector p4;             // 4-Momentum at origin
  G4double                time;           // Global time at origin
  G4int                   trackIndex;     // Index into trackList, or -1 if no such
  G4int                   originVertex;   // Index into vertexList of origin vertex
  bool                    savedByDefault; // True if saved to BesTruthTrack by default
 
  // A list of vertices (index into vertexList)
  // associated with an interaction
  // of this track.
  std::vector<int> vertices;
};
 
class BesSensitiveManager {
public:
  BesSensitiveManager() : m_trackIndex( -1 ), m_trackFlag( 0 ), m_count( 0 ) {
    m_hepmcevt = 0;
    if ( m_sensitiveManager ) G4cout << "BesSensitiveManager constructed twice." << G4endl;
    m_sensitiveManager = this;
  }
 
  ~BesSensitiveManager() { ; }
 
  static BesSensitiveManager* GetSensitiveManager() { return m_sensitiveManager; }
 
  // Add a new client
  void AddSensitiveDetector( BesSensitiveDetector* detector ) {
    clients.push_back( detector );
  }
 
  G4int                         GetCurrentTrackIndex() const { return m_trackIndex; }
  std::vector<BesTruthTrack*>*  GetTrackList() { return m_trackList; }
  std::vector<BesTruthVertex*>* GetVertexList() { return m_vertexList; }
 
  // Take care of things at the beginning and end
  // of event, including dumping all required stuff
  // at the end of the event
  void BeginOfTruthEvent( const G4Event* );
  void EndOfTruthEvent( const G4Event* );
 
  G4int  CheckType( const HepMC::GenEvent* hepmcevt );
  void   SaveParticlesFromGenerator();
  void   SetVertex0( const G4Event* );
  void   UpdatePrimaryTrack( const G4Track* );
  G4bool CheckDecayTrack( const G4Track* );
  void   UpdateVertex( BesTStats, const G4Track* );
  G4bool MatchDaughterTrack( const G4Track* );
  void   GetDaughterVertexes( BesTruthTrack* pTrack, std::vector<int>* vDau );
  G4bool MatchVertex( G4int vIndex, std::vector<int>* vDau );
 
  // Take care of things at the beginning and end
  // of tracks
  void BeginOfTrack( const G4Track* track );
  void EndOfTrack( const G4Track* track, G4TrackingManager* );
 
  // Find out how many tracks and vertices we have
  G4int GetNumberTracks() const { return m_trackList ? m_trackList->size() : 0; }
  G4int GetNumberVertices() const { return m_vertexList ? m_vertexList->size() : 0; }
 
  void ClearEvent();
 
  void SetLogLevel( G4int level ) { m_logLevel = level; }
 
protected:
  static BesSensitiveManager* m_sensitiveManager;
 
  std::vector<BesSensitiveDetector*>::iterator iter;
  std::vector<BesSensitiveDetector*>::iterator iter_end;
 
  // Current track indices
  G4int m_trackIndex;
  G4int m_trackFlag;
 
  // The following are the BesTruthTrack, BesTruthVertex
  // lists. Don't forget to delete them at the end of the event.
  std::vector<BesTruthTrack*>*  m_trackList;
  std::vector<BesTruthVertex*>* m_vertexList;
 
  // Here is a list of clients. Note that
  // these objects are decendents of G4VSensitiveDetector
  // and are thus owned by GEANT4. We must not delete
  // them ourselves!
  std::vector<BesSensitiveDetector*> clients;
 
  std::vector<BesTStats> chain; // Stats on the decay chain
 
  // Make a new TruthTrack (and TruthVertex if necessary)
  void MakeNewTrack( BesTStats& stat, const G4Track* track );
 
  // Update trackList, vertexList, for a new track, and return the new track's stats
  BesTStats FollowTrack( const G4Track* track );
 
  // this data member is set for recording trackIndex
  G4int m_count;
 
  G4ThreeVector m_pos0;
  G4double      m_t0;
 
  G4int            m_logLevel;
  HepMC::GenEvent* m_hepmcevt;
};
 
#endif