MCParticleManager.hh

Go to the documentation of this file.

#ifndef SLIC_MCPARTICLE_MANAGER_HH_
#define SLIC_MCPARTICLE_MANAGER_HH_ 1
 
// SLIC
#include "Module.hh"
#include "Singleton.hh"
 
// LCIO
#include "EVENT/LCCollection.h"
#include "IMPL/LCCollectionVec.h"
#include "IMPL/MCParticleImpl.h"
#include "EVENT/MCParticle.h"
 
// Geant4
#include "globals.hh"
#include "G4Event.hh"
#include "G4PrimaryParticle.hh"
 
// STL
#include <map>
#include <set>
 
using std::map;
using std::set;
 
using EVENT::LCCollection;
using EVENT::MCParticle;
using IMPL::MCParticleImpl;
using IMPL::LCCollectionVec;
 
namespace slic {
 
typedef map<G4int, MCParticle*> TrackIDMap;
typedef map<MCParticle*, G4PrimaryParticle*> PrimaryParticleMap;
typedef map<G4PrimaryParticle*, MCParticle*> MCParticleMap;
typedef PrimaryParticleMap::iterator PrimaryParticleMapIterator;
typedef set<MCParticle*> MCParticleSet;
 
class MCParticleManager: public Singleton<MCParticleManager>, Module {
 
    public:
 
        MCParticleManager() :
                Module("MCParticleManager"), _mcpVec(0) {
        }
 
        virtual ~MCParticleManager() {
        }
 
        LCCollectionVec* getMCParticleCollection() {
            return _mcpVec;
        }
 
        void addMCParticleTrackID(G4int trackId, MCParticle* particle) {
            if (trackId <= 0) {
                return;
            }
            _trackIDMap[trackId] = particle;
        }
 
        MCParticle* findMCParticle(G4int trackId) {
            return _trackIDMap[trackId];
        }
 
        PrimaryParticleMap* getPrimaryParticleMap() {
            return &_primaryMap;
        }
 
        void reset() {
            _trackIDMap.clear();
            _primaryMap.clear();
            _mcpMap.clear();
            _mcpVec = 0;
        }
 
        void createMCParticleCollection() {
            if (_mcpVec == 0) {
                _mcpVec = new LCCollectionVec(EVENT::LCIO::MCPARTICLE);
            }
        }
 
        inline int indexOf(MCParticle* particle) {
            return std::find(_inputVec->begin(), _inputVec->end(), particle) - _inputVec->begin();
        }
 
        inline int indexOf(G4PrimaryParticle* primary) {
            return std::find(_primaryVec.begin(), _primaryVec.end(), primary) - _primaryVec.begin();
        }
 
        void generateEvent(LCCollectionVec* mcparticles, G4Event* event);
 
        void applyLorentzTransformation(LCCollection* mcparticles, const G4double angle);
 
        G4double smearZPosition(const G4double rms);
 
        std::set<G4PrimaryParticle*> createPrimary(G4PrimaryParticle* parent, MCParticle* mcp);
 
        G4PrimaryVertex* createVertex(MCParticle* mcp);
 
        bool isDaughter(G4PrimaryParticle* particle, const std::set<G4PrimaryParticle*>& primaries);
 
    private:
 
        void setMCParticleCollection(LCCollectionVec* mcpVec) {
            _mcpVec = mcpVec;
        }
 
    private:
 
        PrimaryParticleMap _primaryMap;
 
        MCParticleMap _mcpMap;
 
        TrackIDMap _trackIDMap;
 
        LCCollectionVec* _inputVec;
 
        LCCollectionVec* _mcpVec;
 
        std::vector<G4PrimaryParticle*> _primaryVec;
};
 
}
 
#endif