Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

G4Svc Class Reference

#include <G4Svc.h>

Inheritance diagram for G4Svc:

IG4Svc IG4Svc List of all members.

Public Member Functions

double EmcCoherentNoise ()
double EmcCoherentNoise ()
double EmcIncoherentNoise ()
double EmcIncoherentNoise ()
bool EmcLightOutput ()
bool EmcLightOutput ()
int EmcNoiseLevel ()
int EmcNoiseLevel ()
double EmcNoiseMean ()
double EmcNoiseMean ()
double EmcNoiseSigma ()
double EmcNoiseSigma ()
double EmcNoiseThreshold ()
double EmcNoiseThreshold ()
bool EmcRootFlag ()
bool EmcRootFlag ()
int EmcTime ()
int EmcTime ()
virtual StatusCode finalize ()
virtual StatusCode finalize ()
void G4Init ()
void G4Init ()
double GetBeamAngle ()
double GetBeamAngle ()
double GetBeamDeltaTime ()
double GetBeamDeltaTime ()
double GetBeamPosX ()
double GetBeamPosX ()
double GetBeamPosY ()
double GetBeamPosY ()
double GetBeamPosZ ()
double GetBeamPosZ ()
double GetBeamShiftPx ()
double GetBeamShiftPx ()
double GetBeamShiftPy ()
double GetBeamShiftPy ()
double GetBeamShiftPz ()
double GetBeamShiftPz ()
double GetBeamSizeX ()
double GetBeamSizeX ()
double GetBeamSizeY ()
double GetBeamSizeY ()
double GetBeamSizeZ ()
double GetBeamSizeZ ()
double GetBeamStartTime ()
double GetBeamStartTime ()
double GetBeamTime ()
double GetBeamTime ()
bool GetBoostLab ()
bool GetBoostLab ()
double GetBunchTimeSigma ()
double GetBunchTimeSigma ()
const G4Event * GetCurrentEvent () const
const G4Event * GetCurrentEvent () const
const G4Run * GetCurrentRun () const
const G4Run * GetCurrentRun () const
int GetMdcDataInput ()
int GetMdcDataInput ()
int GetMdcDedxFlag ()
int GetMdcDedxFlag ()
std::string GetMdcNoiseFile ()
std::string GetMdcNoiseFile ()
double GetNBunch ()
double GetNBunch ()
bool GetSetBeamShift ()
bool GetSetBeamShift ()
NTuple::Tuple * GetTupleEmc1 ()
NTuple::Tuple * GetTupleEmc1 ()
NTuple::Tuple * GetTupleEmc2 ()
NTuple::Tuple * GetTupleEmc2 ()
NTuple::Tuple * GetTupleMdc ()
NTuple::Tuple * GetTupleMdc ()
NTuple::Tuple * GetTupleMuc ()
NTuple::Tuple * GetTupleMuc ()
NTuple::Tuple * GetTupleTof1 ()
NTuple::Tuple * GetTupleTof1 ()
NTuple::Tuple * GetTupleTof2 ()
NTuple::Tuple * GetTupleTof2 ()
NTuple::Tuple * GetTupleTof3 ()
NTuple::Tuple * GetTupleTof3 ()
virtual StatusCode initialize ()
virtual StatusCode initialize ()
int LogLevel ()
int LogLevel ()
bool MdcRootFlag ()
bool MdcRootFlag ()
int MucNoiseMode ()
int MucNoiseMode ()
bool MucRootFlag ()
bool MucRootFlag ()
virtual StatusCode queryInterface (const InterfaceID &riid, void **ppvInterface)
virtual StatusCode queryInterface (const InterfaceID &riid, void **ppvInterface)
void RunInitialize ()
void RunInitialize ()
G4RunManager * runMgr ()
G4RunManager * runMgr ()
void RunTerminate ()
void RunTerminate ()
void SetBeamTime (double value)
void SetBeamTime (double value)
void SetTupleEmc1 (NTuple::Tuple *tuple)
void SetTupleEmc1 (NTuple::Tuple *tuple)
void SetTupleEmc2 (NTuple::Tuple *tuple)
void SetTupleEmc2 (NTuple::Tuple *tuple)
void SetTupleMdc (NTuple::Tuple *tuple)
void SetTupleMdc (NTuple::Tuple *tuple)
void SetTupleMuc (NTuple::Tuple *tuple)
void SetTupleMuc (NTuple::Tuple *tuple)
void SetTupleTof1 (NTuple::Tuple *tuple)
void SetTupleTof1 (NTuple::Tuple *tuple)
void SetTupleTof2 (NTuple::Tuple *tuple)
void SetTupleTof2 (NTuple::Tuple *tuple)
void SetTupleTof3 (NTuple::Tuple *tuple)
void SetTupleTof3 (NTuple::Tuple *tuple)
void SetUserAction (G4UserSteppingAction *)
void SetUserAction (G4UserTrackingAction *)
void SetUserAction (G4UserStackingAction *)
void SetUserAction (G4VUserPrimaryGeneratorAction *)
void SetUserAction (G4UserEventAction *)
void SetUserAction (G4UserRunAction *)
void SetUserAction (G4UserSteppingAction *)
void SetUserAction (G4UserTrackingAction *)
void SetUserAction (G4UserStackingAction *)
void SetUserAction (G4VUserPrimaryGeneratorAction *)
void SetUserAction (G4UserEventAction *)
void SetUserAction (G4UserRunAction *)
void SetUserInitialization (G4VUserPhysicsList *physInit)
void SetUserInitialization (G4VUserDetectorConstruction *userInit)
void SetUserInitialization (G4VUserPhysicsList *physInit)
void SetUserInitialization (G4VUserDetectorConstruction *userInit)
void SimulateEvents (int)
void SimulateEvents (int)
void StartUISession ()
void StartUISession ()
bool TofRootFlag ()
bool TofRootFlag ()
bool TofSaturationFlag ()
bool TofSaturationFlag ()
G4UImanager * uiMgr ()
G4UImanager * uiMgr ()

Static Public Member Functions

const InterfaceID & interfaceID ()
 Retrieve interface ID.
const InterfaceID & interfaceID ()
 Retrieve interface ID.

Protected Member Functions

 G4Svc (const std::string &name, ISvcLocator *svc)
 G4Svc (const std::string &name, ISvcLocator *svc)
virtual ~G4Svc ()
virtual ~G4Svc ()

Private Attributes

bool _init
double m_beamAngle
double m_beamDeltaTime
double m_beamPosX
double m_beamPosY
double m_beamPosZ
double m_beamShiftPx
double m_beamShiftPy
double m_beamShiftPz
double m_beamSizeX
double m_beamSizeY
double m_beamSizeZ
double m_beamStartTime
double m_beamTime
bool m_besGenAction
bool m_boostLab
double m_bunchTimeSigma
double m_emcCoherentNoise
double m_emcIncoherentNoise
bool m_emcLightOutput
int m_emcNoiseLevel
double m_emcNoiseMean
double m_emcNoiseSigma
double m_emcNoiseThreshold
bool m_emcRootFlag
int m_emcTime
int m_eventVerb
bool m_interactiveG4
int m_logLevel
std::string m_macroName
int m_mdcDataInput
int m_mdcDedxFlag
std::string m_mdcNoiseFile
bool m_mdcRootFlag
int m_mucNoiseMode
bool m_mucRootFlag
double m_nBunch
RealizationSvc * m_RealizationSvc
RealizationSvc * m_RealizationSvc
int m_runID
int m_runVerb
bool m_setBeamShift
bool m_tofRootFlag
bool m_tofSaturationFlag
int m_trackVerb
NTuple::Tuple * m_tupleEmc1
NTuple::Tuple * m_tupleEmc1
NTuple::Tuple * m_tupleEmc2
NTuple::Tuple * m_tupleEmc2
NTuple::Tuple * m_tupleMdc
NTuple::Tuple * m_tupleMdc
NTuple::Tuple * m_tupleMuc
NTuple::Tuple * m_tupleMuc
NTuple::Tuple * m_tupleTof1
NTuple::Tuple * m_tupleTof1
NTuple::Tuple * m_tupleTof2
NTuple::Tuple * m_tupleTof2
NTuple::Tuple * m_tupleTof3
NTuple::Tuple * m_tupleTof3
bool m_vis
G4SvcRunManager * p_runMgr
G4SvcRunManager * p_runMgr
G4UImanager * p_uiMgr
G4UImanager * p_uiMgr

Friends

class SvcFactory<G4Svc>

Constructor & Destructor Documentation

G4Svc::G4Svc (  const std::string &  name,
ISvcLocator *  svc
)  [protected]
  

00037                                                      :
00038       Service( name, svc ), p_runMgr(0), p_uiMgr(0), p_visMgr(0),
00039       _init(false), m_beamTime(0)
00040 {
00041   //declareProperty( "PhysicsList", m_PhysicsList="none");
00042   //declareProperty( "DefaultPhysicsCut",  m_PhysicsCut=-1.);
00043   declareProperty( "Visualize", m_vis=false);
00044   //declareProperty( "VisType", m_visType="VRML1FILE");
00045 
00046   declareProperty( "RunVerbosity", m_runVerb=0);
00047   declareProperty( "EventVerbosity", m_eventVerb=0);
00048   declareProperty( "TrackingVerbosity", m_trackVerb=0);
00049   
00050   declareProperty( "FADSmacro",m_macroName="none" );
00051   declareProperty( "MdcNoiseFile", m_mdcNoiseFile="none");
00052 
00053   //declareProperty( "SaveHits", m_saveHits=true);
00054   //declareProperty( "SaveTracks", m_saveTracks=false);
00055   declareProperty( "LogLevel", m_logLevel=6);
00056   
00057   declareProperty( "InteractiveG4" , m_interactiveG4=false);
00058 
00059   declareProperty("BesGenAction", m_besGenAction=false);
00060 
00061   declareProperty("BeamPosX",m_beamPosX=0);
00062   declareProperty("BeamPosY",m_beamPosY=0);
00063   declareProperty("BeamPosZ",m_beamPosZ=0);
00064 
00065   declareProperty("BeamSizeX", m_beamSizeX=10);
00066   declareProperty("BeamSizeY", m_beamSizeY=20);
00067   declareProperty("BeamSizeZ", m_beamSizeZ=30);
00068 
00069   declareProperty("BeamStartTime",m_beamStartTime=0);
00070   declareProperty("BeamDeltaTime",m_beamDeltaTime=0);
00071   declareProperty("NBunch",m_nBunch=1);
00072 
00073   declareProperty("BunchTimeSigma",m_bunchTimeSigma=0);
00074 
00075   declareProperty("MdcDataInput",m_mdcDataInput=1);  
00076   declareProperty("MdcDedxFlag",m_mdcDedxFlag=1);  
00077 
00078   declareProperty("BoostLab",m_boostLab=false); 
00079   declareProperty("BeamAngle",m_beamAngle=11);
00080    
00081   declareProperty("SetBeamShift",m_setBeamShift= false);
00082   declareProperty("BeamShiftPx" ,m_beamShiftPx=39.45);  // in unit MeV
00083   declareProperty("BeamShiftPy" ,m_beamShiftPy=-0.98);
00084   declareProperty("BeamShiftPz" ,m_beamShiftPz=3.70); 
00085    
00086   declareProperty("MdcRootFlag",m_mdcRootFlag=false);
00087   declareProperty("TofRootFlag",m_tofRootFlag=false);
00088   declareProperty("EmcRootFlag",m_emcRootFlag=false);
00089   declareProperty("MucRootFlag",m_mucRootFlag=false);
00090   
00091   // Switch for ADC Saturation in Bhabha events
00092   declareProperty("TofSaturationFlag",m_tofSaturationFlag=true); 
00093   
00094   declareProperty("EmcLightOutput",m_emcLightOutput=true);
00095   declareProperty("EmcIncoherentNoise",m_emcIncoherentNoise=0.2);
00096   declareProperty("EmcCoherentNoise",m_emcCoherentNoise=0.);
00097   declareProperty("EmcNoiseMean",m_emcNoiseMean=1.16);
00098   declareProperty("EmcNoiseSigma",m_emcNoiseSigma=0.23);
00099   declareProperty("EmcNoiseThreshold",m_emcNoiseThreshold=0.5);
00100   declareProperty("EmcNoiseLevel",m_emcNoiseLevel=3);
00101   declareProperty("EmcTime",m_emcTime=20);
00102   
00103   declareProperty("MucNoiseMode", m_mucNoiseMode=1);
00104 }

G4Svc::~G4Svc (   )  [protected, virtual]
  

00108               {
00109   std::cout<<"G4Svc::~G4Svc()"<<std::endl;
00110   if (p_runMgr != 0) {
00111     delete p_runMgr;
00112   }
00113 #ifdef G4VIS_USE
00114   if (p_visMgr != 0) {
00115     delete p_visMgr;
00116   }
00117 #endif
00118 
00119 }

G4Svc::G4Svc (  const std::string &  name,
ISvcLocator *  svc
)  [protected]
 

virtual G4Svc::~G4Svc (   )  [protected, virtual]
 

Member Function Documentation

double G4Svc::EmcCoherentNoise (   )  [inline]
  

00126 {return m_emcCoherentNoise;}

double G4Svc::EmcCoherentNoise (   )  [inline]
  

00126 {return m_emcCoherentNoise;}

double G4Svc::EmcIncoherentNoise (   )  [inline]
  

00125 {return m_emcIncoherentNoise;}

double G4Svc::EmcIncoherentNoise (   )  [inline]
  

00125 {return m_emcIncoherentNoise;}

bool G4Svc::EmcLightOutput (   )  [inline]
  

00124 {return m_emcLightOutput;}

bool G4Svc::EmcLightOutput (   )  [inline]
  

00124 {return m_emcLightOutput;}

int G4Svc::EmcNoiseLevel (   )  [inline]
  

00130 {return m_emcNoiseLevel;}

int G4Svc::EmcNoiseLevel (   )  [inline]
  

00130 {return m_emcNoiseLevel;}

double G4Svc::EmcNoiseMean (   )  [inline]
  

00127 {return m_emcNoiseMean;}

double G4Svc::EmcNoiseMean (   )  [inline]
  

00127 {return m_emcNoiseMean;}

double G4Svc::EmcNoiseSigma (   )  [inline]
  

00128 {return m_emcNoiseSigma;}

double G4Svc::EmcNoiseSigma (   )  [inline]
  

00128 {return m_emcNoiseSigma;}

double G4Svc::EmcNoiseThreshold (   )  [inline]
  

00129 {return m_emcNoiseThreshold;}

double G4Svc::EmcNoiseThreshold (   )  [inline]
  

00129 {return m_emcNoiseThreshold;}

bool G4Svc::EmcRootFlag (   )  [inline]
  

00119 {return m_emcRootFlag;}

bool G4Svc::EmcRootFlag (   )  [inline]
  

00119 {return m_emcRootFlag;}

int G4Svc::EmcTime (   )  [inline]
  

00131 {return m_emcTime;}

int G4Svc::EmcTime (   )  [inline]
  

00131 {return m_emcTime;}

virtual StatusCode G4Svc::finalize (   )  [virtual]
 

StatusCode G4Svc::finalize (   )  [virtual]
  

00166                            {
00167 
00168   MsgStream log( msgSvc(), name() );
00169   StatusCode status = Service::finalize();
00170 
00171   if ( status.isSuccess() )
00172     log << MSG::INFO << "Service finalised successfully" << endreq;
00173   
00174   return status;
00175 }

void G4Svc::G4Init (   )  [virtual]
 

Implements IG4Svc.

void G4Svc::G4Init (   )  [virtual]
 

Implements IG4Svc.

00295                    {
00296 
00297   MsgStream log( msgSvc(), name() );
00298   
00299   log << MSG::VERBOSE << "Attempting G4 Initialization" << endreq;
00300   
00301   if (!_init) {
00302     // Tracking
00303     //if (m_saveTracks) {
00304     //  log << MSG::INFO << "turning tracking on" << std::endl;
00305     //  uiMgr()->ApplyCommand("/tracking/storeTrajectory 1");
00306     //}
00307 
00308     // Visualization manager
00309 #ifdef G4VIS_USE
00310     if (m_vis) {
00311       log << MSG::INFO << "Initializing G4SvcVisManager" << endreq;
00312       //p_visMgr = new G4SvcVisManager;
00313       p_visMgr = new G4VisExecutive;
00314       p_visMgr->Initialize();
00315     }
00316 #else
00317     m_vis = false;
00318 #endif
00319     
00320     if (!m_vis) {
00321       log << MSG::INFO << "Not including Visualization" << endreq;
00322     }
00323 
00324     // Verbosity
00325     log << MSG::DEBUG << "Setting verbosity levels - " 
00326               << "run: " << m_runVerb << "  event: " << m_eventVerb
00327               << "  track: " << m_trackVerb << endreq;
00328     
00329     {
00330       std::ostrstream ost;
00331       ost << "/run/verbose " << m_runVerb << std::ends;
00332       uiMgr()->ApplyCommand(ost.str());
00333     }
00334     {
00335       std::ostrstream ost;
00336       ost << "/event/verbose " << m_eventVerb << std::ends;
00337       uiMgr()->ApplyCommand(ost.str());
00338     }
00339     {
00340       std::ostrstream ost;
00341       ost << "/tracking/verbose " << m_trackVerb << std::ends;
00342       uiMgr()->ApplyCommand(ost.str());
00343     }
00344     
00345     log << MSG::DEBUG << "Initializing G4 kernel" << endreq;
00346     p_runMgr->Initialize();
00347     _init = true;
00348 
00349     if (m_macroName!="none"){
00350       log << MSG::INFO << "Running G4 macro "<<m_macroName<< endreq;
00351       uiMgr()->ApplyCommand("/control/execute "+m_macroName);
00352     }
00353     if (m_interactiveG4) {
00354       StartUISession();
00355     }
00356     
00357   }else {
00358     log << MSG::ERROR << "G4 kernel already initialized" << endreq;
00359   }
00360 }

double G4Svc::GetBeamAngle (   )  [inline]
  

00089 {return m_beamAngle;}

double G4Svc::GetBeamAngle (   )  [inline]
  

00089 {return m_beamAngle;}

double G4Svc::GetBeamDeltaTime (   )  [inline]
  

00081 {return m_beamDeltaTime;}

double G4Svc::GetBeamDeltaTime (   )  [inline]
  

00081 {return m_beamDeltaTime;}

double G4Svc::GetBeamPosX (   )  [inline]
  

00068 {return m_beamPosX;}

double G4Svc::GetBeamPosX (   )  [inline]
  

00068 {return m_beamPosX;}

double G4Svc::GetBeamPosY (   )  [inline]
  

00069 {return m_beamPosY;}

double G4Svc::GetBeamPosY (   )  [inline]
  

00069 {return m_beamPosY;}

double G4Svc::GetBeamPosZ (   )  [inline]
  

00070 {return m_beamPosZ;}

double G4Svc::GetBeamPosZ (   )  [inline]
  

00070 {return m_beamPosZ;}

double G4Svc::GetBeamShiftPx (   )  [inline]
  

00076 {return m_beamShiftPx;}

double G4Svc::GetBeamShiftPx (   )  [inline]
  

00076 {return m_beamShiftPx;}

double G4Svc::GetBeamShiftPy (   )  [inline]
  

00077 {return m_beamShiftPy;}

double G4Svc::GetBeamShiftPy (   )  [inline]
  

00077 {return m_beamShiftPy;}

double G4Svc::GetBeamShiftPz (   )  [inline]
  

00078 {return m_beamShiftPz;}

double G4Svc::GetBeamShiftPz (   )  [inline]
  

00078 {return m_beamShiftPz;}

double G4Svc::GetBeamSizeX (   )  [inline]
  

00072 {return m_beamSizeX;}

double G4Svc::GetBeamSizeX (   )  [inline]
  

00072 {return m_beamSizeX;}

double G4Svc::GetBeamSizeY (   )  [inline]
  

00073 {return m_beamSizeY;}

double G4Svc::GetBeamSizeY (   )  [inline]
  

00073 {return m_beamSizeY;}

double G4Svc::GetBeamSizeZ (   )  [inline]
  

00074 {return m_beamSizeZ;}

double G4Svc::GetBeamSizeZ (   )  [inline]
  

00074 {return m_beamSizeZ;}

double G4Svc::GetBeamStartTime (   )  [inline]
  

00080 {return m_beamStartTime;}

double G4Svc::GetBeamStartTime (   )  [inline]
  

00080 {return m_beamStartTime;}

double G4Svc::GetBeamTime (   )  [inline]
  

00085 {return m_beamTime;}

double G4Svc::GetBeamTime (   )  [inline]
  

00085 {return m_beamTime;}

bool G4Svc::GetBoostLab (   )  [inline]
  

00090 {return m_boostLab;}

bool G4Svc::GetBoostLab (   )  [inline]
  

00090 {return m_boostLab;}

double G4Svc::GetBunchTimeSigma (   )  [inline]
  

00083 {return m_bunchTimeSigma;}

double G4Svc::GetBunchTimeSigma (   )  [inline]
  

00083 {return m_bunchTimeSigma;}

const G4Event* G4Svc::GetCurrentEvent (   )  const [virtual]
 

Implements IG4Svc.

const G4Event * G4Svc::GetCurrentEvent (   )  const [virtual]
 

Implements IG4Svc.

00192                                             {
00193 
00194   const G4Event *evt = p_runMgr->GetCurrentEvent();
00195 
00196   if (evt == 0) {
00197     MsgStream log( msgSvc(), name() );
00198     log << MSG::ERROR << "Could not get current G4Event" << endreq;
00199   }
00200 
00201   return ( evt );
00202 
00203 }

const G4Run* G4Svc::GetCurrentRun (   )  const [virtual]
 

Implements IG4Svc.

const G4Run * G4Svc::GetCurrentRun (   )  const [virtual]
 

Implements IG4Svc.

00206                                         {
00207 
00208   return ( p_runMgr->GetCurrentRun() );
00209 
00210 }

int G4Svc::GetMdcDataInput (   )  [inline]
  

00093 { return m_mdcDataInput; }

int G4Svc::GetMdcDataInput (   )  [inline]
  

00093 { return m_mdcDataInput; }

int G4Svc::GetMdcDedxFlag (   )  [inline]
  

00094 {return m_mdcDedxFlag;}

int G4Svc::GetMdcDedxFlag (   )  [inline]
  

00094 {return m_mdcDedxFlag;}

std::string G4Svc::GetMdcNoiseFile (   )  [inline]
  

00087 {return m_mdcNoiseFile;}

std::string G4Svc::GetMdcNoiseFile (   )  [inline]
  

00087 {return m_mdcNoiseFile;}

double G4Svc::GetNBunch (   )  [inline]
  

00082 {return m_nBunch;}

double G4Svc::GetNBunch (   )  [inline]
  

00082 {return m_nBunch;}

bool G4Svc::GetSetBeamShift (   )  [inline]
  

00091 {return m_setBeamShift;}

bool G4Svc::GetSetBeamShift (   )  [inline]
  

00091 {return m_setBeamShift;}

NTuple::Tuple* G4Svc::GetTupleEmc1 (   )  [inline]
  

00108 {return m_tupleEmc1;}

NTuple::Tuple* G4Svc::GetTupleEmc1 (   )  [inline]
  

00108 {return m_tupleEmc1;}

NTuple::Tuple* G4Svc::GetTupleEmc2 (   )  [inline]
  

00111 {return m_tupleEmc2;}

NTuple::Tuple* G4Svc::GetTupleEmc2 (   )  [inline]
  

00111 {return m_tupleEmc2;}

NTuple::Tuple* G4Svc::GetTupleMdc (   )  [inline]
  

00096 {return m_tupleMdc;}

NTuple::Tuple* G4Svc::GetTupleMdc (   )  [inline]
  

00096 {return m_tupleMdc;}

NTuple::Tuple* G4Svc::GetTupleMuc (   )  [inline]
  

00114 {return m_tupleMuc;}

NTuple::Tuple* G4Svc::GetTupleMuc (   )  [inline]
  

00114 {return m_tupleMuc;}

NTuple::Tuple* G4Svc::GetTupleTof1 (   )  [inline]
  

00099 {return m_tupleTof1;}

NTuple::Tuple* G4Svc::GetTupleTof1 (   )  [inline]
  

00099 {return m_tupleTof1;}

NTuple::Tuple* G4Svc::GetTupleTof2 (   )  [inline]
  

00102 {return m_tupleTof2;}

NTuple::Tuple* G4Svc::GetTupleTof2 (   )  [inline]
  

00102 {return m_tupleTof2;}

NTuple::Tuple* G4Svc::GetTupleTof3 (   )  [inline]
  

00105 {return m_tupleTof3;}

NTuple::Tuple* G4Svc::GetTupleTof3 (   )  [inline]
  

00105 {return m_tupleTof3;}

virtual StatusCode G4Svc::initialize (   )  [virtual]
 

StatusCode G4Svc::initialize (   )  [virtual]
  

00139                              {
00140 
00141   MsgStream log( msgSvc(), name() );
00142 
00143   StatusCode status = Service::initialize();
00144   log << MSG::INFO << "Service initialized" << endreq;
00145   
00146   //get IRealizationSvc
00147   IRealizationSvc *tmpReal;
00148   status = service("RealizationSvc", tmpReal);
00149   if (!status.isSuccess())
00150   {
00151      log << MSG::ERROR << " Could not initialize Realization Service" << endreq;
00152      return status;
00153   } else {
00154     log << MSG::INFO << "got the RealizationSvc" << endreq;
00155     m_RealizationSvc=dynamic_cast<RealizationSvc*>(tmpReal);
00156   }
00157 
00158   m_runID = m_RealizationSvc->getRunId();
00159 
00160   runMgr();
00161   return status;
00162 }

const InterfaceID& IG4Svc::interfaceID (   )  [inline, static, inherited]
 

Retrieve interface ID. 

00056 { return IID_IG4Svc; }

const InterfaceID& IG4Svc::interfaceID (   )  [inline, static, inherited]
 

Retrieve interface ID. 

00056 { return IID_IG4Svc; }

int G4Svc::LogLevel (   )  [inline]
  

00135 {return m_logLevel;}

int G4Svc::LogLevel (   )  [inline]
  

00135 {return m_logLevel;}

bool G4Svc::MdcRootFlag (   )  [inline]
  

00117 {return m_mdcRootFlag;}

bool G4Svc::MdcRootFlag (   )  [inline]
  

00117 {return m_mdcRootFlag;}

int G4Svc::MucNoiseMode (   )  [inline]
  

00133 {return m_mucNoiseMode;}

int G4Svc::MucNoiseMode (   )  [inline]
  

00133 {return m_mucNoiseMode;}

bool G4Svc::MucRootFlag (   )  [inline]
  

00120 {return m_mucRootFlag;}

bool G4Svc::MucRootFlag (   )  [inline]
  

00120 {return m_mucRootFlag;}

virtual StatusCode G4Svc::queryInterface (  const InterfaceID &  riid,
void **  ppvInterface
)  [virtual]
 

StatusCode G4Svc::queryInterface (  const InterfaceID &  riid,
void **  ppvInterface
)  [virtual]
  

00179                                                               {
00180   StatusCode sc = StatusCode::FAILURE;
00181 
00182   if (riid == IID_IG4Svc) {
00183     *ppvInterface = dynamic_cast<IG4Svc*>(this);
00184     sc = StatusCode::SUCCESS;
00185   } else {
00186     sc = Service::queryInterface( riid, ppvInterface );
00187   }
00188   return sc;
00189 }

void G4Svc::RunInitialize (   ) 
 

void G4Svc::RunInitialize (   ) 
  

00364 {
00365         bool cond = p_runMgr->ConfirmBeamOnCondition();
00366         if(cond)
00367         {
00368                 std::cout<<"########### initializing the G4Run ############"<<
00369                 std::endl;
00370                 p_runMgr->SetRunIDCounter( -std::abs(m_runID) );
00371     p_runMgr->RunInitialization();
00372         }
00373 }

G4RunManager* G4Svc::runMgr (   )  [virtual]
 

Implements IG4Svc.

G4RunManager * G4Svc::runMgr (   )  [virtual]
 

Implements IG4Svc.

00122                             { 
00123   std::cout<<"G4Svc::runMgr()"<<std::endl;
00124   MsgStream log( msgSvc(), name() );
00125 
00126   if (p_runMgr == 0) {
00127     p_runMgr = new G4SvcRunManager();
00128     p_runMgr->SetLogLevel( m_logLevel );
00129     //p_runMgr->SetSaveHits( m_saveHits );
00130     //p_runMgr->SetSaveTracks( m_saveTracks );
00131   }
00132 
00133   return p_runMgr; 
00134 
00135 }

void G4Svc::RunTerminate (   ) 
 

void G4Svc::RunTerminate (   ) 
  

00376 {
00377         p_runMgr->RunTermination();
00378 }

void G4Svc::SetBeamTime (  double  value  )  [inline]
  

00086 {m_beamTime = value;}

void G4Svc::SetBeamTime (  double  value  )  [inline]
  

00086 {m_beamTime = value;}

void G4Svc::SetTupleEmc1 (  NTuple::Tuple *  tuple  )  [inline]
  

00109 {m_tupleEmc1 = tuple;}

void G4Svc::SetTupleEmc1 (  NTuple::Tuple *  tuple  )  [inline]
  

00109 {m_tupleEmc1 = tuple;}

void G4Svc::SetTupleEmc2 (  NTuple::Tuple *  tuple  )  [inline]
  

00112 {m_tupleEmc2 = tuple;}

void G4Svc::SetTupleEmc2 (  NTuple::Tuple *  tuple  )  [inline]
  

00112 {m_tupleEmc2 = tuple;}

void G4Svc::SetTupleMdc (  NTuple::Tuple *  tuple  )  [inline]
  

00097 {m_tupleMdc = tuple;}

void G4Svc::SetTupleMdc (  NTuple::Tuple *  tuple  )  [inline]
  

00097 {m_tupleMdc = tuple;}

void G4Svc::SetTupleMuc (  NTuple::Tuple *  tuple  )  [inline]
  

00115 {m_tupleMuc = tuple;}

void G4Svc::SetTupleMuc (  NTuple::Tuple *  tuple  )  [inline]
  

00115 {m_tupleMuc = tuple;}

void G4Svc::SetTupleTof1 (  NTuple::Tuple *  tuple  )  [inline]
  

00100 {m_tupleTof1 = tuple;}

void G4Svc::SetTupleTof1 (  NTuple::Tuple *  tuple  )  [inline]
  

00100 {m_tupleTof1 = tuple;}

void G4Svc::SetTupleTof2 (  NTuple::Tuple *  tuple  )  [inline]
  

00103 {m_tupleTof2 = tuple;}

void G4Svc::SetTupleTof2 (  NTuple::Tuple *  tuple  )  [inline]
  

00103 {m_tupleTof2 = tuple;}

void G4Svc::SetTupleTof3 (  NTuple::Tuple *  tuple  )  [inline]
  

00106 {m_tupleTof3 = tuple;}

void G4Svc::SetTupleTof3 (  NTuple::Tuple *  tuple  )  [inline]
  

00106 {m_tupleTof3 = tuple;}

void G4Svc::SetUserAction (  G4UserSteppingAction *   )  [virtual]
 

Implements IG4Svc.

void G4Svc::SetUserAction (  G4UserTrackingAction *   )  [virtual]
 

Implements IG4Svc.

void G4Svc::SetUserAction (  G4UserStackingAction *   )  [virtual]
 

Implements IG4Svc.

void G4Svc::SetUserAction (  G4VUserPrimaryGeneratorAction *   )  [virtual]
 

Implements IG4Svc.

void G4Svc::SetUserAction (  G4UserEventAction *   )  [virtual]
 

Implements IG4Svc.

void G4Svc::SetUserAction (  G4UserRunAction *   )  [virtual]
 

Implements IG4Svc.

void G4Svc::SetUserAction (  G4UserSteppingAction *   )  [virtual]
 

Implements IG4Svc.

00274                                                       {
00275   if (p_runMgr != 0) {
00276     p_runMgr->SetUserAction(action);
00277   }
00278 }

void G4Svc::SetUserAction (  G4UserTrackingAction *   )  [virtual]
 

Implements IG4Svc.

00267                                                       {
00268   if (p_runMgr != 0) {
00269     p_runMgr->SetUserAction(action);
00270   }
00271 }

void G4Svc::SetUserAction (  G4UserStackingAction *   )  [virtual]
 

Implements IG4Svc.

00260                                                       {
00261   if (p_runMgr != 0) {
00262     p_runMgr->SetUserAction(action);
00263   }
00264 }

void G4Svc::SetUserAction (  G4VUserPrimaryGeneratorAction *   )  [virtual]
 

Implements IG4Svc.

00252                                                                {
00253   if (p_runMgr != 0) {
00254     if(m_besGenAction)
00255       p_runMgr->SetUserAction( action );
00256   }
00257 }

void G4Svc::SetUserAction (  G4UserEventAction *   )  [virtual]
 

Implements IG4Svc.

00245                                                    {
00246   if (p_runMgr != 0) {
00247     p_runMgr->SetUserAction(action);
00248   }
00249 }

void G4Svc::SetUserAction (  G4UserRunAction *   )  [virtual]
 

Implements IG4Svc.

00238                                                  {
00239   if (p_runMgr != 0) {
00240     p_runMgr->SetUserAction(action);
00241   }
00242 }

void G4Svc::SetUserInitialization (  G4VUserPhysicsList *  physInit  )  [virtual]
 

Implements IG4Svc.

void G4Svc::SetUserInitialization (  G4VUserDetectorConstruction *  userInit  )  [virtual]
 

Implements IG4Svc.

void G4Svc::SetUserInitialization (  G4VUserPhysicsList *  physInit  )  [virtual]
 

Implements IG4Svc.

00230                                                               {
00231   if (p_runMgr != 0) {
00232     p_runMgr->SetUserInitialization(userInit);
00233   }
00234 }

void G4Svc::SetUserInitialization (  G4VUserDetectorConstruction *  userInit  )  [virtual]
 

Implements IG4Svc.

00222                                                                        {
00223   if (p_runMgr != 0) {
00224     p_runMgr->SetUserInitialization(userInit);
00225   }
00226 }

void G4Svc::SimulateEvents (  int   ) 
 

void G4Svc::SimulateEvents (  int   ) 
  

00381 {
00382         p_runMgr->SimulateEvent(i);
00383 }

void G4Svc::StartUISession (   )  [virtual]
 

Implements IG4Svc.

void G4Svc::StartUISession (   )  [virtual]
 

Implements IG4Svc.

00282                            {
00283 
00284   MsgStream log( msgSvc(), name() );
00285   log << MSG::DEBUG << "Starting G4 terminal" << endreq;
00286 
00287   G4UIsession * ses = new G4UIterminal(new G4UItcsh);
00288   ses->SessionStart();
00289   
00290   delete ses;
00291 }

bool G4Svc::TofRootFlag (   )  [inline]
  

00118 {return m_tofRootFlag;}

bool G4Svc::TofRootFlag (   )  [inline]
  

00118 {return m_tofRootFlag;}

bool G4Svc::TofSaturationFlag (   )  [inline]
  

00122 {return m_tofSaturationFlag;} // Tof Q Saturation in bhabha events

bool G4Svc::TofSaturationFlag (   )  [inline]
  

00122 {return m_tofSaturationFlag;} // Tof Q Saturation in bhabha events

G4UImanager* G4Svc::uiMgr (   )  [virtual]
 

Implements IG4Svc.

G4UImanager * G4Svc::uiMgr (   )  [virtual]
 

Implements IG4Svc.

00213                           {
00214   if (p_uiMgr == 0) {
00215     p_uiMgr = G4UImanager::GetUIpointer();
00216   }
00217   return ( p_uiMgr );
00218 }

Friends And Related Function Documentation

SvcFactory<G4Svc> [friend]
 

Member Data Documentation

bool G4Svc::_init [private]
 

double G4Svc::m_beamAngle [private]
 

double G4Svc::m_beamDeltaTime [private]
 

double G4Svc::m_beamPosX [private]
 

double G4Svc::m_beamPosY [private]
 

double G4Svc::m_beamPosZ [private]
 

double G4Svc::m_beamShiftPx [private]
 

double G4Svc::m_beamShiftPy [private]
 

double G4Svc::m_beamShiftPz [private]
 

double G4Svc::m_beamSizeX [private]
 

double G4Svc::m_beamSizeY [private]
 

double G4Svc::m_beamSizeZ [private]
 

double G4Svc::m_beamStartTime [private]
 

double G4Svc::m_beamTime [private]
 

bool G4Svc::m_besGenAction [private]
 

bool G4Svc::m_boostLab [private]
 

double G4Svc::m_bunchTimeSigma [private]
 

double G4Svc::m_emcCoherentNoise [private]
 

double G4Svc::m_emcIncoherentNoise [private]
 

bool G4Svc::m_emcLightOutput [private]
 

int G4Svc::m_emcNoiseLevel [private]
 

double G4Svc::m_emcNoiseMean [private]
 

double G4Svc::m_emcNoiseSigma [private]
 

double G4Svc::m_emcNoiseThreshold [private]
 

bool G4Svc::m_emcRootFlag [private]
 

int G4Svc::m_emcTime [private]
 

int G4Svc::m_eventVerb [private]
 

bool G4Svc::m_interactiveG4 [private]
 

int G4Svc::m_logLevel [private]
 

std::string G4Svc::m_macroName [private]
 

int G4Svc::m_mdcDataInput [private]
 

int G4Svc::m_mdcDedxFlag [private]
 

std::string G4Svc::m_mdcNoiseFile [private]
 

bool G4Svc::m_mdcRootFlag [private]
 

int G4Svc::m_mucNoiseMode [private]
 

bool G4Svc::m_mucRootFlag [private]
 

double G4Svc::m_nBunch [private]
 

RealizationSvc* G4Svc::m_RealizationSvc [private]
 

RealizationSvc* G4Svc::m_RealizationSvc [private]
 

int G4Svc::m_runID [private]
 

int G4Svc::m_runVerb [private]
 

bool G4Svc::m_setBeamShift [private]
 

bool G4Svc::m_tofRootFlag [private]
 

bool G4Svc::m_tofSaturationFlag [private]
 

int G4Svc::m_trackVerb [private]
 

NTuple::Tuple* G4Svc::m_tupleEmc1 [private]
 

NTuple::Tuple* G4Svc::m_tupleEmc1 [private]
 

NTuple::Tuple* G4Svc::m_tupleEmc2 [private]
 

NTuple::Tuple* G4Svc::m_tupleEmc2 [private]
 

NTuple::Tuple* G4Svc::m_tupleMdc [private]
 

NTuple::Tuple* G4Svc::m_tupleMdc [private]
 

NTuple::Tuple* G4Svc::m_tupleMuc [private]
 

NTuple::Tuple* G4Svc::m_tupleMuc [private]
 

NTuple::Tuple* G4Svc::m_tupleTof1 [private]
 

NTuple::Tuple* G4Svc::m_tupleTof1 [private]
 

NTuple::Tuple* G4Svc::m_tupleTof2 [private]
 

NTuple::Tuple* G4Svc::m_tupleTof2 [private]
 

NTuple::Tuple* G4Svc::m_tupleTof3 [private]
 

NTuple::Tuple* G4Svc::m_tupleTof3 [private]
 

bool G4Svc::m_vis [private]
 

G4SvcRunManager* G4Svc::p_runMgr [private]
 

G4SvcRunManager* G4Svc::p_runMgr [private]
 

G4UImanager* G4Svc::p_uiMgr [private]
 

G4UImanager* G4Svc::p_uiMgr [private]
 

The documentation for this class was generated from the following files:
Generated on Wed Feb 2 16:15:55 2011 for BOSS6.5.5 by  doxygen 1.3.9.1