G4AtlasAlg.cxx File Reference

#include "G4AtlasAlg.h"
#include "G4AtlasFluxRecorder.h"
#include "G4AtlasTools/G4AtlasActionInitialization.h"
#include "AthenaKernel/RNGWrapper.h"
#include "CxxUtils/checker_macros.h"
#include "G4AtlasAlg/G4AtlasMTRunManager.h"
#include "G4AtlasAlg/G4AtlasRunManager.h"
#include "G4AtlasAlg/G4AtlasUserWorkerThreadInitialization.h"
#include "G4AtlasAlg/G4AtlasWorkerRunManager.h"
#include <G4Event.hh>
#include "G4EventManager.hh"
#include "G4GDMLParser.hh"
#include "G4Navigator.hh"
#include "G4ParallelWorldPhysics.hh"
#include "G4PropagatorInField.hh"
#include "G4RunManagerKernel.hh"
#include "G4ScoringManager.hh"
#include "G4StackManager.hh"
#include "G4StateManager.hh"
#include "G4TrackingManager.hh"
#include "G4TransportationManager.hh"
#include "G4UImanager.hh"
#include "G4VModularPhysicsList.hh"
#include "G4VUserPhysicsList.hh"
#include "CLHEP/Random/RandomEngine.h"
#include "GaudiKernel/IThreadInitTool.h"
#include "GeneratorObjects/HepMcParticleLink.h"
#include "GeoModelInterfaces/IGeoModelSvc.h"
#include "HitManagement/HitCollectionMap.h"
#include "MCTruth/AtlasG4EventUserInfo.h"
#include "PathResolver/PathResolver.h"
#include "StoreGate/ReadHandle.h"
#include "StoreGate/WriteHandle.h"
#include <memory>
#include <mutex>

Go to the source code of this file.

Functions
StatusCode G4AtlasAlg::initialize	ATLAS_NOT_THREAD_SAFE ()
	Install fatal handler with default options.

Variables
static std::once_flag	initializeOnceFlag
static std::once_flag	finalizeOnceFlag
static std::once_flag	releaseGeoModelOnceFlag

Function Documentation

ATLAS_NOT_THREAD_SAFE()

StatusCode G4AtlasAlg::initialize ATLAS_NOT_THREAD_SAFE ( )

inline

Install fatal handler with default options.

This is meant to be easy to call from python via ctypes.

Definition at line 70 of file G4AtlasAlg.cxx.

{
  ATH_MSG_DEBUG("Start of initialize()");
 
  // Read the simplified geometry for FastCaloSim track transportation if requested
  if(!m_simplifiedGeoPath.empty()) {
    std::string geoFile = PathResolverFindCalibFile(m_simplifiedGeoPath);
    
    if (geoFile.empty()) {
      ATH_MSG_FATAL("Could not find simplified geometry file: " << m_simplifiedGeoPath);
      return StatusCode::FAILURE;
    }
 
    G4GDMLParser parser;
    parser.Read(geoFile, false);
  }
 
  // Create the scoring manager if requested
  if (m_recordFlux) G4ScoringManager::GetScoringManager();
 
  ATH_CHECK( m_userActionSvc.retrieve() );
  // One-time initialization
  try {
    std::call_once(initializeOnceFlag, &G4AtlasAlg::initializeOnce, this);
  }
  catch(const std::exception& e) {
    ATH_MSG_ERROR("Failure in G4AtlasAlg::initializeOnce: " << e.what());
    return StatusCode::FAILURE;
  }
 
  ATH_CHECK( m_rndmGenSvc.retrieve() );
  ATH_CHECK(m_actionTools.retrieve());
 
  ATH_CHECK(m_senDetTool.retrieve());
  ATH_CHECK(m_fastSimTool.retrieve());
 
  // Truth
  ATH_CHECK( m_truthRecordSvc.retrieve() );
  ATH_MSG_INFO( "- Using ISF TruthRecordSvc : " << m_truthRecordSvc.typeAndName() );
 
  // I/O
  ATH_CHECK( m_inputTruthCollectionKey.initialize());
  ATH_CHECK( m_outputTruthCollectionKey.initialize());
  ATH_CHECK( m_eventInfoKey.initialize() );
 
  ATH_CHECK(m_inputConverter.retrieve());
  if ( not m_truthPreselectionTool.empty() ) {
    ATH_CHECK(m_truthPreselectionTool.retrieve());
  }
 
  if ( not m_qspatcher.empty() ) {
    ATH_CHECK( m_qspatcher.retrieve() );
  }
 
  ATH_MSG_DEBUG("End of initialize()");
  return StatusCode::SUCCESS;
}

Variable Documentation

finalizeOnceFlag

std::once_flag finalizeOnceFlag

static

Definition at line 54 of file G4AtlasAlg.cxx.

initializeOnceFlag

std::once_flag initializeOnceFlag

static

Definition at line 53 of file G4AtlasAlg.cxx.

releaseGeoModelOnceFlag

std::once_flag releaseGeoModelOnceFlag

static

Definition at line 55 of file G4AtlasAlg.cxx.