EventSourceManager.hh

Go to the documentation of this file.

#ifndef SLIC_EVENTSOURCEMANAGER_HH_
#define SLIC_EVENTSOURCEMANAGER_HH_ 1
 
// SLIC
#include "Module.hh"
#include "EventSource.hh"
#include "EventSourceWithInputFile.hh"
#include "GPSEventSource.hh"
#include "ParticleGunEventSource.hh"
#include "GeneratorMessenger.hh"
#include "Singleton.hh"
 
// Geant4
#include "G4VPrimaryGenerator.hh"
#include "G4GeneralParticleSource.hh"
#include "G4ParticleGun.hh"
#include "G4UnitsTable.hh"
 
namespace slic {
 
class EventSourceManager: public Module, public Singleton<EventSourceManager> {
 
    public:
 
        enum ESourceType {
            eUnknown = 0, eStdHep, eLCIO, eGPS, eParticleGun, eLHE
        };
 
    public:
 
        virtual ~EventSourceManager();
 
        EventSourceManager();
 
    public:
 
        void setSourceType(ESourceType est);
 
        void setSourceType(const std::string& s);
 
        ESourceType getCurrentSourceType();
 
        ESourceType getSourceTypeFromFileExtension(const std::string& ext);
 
        const std::string& getCurrentSourceName();
 
        const std::string& getSourceNameFromType(ESourceType egt) const;
 
        ESourceType getSourceTypeFromName(const std::string& name) const;
 
        const std::string& getFilename();
 
        void setFilename(const std::string& fileName);
 
        void setupEventSource();
 
        void resetCurrentEventSource();
 
        void setSkipEvents(unsigned int n);
 
        unsigned int getSkipEvents();
 
        void dumpCurrentEvent();
 
        void printNumEventsGenerated();
 
        int getNumEventsGenerated();
 
        void incrNumEventsGenerated();
 
        void generate(G4Event* event);
 
        void setEventSource(EventSource* eventSource);
 
        void deleteCurrentEventSource();
 
        EventSource* createEventSource(ESourceType st);
 
        EventSource* getCurrentSource();
 
        void setupEventSource(ESourceType sourceType);
 
        void setupEventSource(const std::string& sourceType);
 
        void beginEvent(const G4Event* event);
 
        void endEvent(const G4Event* event);
 
        void beginRun(const G4Run* run);
 
        void endRun(const G4Run* run);
 
        bool isEOF();
 
        bool isNewSource();
 
        bool isNewSource(ESourceType est);
 
        bool isNewFilename();
 
        bool isFileSource();
 
        EventSourceWithInputFile* getFileSource();
 
        G4GeneralParticleSource* getGPS();
 
        G4ParticleGun* getParticleGun();
 
        double getLorentzTransformationAngle() {
            return m_lorentzTransformationAngle;
        }
 
        void setLorentzTransformationAngle(const G4double angle);
 
        void setZSmearing(const G4double zSmear) {
            m_zSmearingParam = zSmear;
            G4cout << "Set m_zSmearingParam = " << m_zSmearingParam << G4endl;
        }
 
        G4double getZSmearing() {
            return m_zSmearingParam;
        }
 
        void enablePrintEvent(G4bool enable) {
            m_enablePrintEvent = enable;
        }
 
    public:
 
        void generateNextEvent(G4Event* evt);
 
    private:
 
        GeneratorMessenger* m_messenger;
 
        EventSource* m_currentEventSource;
 
        EventSource* m_particleGunSource;
 
        // filename
        std::string m_filename;
        bool m_fileIsSet;
        bool m_newFilename;
 
        int m_ngen;
 
        unsigned int m_nskip;
 
        bool m_newSource;
 
        // gen strings
        static std::string STDHEP;
        static std::string LCIO;
        static std::string GPS;
        static std::string PARTICLE_GUN;
        static std::string LHE;
        static std::string UNKNOWN;
 
        ESourceType m_sourceType;
 
        G4double m_lorentzTransformationAngle;
 
        G4double m_zSmearingParam;
 
        G4bool m_enablePrintEvent;
 
};
}
 
#endif