G4Svc.h

Go to the documentation of this file.

#ifndef G4SIM_G4SVC_H
#define G4SIM_G4SVC_H
 
#include "G4Svc/IG4Svc.h"
#include "GaudiKernel/NTuple.h"
#include "GaudiKernel/Service.h"
 
// G4 includes
#include "G4UImanager.hh"
 
#ifdef G4VIS_USE
#  include "G4VisManager.hh"
#endif
 
#include "RealizationSvc/IRealizationSvc.h"
#include <string>
#include <vector>
 
// Forward declarations
template <class TYPE> class SvcFactory;
 
class G4VUserPhysicsList;
class G4RunManager;
class G4SvcRunManager;
class G4VUserActionInitialization;
 
// ClassName:   G4Svc
// Description: This service provides access to Geant 4
//
 
class G4Svc : public extends<Service, IG4Svc> {
public:
  G4Svc( const std::string& name, ISvcLocator* svc );
 
  // Destructor.
  virtual ~G4Svc();
 
  virtual StatusCode initialize();
  virtual StatusCode finalize();
 
  // Query the interfaces.
  // virtual StatusCode queryInterface( const InterfaceID& riid, void** ppvInterface );
 
  G4RunManager* runMgr();
 
  // Detector init
  void SetUserInitialization( G4VUserDetectorConstruction* userInit );
 
  // Physics init
  void SetUserInitialization( G4VUserPhysicsList* physInit );
 
  void SetUserInitialization( G4VUserActionInitialization* actionInit );
 
  // User Action
  /*void SetUserAction(G4UserRunAction *);
  void SetUserAction(G4UserEventAction *);
  void SetUserAction(G4VUserPrimaryGeneratorAction*);
  void SetUserAction(G4UserStackingAction*);
  void SetUserAction(G4UserTrackingAction*);
  void SetUserAction(G4UserSteppingAction*);*/
 
  // G4Event
  const G4Event* GetCurrentEvent() const;
  const G4Run*   GetCurrentRun() const;
 
#ifdef G4VIS_USE
  G4VisManager* visMgr() { return p_visMgr; }
#endif
  G4UImanager* uiMgr();
  void         StartUISession();
 
  // for vertex parameters
  double GetBeamPosX() { return m_beamPosX; }
  double GetBeamPosY() { return m_beamPosY; }
  double GetBeamPosZ() { return m_beamPosZ; }
 
  double GetBeamSizeX() { return m_beamSizeX; }
  double GetBeamSizeY() { return m_beamSizeY; }
  double GetBeamSizeZ() { return m_beamSizeZ; }
 
  double GetBeamShiftPx() { return m_beamShiftPx; }
  double GetBeamShiftPy() { return m_beamShiftPy; }
  double GetBeamShiftPz() { return m_beamShiftPz; }
 
  double GetBeamStartTime() { return m_beamStartTime; }
  double GetBeamDeltaTime() { return m_beamDeltaTime; }
  double GetNBunch() { return m_nBunch; }
  double GetBunchTimeSigma() { return m_bunchTimeSigma; }
 
  double      GetBeamTime() { return m_beamTime; }
  void        SetBeamTime( double value ) { m_beamTime = value; }
  std::string GetMdcNoiseFile() { return m_mdcNoiseFile; }
 
  double GetBeamAngle() { return m_beamAngle; }
  bool   GetBoostLab() { return m_boostLab; }
  bool   GetSetBeamShift() { return m_setBeamShift; }
 
  int GetMdcDataInput() { return m_mdcDataInput; }
  int GetMdcDedxFlag() { return m_mdcDedxFlag; }
  int GetMdcNewSimOpt() { return m_mdcNewSimOpt; }
 
  NTuple::Tuple* GetTupleMdc() { return m_tupleMdc; }
  void           SetTupleMdc( NTuple::Tuple* tuple ) { m_tupleMdc = tuple; }
 
  NTuple::Tuple* GetTupleTof1() { return m_tupleTof1; }
  void           SetTupleTof1( NTuple::Tuple* tuple ) { m_tupleTof1 = tuple; }
 
  NTuple::Tuple* GetTupleTof2() { return m_tupleTof2; }
  void           SetTupleTof2( NTuple::Tuple* tuple ) { m_tupleTof2 = tuple; }
 
  NTuple::Tuple* GetTupleTof3() { return m_tupleTof3; }
  void           SetTupleTof3( NTuple::Tuple* tuple ) { m_tupleTof3 = tuple; }
 
  NTuple::Tuple* GetTupleEmc1() { return m_tupleEmc1; }
  void           SetTupleEmc1( NTuple::Tuple* tuple ) { m_tupleEmc1 = tuple; }
 
  NTuple::Tuple* GetTupleEmc2() { return m_tupleEmc2; }
  void           SetTupleEmc2( NTuple::Tuple* tuple ) { m_tupleEmc2 = tuple; }
 
  NTuple::Tuple* GetTupleMuc() { return m_tupleMuc; }
  void           SetTupleMuc( NTuple::Tuple* tuple ) { m_tupleMuc = tuple; }
 
  bool MdcRootFlag() { return m_mdcRootFlag; }
  bool TofRootFlag() { return m_tofRootFlag; }
  bool EmcRootFlag() { return m_emcRootFlag; }
  bool MucRootFlag() { return m_mucRootFlag; }
 
  bool TofSaturationFlag() { return m_tofSaturationFlag; } // Tof Q Saturation in bhabha events
 
  bool   EmcLightOutput() { return m_emcLightOutput; }
  double EmcIncoherentNoise() { return m_emcIncoherentNoise; }
  double EmcCoherentNoise() { return m_emcCoherentNoise; }
  double EmcNoiseMean() { return m_emcNoiseMean; }
  double EmcNoiseSigma() { return m_emcNoiseSigma; }
  double EmcNoiseThreshold() { return m_emcNoiseThreshold; }
  int    EmcNoiseLevel() { return m_emcNoiseLevel; }
  int    EmcTime() { return m_emcTime; }
  int    EmcElecSaturation() { return m_emcELecSaturation; }
  int    EmcElecSatuDead() { return m_emcELecSatuDead; }
 
  int MucNoiseMode() { return m_mucNoiseMode; }
 
  int LogLevel() { return m_logLevel; }
 
public:
  void G4Init();
 
  // Run initialization, termination and single event generation for G4SimAlg
  void RunInitialize();
  void RunTerminate();
  void SimulateEvents( int );
 
private:
  // Allow SvcFactory to instantiate the service.
  friend class SvcFactory<G4Svc>;
 
  G4SvcRunManager* p_runMgr;
  G4UImanager*     p_uiMgr;
 
  // std::string m_PhysicsList;
  // double m_PhysicsCut;
 
  // Visualization
  bool m_vis;
  // std::string m_visType;
 
  // Initialization macro file
 
  std::string m_macroName;
  std::string m_mdcNoiseFile;
 
#ifdef G4VIS_USE
  G4VisManager* p_visMgr;
#endif
 
  // Save Hits and Tracks in StoreGate
  // bool m_saveHits;
  // bool m_saveTracks;
  int m_logLevel;
 
  // Verbosity
  int m_runVerb;
  int m_eventVerb;
  int m_trackVerb;
 
  bool _init;
 
  bool m_interactiveG4;
 
  bool m_besGenAction;
 
  int m_runID;
 
  int m_mdcDataInput;
  int m_mdcDedxFlag;
  int m_mdcNewSimOpt; // (0:Old MdcSim, 1:New) liaoyp -- 2023.10.30
 
  // vertex parameters
  double m_beamPosX;
  double m_beamPosY;
  double m_beamPosZ;
 
  double m_beamSizeX;
  double m_beamSizeY;
  double m_beamSizeZ;
 
  double m_beamStartTime;
  double m_beamDeltaTime;
  double m_nBunch;
 
  double m_bunchTimeSigma;
  double m_beamTime;
 
  double m_beamShiftPx;
  double m_beamShiftPy;
  double m_beamShiftPz;
 
  bool   m_boostLab;
  bool   m_setBeamShift;
  double m_beamAngle;
 
  // MC Monitor
  NTuple::Tuple* m_tupleMdc;
  bool           m_mdcRootFlag;
 
  NTuple::Tuple* m_tupleTof1;
  NTuple::Tuple* m_tupleTof2;
  NTuple::Tuple* m_tupleTof3;
  bool           m_tofRootFlag;
  bool           m_tofSaturationFlag;
 
  NTuple::Tuple* m_tupleEmc1; // digi level
  NTuple::Tuple* m_tupleEmc2; // event level
  bool           m_emcRootFlag;
 
  // Emc Crystal Light Output
  bool m_emcLightOutput;
  // Incoherent Noise
  double m_emcIncoherentNoise;
  // Coherent Noise
  double m_emcCoherentNoise;
  // Noise for fast simulation
  double m_emcNoiseMean;
  double m_emcNoiseSigma;
  // Only energy above noise threshold will be recorded
  double m_emcNoiseThreshold;
  // Noise Level:
  // 0: No noise, 1: Only singal crystals have noise,
  // 2: Only 5x5 matrix has noise, 3: All noise.
  int m_emcNoiseLevel;
  // Time
  int m_emcTime;
  // MC electronics saturation of crystal:
  // 0:using Bhabha calibration constants;
  // 1:using EmaxData from data;
  int m_emcELecSaturation;
 
  // MC Special dead channel of electronics saturation of crystal:
  // 0:without the simulation Special dead channel in MC ;
  // 1:with the simulation Special dead channel in MC ;
  int m_emcELecSatuDead;
 
  // Muc noise mode
  int m_mucNoiseMode;
 
  NTuple::Tuple* m_tupleMuc;
  bool           m_mucRootFlag;
 
  IRealizationSvc* m_RealizationSvc;
};
 
#endif