LcioManager.hh

Go to the documentation of this file.

#ifndef SLIC_LCIOMANAGER_HH_
#define SLIC_LCIOMANAGER_HH_ 1
 
// lcdd
#include "lcdd/detectors/SensitiveDetector.hh"
#include "lcdd/hits/CalorimeterHit.hh"
#include "lcdd/hits/TrackerHit.hh"
 
// slic
#include "LcioHitsCollectionBuilder.hh"
#include "LcioFileNamer.hh"
#include "Singleton.hh"
 
// lcio
#include "IO/LCWriter.h"
#include "EVENT/MCParticle.h"
#include "IMPL/SimCalorimeterHitImpl.h"
#include "IMPL/SimTrackerHitImpl.h"
#include "IMPL/LCCollectionVec.h"
#include "IMPL/LCEventImpl.h"
#include "IMPL/LCRunHeaderImpl.h"
#include "IMPL/MCParticleImpl.h"
 
// geant4
#include "G4Event.hh"
#include "G4PrimaryParticle.hh"
 
// std
#include <string>
#include <map>
 
class G4Run;
class G4VHitsCollection;
 
namespace slic {
 
class LcioMessenger;
 
class LcioManager: public Module, public Singleton<LcioManager> {
 
    public:
 
        enum EFileExistsAction {
            eInvalid = -1, eFail = 0, eDelete = 1, eAppend = 2
        };
 
    public:
 
        LcioManager();
 
        virtual ~LcioManager();
 
    public:
 
        void openLcioFile();
 
        void setPath(const std::string& path);
 
        void setFilename(const std::string& filename);
 
        void setAutonameFields(const std::vector<std::string>& fields);
 
        std::string getFullOutputPath(bool withExtension = false);
 
        static EFileExistsAction getFileExistsActionFromString(const std::string& fileExists);
 
        void setRunNumber(int runNumber);
 
        void beginRun(const G4Run* run);
 
        void endRun(const G4Run* run);
 
        IMPL::LCEventImpl* createLCEvent(const G4Event* anEvent);
 
        IMPL::LCEventImpl* createLCEvent();
 
        void addCollection(EVENT::LCEvent* lcevent, EVENT::LCCollection* collection, const std::string& name);
 
        void addCollection(EVENT::LCCollection* collection, const std::string& name);
 
        void endEvent(const G4Event* anEvent);
 
        void setCurrentLCEvent(IMPL::LCEventImpl* anLCEvent) {
            m_currentLCEvent = anLCEvent;
        }
 
        IMPL::LCEventImpl* getCurrentLCEvent() {
            return m_currentLCEvent;
        }
 
        void setStoreMomentum(bool s = true) {
            m_HCBuilder->setStoreMomentum(s);
        }
 
        void setFileExistsAction(EFileExistsAction fea) {
            if (fea == eInvalid) {
#ifdef SLIC_LOG
                log() << LOG::error << "Invalid setting for FileExistsAction." << LOG::done;
#endif
                return;
            }
 
            m_fileExistsAction = fea;
        }
 
        EFileExistsAction getFileExistsAction() {
            return m_fileExistsAction;
        }
 
        inline LcioHitsCollectionBuilder* getHitsCollectionBuilder() {
            return m_HCBuilder;
        }
 
        inline LcioFileNamer* getFileNamer() {
            return m_namer;
        }
 
        void enableDumpEvent(bool p = true) {
            m_enableDumpEvent = p;
        }
 
        void setWriteCompleteEvent(G4bool writeCompleteEvent) {
            _writeCompleteEvent = writeCompleteEvent;
        }
 
        G4bool getWriteCompleteEvent() {
            return _writeCompleteEvent;
        }
 
    private:
 
        void makeAutoname();
 
        void createHitsCollections();
 
        void createWriter();
 
        void deleteWriter();
 
        void createRunHeader(const G4Run* run);
 
        void deleteRunHeader();
 
        void setDetectorName();
 
        void setEventTimeStamp();
 
        void addActiveSubdetectors();
 
    private:
 
        IO::LCWriter* m_writer;
 
        IMPL::LCRunHeaderImpl* m_runHdr;
 
        std::string m_filename;
        std::string m_path;
 
        // event generator from MCP Coll
        //LcioPrimaryGenerator* m_eventGenerator;
 
        LcioHitsCollectionBuilder* m_HCBuilder;
 
        IMPL::LCEventImpl* m_currentLCEvent;
 
        // messenger
        LcioMessenger* m_messenger;
 
        EFileExistsAction m_fileExistsAction;
 
        int m_runNumber;
 
        LcioFileNamer* m_namer;
 
        static std::string m_defaultFileName;
        std::vector<std::string> m_currentAutonameFields;
 
        bool m_enableDumpEvent;
        bool m_writerIsOpen;
        bool m_usingAutoname;
        bool _writeCompleteEvent;
};
}
 
#endif