G4HadIntProcessor.cxx File Reference

#include "ISF_FatrasToolsG4/G4HadIntProcessor.h"
#include "ISF_Event/ISFParticle.h"
#include "ISF_Event/ISFParticleContainer.h"
#include "ISF_Event/ParticleClipboard.h"
#include "ISF_Event/ParticleUserInformation.h"
#include "ISF_Interfaces/IParticleBroker.h"
#include "ISF_Geant4Tools/IG4RunManagerHelper.h"
#include "ISF_Interfaces/ITruthSvc.h"
#include "ISF_Event/ISFTruthIncident.h"
#include <G4HadronElasticProcess.hh>
#include "TrkGeometry/MaterialProperties.h"
#include "G4Material.hh"
#include "G4RunManager.hh"
#include "G4ParticleGun.hh"
#include "G4Box.hh"
#include "G4LogicalVolume.hh"
#include "G4PVPlacement.hh"
#include "QGSP_BERT.hh"
#include "QGSP_BIC.hh"
#include "FTFP_BERT.hh"
#include "G4UImanager.hh"
#include "G4NistManager.hh"
#include "G4VEnergyLossProcess.hh"
#include <G4MaterialCutsCouple.hh>
#include <G4HadronInelasticProcess.hh>
#include "globals.hh"
#include "G4CrossSectionDataStore.hh"
#include "G4Element.hh"
#include "G4ElementVector.hh"
#include "G4IsotopeVector.hh"
#include "G4Neutron.hh"
#include "G4ProductionCutsTable.hh"
#include "G4ios.hh"
#include "TruthUtils/MagicNumbers.h"
#include "CLHEP/Units/SystemOfUnits.h"
#include "AtlasHepMC/GenParticle.h"
#include "AtlasHepMC/GenVertex.h"
#include "CLHEP/Random/RandExponential.h"
#include "CLHEP/Random/RandFlat.h"
#include <math.h>

Go to the source code of this file.

Functions
StatusCode iFatras::G4HadIntProcessor::initG4RunManager	ATLAS_NOT_THREAD_SAFE ()
	Install fatal handler with default options.

Function Documentation

ATLAS_NOT_THREAD_SAFE()

StatusCode iFatras::G4HadIntProcessor::initG4RunManager 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 244 of file G4HadIntProcessor.cxx.

                                                                             {
 
  ATH_MSG_DEBUG("[ g4sim ] Initializing G4RunManager");
 
  // Get the G4RunManagerHelper ( no initialization of G4RunManager done )
  ATH_CHECK( m_g4RunManagerHelper.retrieve() );
 
  G4RunManager* g4runManager = m_g4RunManagerHelper->fastG4RunManager();
  g4runManager->SetVerboseLevel(10);
 
  initProcessPDG( 211);
  initProcessPDG(-211);
  initProcessPDG(2212);
  initProcessPDG(-2212);
  initProcessPDG(2112);
  initProcessPDG( 130);
  initProcessPDG( 321);
  initProcessPDG( 111);
  initProcessPDG(-321);
 
  // define the available G4Material
  m_g4Material.clear();
 
  G4NistManager* G4Nist = G4NistManager::Instance();
  G4Material* air = G4Nist->G4NistManager::FindOrBuildMaterial("G4_AIR");
  if (air) {
    G4MaterialCutsCouple airCuts = G4MaterialCutsCouple(air);
    // airCuts->SetIndex(0);    // ?
    std::pair<G4Material*,G4MaterialCutsCouple> airMat(air,airCuts);
    m_g4Material.push_back(std::pair<float,std::pair<G4Material*,G4MaterialCutsCouple> >(0.,airMat));
  }
  G4Material* h = G4Nist->G4NistManager::FindOrBuildMaterial("G4_H");
  if (h) {
    G4MaterialCutsCouple hCuts = G4MaterialCutsCouple(h);
    std::pair<G4Material*,G4MaterialCutsCouple> hMat(h,hCuts);
    m_g4Material.push_back(std::pair<float,std::pair<G4Material*,G4MaterialCutsCouple> >(1.,hMat));
  }
  G4Material* al = G4Nist->G4NistManager::FindOrBuildMaterial("G4_Al");
  if (al) {
    G4MaterialCutsCouple alCuts = G4MaterialCutsCouple(al);
    std::pair<G4Material*,G4MaterialCutsCouple> alMat(al,alCuts);
    m_g4Material.push_back(std::pair<float,std::pair<G4Material*,G4MaterialCutsCouple> >(13.,alMat));
  }
  G4Material* si = G4Nist->G4NistManager::FindOrBuildMaterial("G4_Si");
  if (si) {
    G4MaterialCutsCouple siCuts = G4MaterialCutsCouple(si);
    std::pair<G4Material*,G4MaterialCutsCouple> siMat(si,siCuts);
    m_g4Material.push_back(std::pair<float,std::pair<G4Material*,G4MaterialCutsCouple> >(14.,siMat));
  }
  G4Material* ar = G4Nist->G4NistManager::FindOrBuildMaterial("G4_Ar");
  if (ar) {
    G4MaterialCutsCouple arCuts = G4MaterialCutsCouple(ar);
    std::pair<G4Material*,G4MaterialCutsCouple> arMat(ar,arCuts);
    m_g4Material.push_back(std::pair<float,std::pair<G4Material*,G4MaterialCutsCouple> >(18.,arMat));
  }
  G4Material* fe = G4Nist->G4NistManager::FindOrBuildMaterial("G4_Fe");
  if (fe) {
    G4MaterialCutsCouple feCuts = G4MaterialCutsCouple(fe);
    std::pair<G4Material*,G4MaterialCutsCouple> feMat(fe,feCuts);
    m_g4Material.push_back(std::pair<float,std::pair<G4Material*,G4MaterialCutsCouple> >(26.,feMat));
  }
  G4Material* pb = G4Nist->G4NistManager::FindOrBuildMaterial("G4_Pb");
  if (pb) {
    G4MaterialCutsCouple pbCuts = G4MaterialCutsCouple(pb);
    std::pair<G4Material*,G4MaterialCutsCouple> pbMat(pb,pbCuts);
    m_g4Material.push_back(std::pair<float,std::pair<G4Material*,G4MaterialCutsCouple> >(82.,pbMat));
  }
 
  ATH_MSG_INFO("material vector size for had interaction:"<< m_g4Material.size());
 
  //G4cout << *(G4Material::GetMaterialTable()) << std::endl;
 
  // Flush the G4 cout/cerr: ATLASSIM-5137
  G4cout << std::flush;
  G4cerr << std::flush;
 
  return StatusCode::SUCCESS;
}