LcioManager.hh

Go to the documentation of this file.

// $Header: /cvs/lcd/slic/include/LcioManager.hh,v 1.56 2007/04/27 01:54:32 jeremy Exp $

#ifndef SLIC_LCIOMANAGER_HH
#define SLIC_LCIOMANAGER_HH 1

// lcdd
#include "G4SensitiveDetector.hh"
#include "G4CalorimeterHit.hh"
#include "G4TrackerHit.hh"

// slic
#include "LcioPrimaryGenerator.hh"
#include "LcioMcpManager.hh"
#include "LcioHitsCollectionBuilder.hh"
#include "LcioFileNamer.hh"
#include "Trajectory.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;
class G4TrajectoryContainer;

namespace slic
{

  class LcioMessenger;

  class LcioManager : public Module, public Singleton<LcioManager>
  {

  public:

    enum EFileExistsAction {
      eInvalid = -1,
      eFail = 0,
      eDelete = 1,
      eAppend = 2
    };

    typedef unsigned int RunNumberType;

  public:
    virtual ~LcioManager();

    //static LcioManager* instance();

    LcioManager();

  public:

    // open file from mvar vals
    void openLcioFile();

    // path and filename
    void setPath(const std::string& path);
    void setFilename(const std::string& filename);
    void setAutonameFields(const std::vector<std::string>& fields);

    const std::string& getPath() const;
    const std::string& getFilename() const;

    // get path + filename; arg == true to include ".slcio" extension
    std::string getFullOutputPath(bool withExtension = false);

    // convert to file exists setting from a string
    static EFileExistsAction getFileExistsActionFromString( const std::string& fea);

    void setRunNumber(RunNumberType rnt);
    const int getRunNumber();

    // run actions
    void beginRun( const G4Run* );
    void endRun( const G4Run* );

    // create the LCEvent
    IMPL::LCEventImpl* createLCEvent(const G4Event* anEvent);
    IMPL::LCEventImpl* createLCEvent();

    // create Mcp coll
    void createFinalMcpCollection();

    void addCollection( EVENT::LCEvent*, EVENT::LCCollection*, const std::string& );

    void addCollection( EVENT::LCCollection*, const std::string& );
    
    void addInitialMCParticleCollection();

    // formerly writeEvent()
    void endEvent(const G4Event* anEvent);

    // set the current LCEvent
    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 LcioPrimaryGenerator* getGenerator()
    {
      return m_eventGenerator;
    }

    inline LcioMcpManager* getMcpManager()
    {
      return m_mcpManager;
    }

    inline LcioHitsCollectionBuilder* getHCBuilder()
    {
      return m_HCBuilder;
    }

    inline LcioFileNamer* getFileNamer()
    {
      return m_namer;
    }

    void enableDumpEvent(bool p = true)
    {
      m_enableDumpEvent = p;
    }

  private:

    void makeAutoname();

    // add HCs using builder and current ptrs
    void createHitsCollections();

    // LCWriter
    void createWriter();
    void deleteWriter();

    // run header
    void createRunHeader(const G4Run*);
    void deleteRunHeader();

    // set detector tag in LCIO output header
    void setDetectorName();

    // set timestamp
    void setEventTimeStamp();

    // add actives detectors from LCDD parser into the LCIO header
    void addActiveSubdetectors();

    // reset cached instance vars
    void reset();

  private:

    // final Mcp collection with all info from McpInitial, Trajectories, Primaries
    IMPL::LCCollectionVec* m_McpFinalColl;

    // writer
    IO::LCWriter* m_writer;

    // run header
    IMPL::LCRunHeaderImpl* m_runHdr;

    // file info
    std::string m_filename;
    std::string m_path;

    // Mcp manager
    LcioMcpManager* m_mcpManager;

    // event generator from MCP Coll
    LcioPrimaryGenerator* m_eventGenerator;

    // creation of HCs
    LcioHitsCollectionBuilder* m_HCBuilder;

    // current LCEvent
    IMPL::LCEventImpl* m_currentLCEvent;

    // messenger
    LcioMessenger* m_messenger;

    // action when file exists
    EFileExistsAction m_fileExistsAction;

    // starting run number
    RunNumberType 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 m_abortCurrentRun;    
  };
}

#endif

---