G4Svc.cpp

Go to the documentation of this file.

//------------------------------------------------------------------
//
// ClassName:   G4Svc
//
// Description: This service provides access to Geant 4
//
// Based on Athena software
//
//------------------------------------------------------------------
 
// Include files
#include "GaudiKernel/ISvcLocator.h"
#include "GaudiKernel/MsgStream.h"
 
#include "G4Svc.h"
#include "G4SvcRunManager.h"
#ifdef G4VIS_USE
#  include "G4Svc/G4SvcVisManager.h"
#  include "G4VisExecutive.hh"
#endif
 
// GEANT
#include "G4RunManager.hh"
#include "G4UIsession.hh"
#include "G4UItcsh.hh"
#include "G4UIterminal.hh"
 
#include <cstdlib>
#include <fstream>
#include <iostream>
#include <strstream>
 
//*************************************************************************//
DECLARE_COMPONENT( G4Svc )
 
G4Svc::G4Svc( const std::string& name, ISvcLocator* svc )
    : base_class( name, svc )
    , p_runMgr( 0 )
    , p_uiMgr( 0 )
#ifdef G4VIS_USE
    , p_visMgr( 0 )
#endif
    , _init( false )
    , m_beamTime( 0 ) {
  // declareProperty( "PhysicsList", m_PhysicsList="none");
  // declareProperty( "DefaultPhysicsCut",  m_PhysicsCut=-1.);
  declareProperty( "Visualize", m_vis = false );
  // declareProperty( "VisType", m_visType="VRML1FILE");
 
  declareProperty( "RunVerbosity", m_runVerb = 0 );
  declareProperty( "EventVerbosity", m_eventVerb = 0 );
  declareProperty( "TrackingVerbosity", m_trackVerb = 0 );
 
  declareProperty( "FADSmacro", m_macroName = "none" );
  declareProperty( "MdcNoiseFile", m_mdcNoiseFile = "none" );
 
  // declareProperty( "SaveHits", m_saveHits=true);
  // declareProperty( "SaveTracks", m_saveTracks=false);
  declareProperty( "LogLevel", m_logLevel = 6 );
 
  declareProperty( "InteractiveG4", m_interactiveG4 = false );
 
  declareProperty( "BesGenAction", m_besGenAction = false );
 
  declareProperty( "BeamPosX", m_beamPosX = 0 );
  declareProperty( "BeamPosY", m_beamPosY = 0 );
  declareProperty( "BeamPosZ", m_beamPosZ = 0 );
 
  declareProperty( "BeamSizeX", m_beamSizeX = 10 );
  declareProperty( "BeamSizeY", m_beamSizeY = 20 );
  declareProperty( "BeamSizeZ", m_beamSizeZ = 30 );
 
  declareProperty( "BeamStartTime", m_beamStartTime = 0 );
  declareProperty( "BeamDeltaTime", m_beamDeltaTime = 0 );
  declareProperty( "NBunch", m_nBunch = 1 );
 
  declareProperty( "BunchTimeSigma", m_bunchTimeSigma = 0 );
 
  declareProperty( "MdcDataInput", m_mdcDataInput = 1 );
  declareProperty( "MdcDedxFlag", m_mdcDedxFlag = 1 );
  declareProperty( "MdcNewSimOpt",
                   m_mdcNewSimOpt = 1 ); // (0:Old MdcSim, 1:New) liaoyp -- 2023.10.30
 
  declareProperty( "BoostLab", m_boostLab = false );
  declareProperty( "BeamAngle", m_beamAngle = 11 );
 
  declareProperty( "SetBeamShift", m_setBeamShift = false );
  declareProperty( "BeamShiftPx", m_beamShiftPx = 39.45 ); // in unit MeV
  declareProperty( "BeamShiftPy", m_beamShiftPy = -0.98 );
  declareProperty( "BeamShiftPz", m_beamShiftPz = 3.70 );
 
  declareProperty( "MdcRootFlag", m_mdcRootFlag = false );
  declareProperty( "TofRootFlag", m_tofRootFlag = false );
  declareProperty( "EmcRootFlag", m_emcRootFlag = false );
  declareProperty( "MucRootFlag", m_mucRootFlag = false );
 
  // Switch for ADC Saturation in Bhabha events
  declareProperty( "TofSaturationFlag", m_tofSaturationFlag = true );
 
  declareProperty( "EmcLightOutput", m_emcLightOutput = true );
  declareProperty( "EmcIncoherentNoise", m_emcIncoherentNoise = 0.2 );
  declareProperty( "EmcCoherentNoise", m_emcCoherentNoise = 0. );
  declareProperty( "EmcNoiseMean", m_emcNoiseMean = 1.16 );
  declareProperty( "EmcNoiseSigma", m_emcNoiseSigma = 0.23 );
  declareProperty( "EmcNoiseThreshold", m_emcNoiseThreshold = 0.5 );
  declareProperty( "EmcNoiseLevel", m_emcNoiseLevel = 3 );
  declareProperty( "EmcTime", m_emcTime = 20 );
  declareProperty( "EmcELecSaturation", m_emcELecSaturation = 1 );
  declareProperty( "EmcELecSatuDead", m_emcELecSatuDead = 0 );
  declareProperty( "MucNoiseMode", m_mucNoiseMode = 1 );
}
 
//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//
 
G4Svc::~G4Svc() {
  //  std::cout<<"G4Svc::~G4Svc()"<<std::endl;
  //  if (p_runMgr != 0) {
  //    delete p_runMgr;
  //  }
  // #ifdef G4VIS_USE
  //  if (p_visMgr != 0) {
  //    delete p_visMgr;
  //  }
  // #endif
}
 
//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//
G4RunManager* G4Svc::runMgr() {
  // std::cout<<"G4Svc::runMgr()"<<std::endl;
  MsgStream log( msgSvc(), name() );
 
  if ( p_runMgr == 0 )
  {
    p_runMgr = new G4SvcRunManager();
    p_runMgr->SetLogLevel( m_logLevel );
    // p_runMgr->SetSaveHits( m_saveHits );
    // p_runMgr->SetSaveTracks( m_saveTracks );
  }
 
  return p_runMgr;
}
 
//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//
 
StatusCode G4Svc::initialize() {
 
  MsgStream log( msgSvc(), name() );
 
  StatusCode status = Service::initialize();
  log << MSG::INFO << "Service initialized" << endmsg;
 
  // get IRealizationSvc
  status = service( "RealizationSvc", m_RealizationSvc );
  if ( !status.isSuccess() )
  {
    log << MSG::ERROR << " Could not initialize Realization Service" << endmsg;
    return status;
  }
  else { log << MSG::INFO << "got the RealizationSvc" << endmsg; }
 
  m_runID = m_RealizationSvc->getRunId();
 
  runMgr();
  return status;
}
 
//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//
 
StatusCode G4Svc::finalize() {
 
  MsgStream  log( msgSvc(), name() );
  StatusCode status = Service::finalize();
 
  if ( status.isSuccess() ) log << MSG::INFO << "Service finalised successfully" << endmsg;
 
  return status;
}
 
//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//
/*StatusCode G4Svc::queryInterface( const InterfaceID& riid,
                                        void** ppvInterface ) {
  StatusCode sc = StatusCode::FAILURE;
 
  if (riid == IID_IG4Svc) {
    *ppvInterface = dynamic_cast<IG4Svc*>(this);
    sc = StatusCode::SUCCESS;
  } else {
    sc = Service::queryInterface( riid, ppvInterface );
  }
  return sc;
}*/
 
//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//
const G4Event* G4Svc::GetCurrentEvent() const {
 
  const G4Event* evt = p_runMgr->GetCurrentEvent();
 
  if ( evt == 0 )
  {
    MsgStream log( msgSvc(), name() );
    log << MSG::ERROR << "Could not get current G4Event" << endmsg;
  }
 
  return ( evt );
}
 
//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//
const G4Run* G4Svc::GetCurrentRun() const { return ( p_runMgr->GetCurrentRun() ); }
 
//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//
G4UImanager* G4Svc::uiMgr() {
  if ( p_uiMgr == 0 ) { p_uiMgr = G4UImanager::GetUIpointer(); }
  return ( p_uiMgr );
}
 
//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//
 
void G4Svc::SetUserInitialization( G4VUserDetectorConstruction* userInit ) {
  if ( p_runMgr != 0 ) { p_runMgr->SetUserInitialization( userInit ); }
}
 
//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//
 
void G4Svc::SetUserInitialization( G4VUserPhysicsList* userInit ) {
  if ( p_runMgr != 0 ) { p_runMgr->SetUserInitialization( userInit ); }
}
 
void G4Svc::SetUserInitialization( G4VUserActionInitialization* userInit ) {
  if ( p_runMgr != 0 ) { p_runMgr->SetUserInitialization( userInit ); }
}
 
//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//
 
/*void G4Svc::SetUserAction(G4UserRunAction *action) {
  if (p_runMgr != 0) {
    p_runMgr->SetUserAction(action);
  }
}*/
//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//
 
/*void G4Svc::SetUserAction(G4UserEventAction *action) {
  if (p_runMgr != 0) {
    p_runMgr->SetUserAction(action);
  }
}*/
//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//
/*
void G4Svc::SetUserAction(G4VUserPrimaryGeneratorAction *action) {
  if (p_runMgr != 0) {
    if(m_besGenAction)
      p_runMgr->SetUserAction( action );
  }
}*/
//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//
 
/*void G4Svc::SetUserAction(G4UserStackingAction *action) {
  if (p_runMgr != 0) {
    p_runMgr->SetUserAction(action);
  }
}*/
//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//
 
/*void G4Svc::SetUserAction(G4UserTrackingAction *action) {
  if (p_runMgr != 0) {
    p_runMgr->SetUserAction(action);
  }
}*/
//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//
 
/*void G4Svc::SetUserAction(G4UserSteppingAction *action) {
  if (p_runMgr != 0) {
    p_runMgr->SetUserAction(action);
  }
}*/
 
//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//
 
void G4Svc::StartUISession() {
 
  MsgStream log( msgSvc(), name() );
  log << MSG::DEBUG << "Starting G4 terminal" << endmsg;
 
  G4UIsession* ses = new G4UIterminal( new G4UItcsh );
  ses->SessionStart();
 
  delete ses;
}
 
//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//
 
void G4Svc::G4Init() {
 
  MsgStream log( msgSvc(), name() );
 
  log << MSG::VERBOSE << "Attempting G4 Initialization" << endmsg;
 
  if ( !_init )
  {
    // Tracking
    // if (m_saveTracks) {
    //  log << MSG::INFO << "turning tracking on" << std::endl;
    //  uiMgr()->ApplyCommand("/tracking/storeTrajectory 1");
    //}
 
    // Visualization manager
#ifdef G4VIS_USE
    if ( m_vis )
    {
      log << MSG::INFO << "Initializing G4SvcVisManager" << endmsg;
      // p_visMgr = new G4SvcVisManager;
      p_visMgr = new G4VisExecutive;
      p_visMgr->Initialize();
    }
#else
    m_vis = false;
#endif
 
    if ( !m_vis ) { log << MSG::INFO << "Not including Visualization" << endmsg; }
 
    // Verbosity
    log << MSG::DEBUG << "Setting verbosity levels - "
        << "run: " << m_runVerb << "  event: " << m_eventVerb << "  track: " << m_trackVerb
        << endmsg;
 
    {
      std::ostrstream ost;
      ost << "/run/verbose " << m_runVerb << std::ends;
      uiMgr()->ApplyCommand( ost.str() );
    }
    {
      std::ostrstream ost;
      ost << "/event/verbose " << m_eventVerb << std::ends;
      uiMgr()->ApplyCommand( ost.str() );
    }
    {
      std::ostrstream ost;
      ost << "/tracking/verbose " << m_trackVerb << std::ends;
      uiMgr()->ApplyCommand( ost.str() );
    }
 
    log << MSG::DEBUG << "Initializing G4 kernel" << endmsg;
    p_runMgr->Initialize();
    _init = true;
 
    if ( m_macroName != "none" )
    {
      log << MSG::INFO << "Running G4 macro " << m_macroName << endmsg;
      uiMgr()->ApplyCommand( "/control/execute " + m_macroName );
    }
    if ( m_interactiveG4 ) { StartUISession(); }
  }
  else { log << MSG::ERROR << "G4 kernel already initialized" << endmsg; }
}
 
//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//
void G4Svc::RunInitialize() {
  bool cond = p_runMgr->ConfirmBeamOnCondition();
  if ( cond )
  {
    std::cout << "########### initializing the G4Run ############" << std::endl;
    p_runMgr->SetRunIDCounter( -std::abs( m_runID ) );
    p_runMgr->RunInitialization();
  }
}
//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//
void G4Svc::RunTerminate() { p_runMgr->RunTermination(); }
//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//
void G4Svc::SimulateEvents( int i ) { p_runMgr->SimulateEvent( i ); }
 
//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//