ISF::ActsFatrasSimTool Class Reference

#include <ActsFatrasSimTool.h>

Inheritance diagram for ISF::ActsFatrasSimTool:

Collaboration diagram for ISF::ActsFatrasSimTool:

Classes
struct	HitSurfaceSelector
	Simple struct to select surfaces where hits should be generated. More...
struct	SingleParticleSimulation
	Single particle simulation with fixed propagator, interactions, and decay. More...

Public Types
using	Generator = std::ranlux48
using	Navigator = Acts::Navigator
using	ChargedStepper = Acts::EigenStepper<Acts::EigenStepperDefaultExtension>
using	ChargedPropagator = Acts::Propagator<ChargedStepper, Navigator>
using	NeutralStepper = Acts::StraightLineStepper
using	NeutralPropagator = Acts::Propagator<NeutralStepper, Navigator>
using	ChargedSelector = ActsFatras::ChargedSelector
using	ChargedInteractions
using	ChargedSimulation
using	NeutralSelector = ActsFatras::NeutralSelector
using	NeutralInteractions = ActsFatras::InteractionList<ActsFatras::PhotonConversion>
using	NeutralSimulation
using	Simulation

Public Member Functions
Amg::Vector3D	convertMom3FromActs (const Acts::Vector3 &actsMom)
	Convert ACTS momentum to Athena momentum.
Amg::Vector3D	convertPos3FromActs (const Acts::Vector3 &actsPos)
	ActsFatrasSimTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~ActsFatrasSimTool ()
virtual StatusCode	initialize () override
virtual StatusCode	simulate (const EventContext &ctx, ISFParticle &isp, ISFParticleContainer &, McEventCollection *) override
virtual StatusCode	simulateVector (const EventContext &ctx, const ISFParticleVector &particles, ISFParticleContainer &secondaries, McEventCollection *mcEventCollection, McEventCollection *shadowTruth=nullptr) override
	Simulation call for vectors of particles.
virtual StatusCode	setupEvent (const EventContext &) override
	Setup Event chain - in case of a begin-of event action is needed.
virtual StatusCode	releaseEvent (const EventContext &ctx) override
	Release Event chain - in case of an end-of event action is needed.
virtual ISF::SimulationFlavor	simFlavor () const override
virtual Acts::MagneticFieldContext	getMagneticFieldContext (const EventContext &) const
virtual StatusCode	sysInitialize () override
	Gaudi sysInitialize() methods.
virtual StatusCode	setupEventST () override
	Setup Event chain - in case of a begin-of event action is needed (called by ISimulationSvc)
virtual StatusCode	releaseEventST () override
	Release Event chain - in case of an end-of event action is needed (called by ISimulationSvc)
const ChronoEntity *	chronoStart (const IChronoSvc::ChronoTag &tag)
	wrapper call to start chrono with given tag
const ChronoEntity *	chronoStop (const IChronoSvc::ChronoTag &tag)
	wrapper call to stop chrono with given tag

Protected Attributes
ServiceHandle< IChronoStatSvc >	m_chrono {this, "ChronoStatService", "ChronoStatSvc"}
	The timing service for general usage.

Private Member Functions
template<class T>
StatusCode	retrieveTool (ToolHandle< T > &thandle)
bool	checkStartSurface (const Acts::MagneticFieldContext &mctx, const Acts::GeometryContext &anygctx, const ChargedPropagator &chargedPropagator, const Acts::BoundTrackParameters &startParameters, Acts::Direction navDir=Acts::Direction::Forward(), double pathLimit=std::numeric_limits< double >::max()) const
int	getATLASProcessCode (ActsFatras::ProcessType actspt)

Private Attributes
SiHitCollection	m_pixelSiHits
SiHitCollection	m_sctSiHits
ServiceHandle< IAthRNGSvc >	m_rngSvc {this, "RNGService", "AthRNGSvc"}
ATHRNG::RNGWrapper *m_randomEngine	ATLAS_THREAD_SAFE {}
Gaudi::Property< std::string >	m_randomEngineName
ServiceHandle< ISF::IGeoIDSvc >	m_geoIDSvc {this, "GeoIDSvc", "ISF::GeoIDSvc"}
PublicToolHandle< ActsTrk::IExtrapolationTool >	m_extrapolationTool {this, "ExtrapolationTool", "ActsExtrapolationTool"}
PublicToolHandle< ActsTrk::ITrackingGeometryTool >	m_trackingGeometryTool
std::shared_ptr< const Acts::TrackingGeometry >	m_trackingGeometry
SG::ReadCondHandleKey< AtlasFieldCacheCondObj >	m_fieldCacheCondObjInputKey {this, "AtlasFieldCacheCondObj", "fieldCondObj", "Name of the Magnetic Field conditions object key"}
std::shared_ptr< const Acts::Logger >	m_logger {nullptr}
PublicToolHandle< ISF::IParticleFilter >	m_particleFilter
ServiceHandle< ISF::ITruthSvc >	m_truthRecordSvc {this, "TruthRecordService", "ISF_TruthRecordSvc", ""}
ToolHandle< ActsFatrasWriteHandler >	m_ActsFatrasWriteHandler
Gaudi::Property< double >	m_interact_minPt
Gaudi::Property< bool >	m_meanEnergyLoss {this, "MeanEnergyLoss", true, "Toggle between mean and mode evaluation of energy loss"}
Gaudi::Property< bool >	m_includeGgradient {this, "IncludeGgradient", true, "Boolean flag for inclusion of d(dEds)d(q/p) into energy loss"}
Gaudi::Property< double >	m_momentumCutOff {this, "MomentumCutOff", 0., "Cut-off value for the momentum in SI units"}
Gaudi::Property< double >	m_maxStep
Gaudi::Property< double >	m_maxRungeKuttaStepTrials
Gaudi::Property< double >	m_maxStepSize
Gaudi::Property< double >	m_pathLimit
Gaudi::Property< bool >	m_loopProtection
Gaudi::Property< double >	m_loopFraction
Gaudi::Property< double >	m_tolerance
Gaudi::Property< double >	m_stepSizeCutOff
Gaudi::Property< std::map< int, int > >	m_processTypeMap

Detailed Description

Definition at line 73 of file ActsFatrasSimTool.h.

Member Typedef Documentation

ChargedInteractions

using ISF::ActsFatrasSimTool::ChargedInteractions

Initial value:

 
          ActsFatras::StandardChargedElectroMagneticInteractions

Definition at line 191 of file ActsFatrasSimTool.h.

ChargedPropagator

using ISF::ActsFatrasSimTool::ChargedPropagator = Acts::Propagator<ChargedStepper, Navigator>

Definition at line 182 of file ActsFatrasSimTool.h.

ChargedSelector

using ISF::ActsFatrasSimTool::ChargedSelector = ActsFatras::ChargedSelector

Definition at line 190 of file ActsFatrasSimTool.h.

ChargedSimulation

using ISF::ActsFatrasSimTool::ChargedSimulation

Initial value:

 SingleParticleSimulation<
          ChargedPropagator, ChargedInteractions, HitSurfaceSelector,
          ActsFatras::NoDecay>

Definition at line 193 of file ActsFatrasSimTool.h.

ChargedStepper

using ISF::ActsFatrasSimTool::ChargedStepper = Acts::EigenStepper<Acts::EigenStepperDefaultExtension>

Definition at line 181 of file ActsFatrasSimTool.h.

Generator

using ISF::ActsFatrasSimTool::Generator = std::ranlux48

Definition at line 177 of file ActsFatrasSimTool.h.

Navigator

using ISF::ActsFatrasSimTool::Navigator = Acts::Navigator

Definition at line 179 of file ActsFatrasSimTool.h.

NeutralInteractions

using ISF::ActsFatrasSimTool::NeutralInteractions = ActsFatras::InteractionList<ActsFatras::PhotonConversion>

Definition at line 198 of file ActsFatrasSimTool.h.

NeutralPropagator

using ISF::ActsFatrasSimTool::NeutralPropagator = Acts::Propagator<NeutralStepper, Navigator>

Definition at line 185 of file ActsFatrasSimTool.h.

NeutralSelector

using ISF::ActsFatrasSimTool::NeutralSelector = ActsFatras::NeutralSelector

Definition at line 197 of file ActsFatrasSimTool.h.

NeutralSimulation

using ISF::ActsFatrasSimTool::NeutralSimulation

Initial value:

 SingleParticleSimulation<
          NeutralPropagator, NeutralInteractions, ActsFatras::NoSurface,
          ActsFatras::NoDecay>

Definition at line 199 of file ActsFatrasSimTool.h.

NeutralStepper

using ISF::ActsFatrasSimTool::NeutralStepper = Acts::StraightLineStepper

Definition at line 184 of file ActsFatrasSimTool.h.

Simulation

using ISF::ActsFatrasSimTool::Simulation

Initial value:

 ActsFatras::Simulation<ChargedSelector, ChargedSimulation,
                                            NeutralSelector, NeutralSimulation>

Definition at line 203 of file ActsFatrasSimTool.h.

Constructor & Destructor Documentation

ActsFatrasSimTool()

ISF::ActsFatrasSimTool::ActsFatrasSimTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Definition at line 20 of file ActsFatrasSimTool.cxx.

    : BaseSimulatorTool(type, name, parent) {}

~ActsFatrasSimTool()

ISF::ActsFatrasSimTool::~ActsFatrasSimTool ( )

virtual

Definition at line 25 of file ActsFatrasSimTool.cxx.

{}

Member Function Documentation

checkStartSurface()

bool ISF::ActsFatrasSimTool::checkStartSurface ( const Acts::MagneticFieldContext & mctx, const Acts::GeometryContext & anygctx, const ChargedPropagator & chargedPropagator, const Acts::BoundTrackParameters & startParameters, Acts::Direction navDir = Acts::Direction::Forward(), double pathLimit = std::numeric_limits<double>::max() ) const

private

Definition at line 413 of file ActsFatrasSimTool.cxx.

{
 
  ATH_MSG_VERBOSE(name() << "::" << __FUNCTION__ << " begin");
  using ActorList =
  Acts::ActorList<Acts::detail::SteppingLogger, Acts::MaterialInteractor>;
  using PropagatorOptions = typename ChargedPropagator::template Options<ActorList>;
 
  ATH_MSG_VERBOSE(name() << "::" << __FUNCTION__ << " Setting up propagator options for start surface check.");
  PropagatorOptions options(anygctx, mctx);
  options.loopProtection = (Acts::VectorHelpers::perp(startParameters.momentum()) < 300 * 1_MeV);
  options.direction = navDir;
  options.pathLimit = pathLimit;
 
  // The state creation triggers the initial volume/surface lookup
  ATH_MSG_VERBOSE(name() << "::" << __FUNCTION__ << " Initializing propagator state with start parameters: position " 
              << startParameters.position(anygctx).transpose() << ", momentum " 
              << startParameters.momentum().transpose());
  auto state = chargedPropagator.makeState(options);
  ATH_MSG_VERBOSE(name() << "::" << __FUNCTION__ << " Created propagator state. Now initializing with start parameters.");
  auto initResult = chargedPropagator.initialize(state, startParameters);
  if (!initResult.ok()) {
    ATH_MSG_WARNING(name() << "::" << __FUNCTION__ << " Failed to initialize propagator state: " 
                << initResult.error().message());
    return false;
  }
  return true;
}

chronoStart()

const ChronoEntity * ISF::BaseSimulatorTool::chronoStart ( const IChronoSvc::ChronoTag & tag )

inlineinherited

wrapper call to start chrono with given tag

Definition at line 97 of file BaseSimulatorTool.h.

                                                                     {
      if (m_chrono) return m_chrono->chronoStart( tag);
      return nullptr;
    }

chronoStop()

const ChronoEntity * ISF::BaseSimulatorTool::chronoStop ( const IChronoSvc::ChronoTag & tag )

inlineinherited

wrapper call to stop chrono with given tag

Definition at line 103 of file BaseSimulatorTool.h.

                                                                    {
      if (m_chrono) return m_chrono->chronoStop( tag);
      return nullptr;
    }

convertMom3FromActs()

Amg::Vector3D ISF::ActsFatrasSimTool::convertMom3FromActs ( const Acts::Vector3 & actsMom )

inline

Convert ACTS momentum to Athena momentum.

Definition at line 207 of file ActsFatrasSimTool.h.

                                                                     {
    Amg::Vector3D threeMom{Amg::Vector3D::Zero()};
    threeMom[Amg::x] = ActsTrk::energyToAthena(actsMom[Acts::eMom0]);
    threeMom[Amg::y] = ActsTrk::energyToAthena(actsMom[Acts::eMom1]);
    threeMom[Amg::z] = ActsTrk::energyToAthena(actsMom[Acts::eMom2]);
    return threeMom;
  }

convertPos3FromActs()

Amg::Vector3D ISF::ActsFatrasSimTool::convertPos3FromActs ( const Acts::Vector3 & actsPos )

inline

Definition at line 215 of file ActsFatrasSimTool.h.

                                                                     {
    Amg::Vector3D pos{Amg::Vector3D::Zero()};
    pos[Amg::x] = ActsTrk::lengthToAthena(actsPos[Acts::ePos0]);
    pos[Amg::y] = ActsTrk::lengthToAthena(actsPos[Acts::ePos1]);
    pos[Amg::z] = ActsTrk::lengthToAthena(actsPos[Acts::ePos2]);
    return pos;
  }

getATLASProcessCode()

int ISF::ActsFatrasSimTool::getATLASProcessCode ( ActsFatras::ProcessType actspt )

inlineprivate

Definition at line 337 of file ActsFatrasSimTool.h.

{return m_processTypeMap[static_cast<uint32_t>(actspt)];};

getMagneticFieldContext()

Acts::MagneticFieldContext ISF::ActsFatrasSimTool::getMagneticFieldContext ( const EventContext & ctx ) const

virtual

Definition at line 402 of file ActsFatrasSimTool.cxx.

                                                                                                    {
  SG::ReadCondHandle<AtlasFieldCacheCondObj> readHandle{m_fieldCacheCondObjInputKey, ctx};
  if (!readHandle.isValid()) {
    ATH_MSG_ERROR(name() + ": Failed to retrieve magnetic field condition data " + m_fieldCacheCondObjInputKey.key() + ".");
  }
  else ATH_MSG_DEBUG(name() << "retrieved magnetic field condition data "<< m_fieldCacheCondObjInputKey.key());
  const AtlasFieldCacheCondObj* fieldCondObj{*readHandle};
 
  return Acts::MagneticFieldContext(fieldCondObj);
}

initialize()

StatusCode ISF::ActsFatrasSimTool::initialize ( )

overridevirtual

Reimplemented from ISF::BaseSimulatorTool.

Definition at line 27 of file ActsFatrasSimTool.cxx.

                                            {
  ATH_CHECK(BaseSimulatorTool::initialize());
  ATH_MSG_INFO("ISF::ActsFatrasSimTool update with ACTS version: v"
    << Acts::VersionMajor << "." << Acts::VersionMinor << "."
    << Acts::VersionPatch << " [" << Acts::CommitHash.value_or("unknown hash") << "]");
  // Retrieve particle filter
  ATH_CHECK(m_particleFilter.retrieve());
  ATH_MSG_INFO("Using particle filter: " << m_particleFilter.typeAndName());
  // setup logger
  m_logger = makeActsAthenaLogger(this, std::string("ActsFatras"),std::string("ActsFatrasSimTool"));
 
  // Geometry identifier service
  if ( !m_geoIDSvc.empty() && m_geoIDSvc.retrieve().isFailure()){
    ATH_MSG_FATAL ("Could not retrieve " << m_geoIDSvc);
    return StatusCode::FAILURE;
  }
 
  // Acts Extrapolator
  ATH_CHECK(m_extrapolationTool.retrieve());
  ATH_MSG_INFO( "- ActsExtrapolationTool : " << m_extrapolationTool.typeAndName() );
 
  // retrive tracking geo tool
  ATH_CHECK(m_trackingGeometryTool.retrieve());
  m_trackingGeometry = m_trackingGeometryTool->trackingGeometry();
  
  //retrive Magnetfield tool
  ATH_MSG_VERBOSE("Using ATLAS magnetic field service");
  ATH_CHECK( m_fieldCacheCondObjInputKey.initialize());
 
  // Random number service
  if (m_rngSvc.retrieve().isFailure()) {
    ATH_MSG_FATAL("Could not retrieve " << m_rngSvc);
    return StatusCode::FAILURE;
  }
  // Get own engine with own seeds
  m_randomEngine = m_rngSvc->getEngine(this, m_randomEngineName.value());
  if (!m_randomEngine) {
    ATH_MSG_FATAL("Could not get random engine '" << m_randomEngineName.value() << "'");
    return StatusCode::FAILURE;
  }
 
  // ISF truth service
  ATH_CHECK (m_truthRecordSvc.retrieve());
  ATH_MSG_DEBUG( "- Using ISF TruthRecordSvc : " << m_truthRecordSvc.typeAndName() );
  return StatusCode::SUCCESS;
}

releaseEvent()

virtual StatusCode ISF::ActsFatrasSimTool::releaseEvent ( const EventContext & )

inlineoverridevirtual

Release Event chain - in case of an end-of event action is needed.

Reimplemented from ISF::BaseSimulatorTool.

Definition at line 241 of file ActsFatrasSimTool.h.

                                                                    {
    std::vector<SiHitCollection> hitcolls;
    hitcolls.push_back(m_pixelSiHits);
    hitcolls.push_back(m_sctSiHits);
    ATH_CHECK(m_ActsFatrasWriteHandler->WriteHits(hitcolls,ctx));
    ATH_CHECK(m_truthRecordSvc->releaseEvent());
    return StatusCode::SUCCESS; };

releaseEventST()

virtual StatusCode ISF::BaseSimulatorTool::releaseEventST ( )

inlineoverridevirtualinherited

Release Event chain - in case of an end-of event action is needed (called by ISimulationSvc)

Reimplemented in ISF::BaseSimulatorG4Tool, and ISF::FastCaloSimV2Tool.

Definition at line 93 of file BaseSimulatorTool.h.

    { return releaseEvent(Gaudi::Hive::currentContext()); }

retrieveTool()

template<class T>

StatusCode ISF::ActsFatrasSimTool::retrieveTool ( ToolHandle< T > & thandle )

inlineprivate

Definition at line 260 of file ActsFatrasSimTool.h.

                                                  {
    if (!thandle.empty() && thandle.retrieve().isFailure()) {
      ATH_MSG_FATAL("Cannot retrieve " << thandle << ". Abort.");
      return StatusCode::FAILURE;
    } else ATH_MSG_DEBUG("Successfully retrieved " << thandle);
    return StatusCode::SUCCESS;
  }

setupEvent()

virtual StatusCode ISF::ActsFatrasSimTool::setupEvent ( const EventContext & )

inlineoverridevirtual

Setup Event chain - in case of a begin-of event action is needed.

Reimplemented from ISF::BaseSimulatorTool.

Definition at line 236 of file ActsFatrasSimTool.h.

                                                              {
    ATH_CHECK(m_truthRecordSvc->initializeTruthCollection());
    m_pixelSiHits.Clear();
    m_sctSiHits.Clear();
    return StatusCode::SUCCESS; };

setupEventST()

virtual StatusCode ISF::BaseSimulatorTool::setupEventST ( )

inlineoverridevirtualinherited

Setup Event chain - in case of a begin-of event action is needed (called by ISimulationSvc)

Reimplemented in ISF::BaseSimulatorG4Tool, and ISF::FastCaloSimV2Tool.

Definition at line 66 of file BaseSimulatorTool.h.

    { return setupEvent(Gaudi::Hive::currentContext()); }

simFlavor()

virtual ISF::SimulationFlavor ISF::ActsFatrasSimTool::simFlavor ( ) const

inlineoverridevirtual

Definition at line 248 of file ActsFatrasSimTool.h.

                                                        {
    return ISF::Fatras; };

simulate()

StatusCode ISF::ActsFatrasSimTool::simulate ( const EventContext & ctx, ISFParticle & isp, ISFParticleContainer & secondaries, McEventCollection * mcEventCollection )

overridevirtual

Reimplemented from ISF::BaseSimulatorTool.

Definition at line 74 of file ActsFatrasSimTool.cxx.

                                        {
  ATH_MSG_VERBOSE("Particle " << isp << " received for simulation.");
  // Check if particle passes filter, if there is one
  if (!m_particleFilter.empty() && !m_particleFilter->passFilter(isp)) {
    ATH_MSG_VERBOSE("ISFParticle " << isp << " does not pass selection. Ignoring.");
    return StatusCode::SUCCESS;
  }
  // Process ParticleState from particle stack
  // Wrap the input ISFParticle in an STL vector with size of 1
  const ISF::ISFParticleVector ispVector(1, &isp);
  ATH_CHECK(this->simulateVector(ctx, ispVector, secondaries, mcEventCollection));
  ATH_MSG_VERBOSE("Simulation done");
  return StatusCode::SUCCESS;
}

simulateVector()

StatusCode ISF::ActsFatrasSimTool::simulateVector ( const EventContext & ctx, const ISFParticleVector & particles, ISFParticleContainer & secondaries, McEventCollection * mcEventCollection, McEventCollection * = nullptr )

overridevirtual

Simulation call for vectors of particles.

Reimplemented from ISF::BaseSimulatorTool.

Definition at line 91 of file ActsFatrasSimTool.cxx.

                                                                                             {
  // filter particles
  std::vector<ISFParticle*> selectedParticles;
  for (const auto isfp : particles) {
    if (!m_particleFilter.empty() && !m_particleFilter->passFilter(*isfp)) {
      ATH_MSG_VERBOSE("ISFParticle " << *isfp << " does not pass selection. Ignoring.");
      continue;
    }
    selectedParticles.push_back(isfp);
  }
  if (selectedParticles.empty()) {
    ATH_MSG_VERBOSE("No particles passed selection. Ignoring.");
    return StatusCode::SUCCESS;
  }
  // Set random seed for current event                            
  m_randomEngine->setSeed(m_randomEngineName, ctx);
  CLHEP::HepRandomEngine* randomEngine = m_randomEngine->getEngine(ctx);
  Generator generator(CLHEP::RandFlat::shoot(randomEngine->flat()));
  ATH_MSG_VERBOSE(name() << " RNG seed " << CLHEP::RandFlat::shoot(randomEngine->flat()));
  ATH_MSG_VERBOSE(name() << " received vector of size "
               << selectedParticles.size() << " particles for simulation.");
 
  // construct the ACTS simulator
  Acts::Navigator navigator( Acts::Navigator::Config{ m_trackingGeometry }, m_logger);
  auto bField = std::make_shared<ATLASMagneticFieldWrapper>();
  auto chargedStepper = ChargedStepper(std::move(bField));
  auto neutralStepper = NeutralStepper();
  auto chargedPropagator = ChargedPropagator(chargedStepper, navigator, m_logger);
  auto neutralPropagator = NeutralPropagator(neutralStepper, navigator, m_logger);
  ChargedSimulation simulatorCharged(std::move(chargedPropagator), m_logger);
  NeutralSimulation simulatorNeutral(std::move(neutralPropagator), m_logger);
  Simulation simulator=Simulation(std::move(simulatorCharged),std::move(simulatorNeutral));
  ATH_MSG_VERBOSE(name() << " Min pT for interaction " << m_interact_minPt * Acts::UnitConstants::MeV << " GeV");
  // Acts propagater options
  simulator.charged.maxStepSize = m_maxStepSize;
  simulator.charged.maxStep = m_maxStep;
  simulator.charged.pathLimit = m_pathLimit;
  simulator.charged.maxRungeKuttaStepTrials = m_maxRungeKuttaStepTrials;
  simulator.charged.loopProtection = m_loopProtection;
  simulator.charged.loopFraction = m_loopFraction;
  simulator.charged.targetTolerance = m_tolerance;
  simulator.charged.stepSizeCutOff = m_stepSizeCutOff;
  // Create interaction list
  simulator.charged.interactions = ActsFatras::makeStandardChargedElectroMagneticInteractions(m_interact_minPt * Acts::UnitConstants::MeV);
 
  // Construct the ACTS propagator for starting surface check
  auto surfaceCheckPropagator = ChargedPropagator(chargedStepper, navigator);
  
  // get Geo and Mag map
  ATH_MSG_VERBOSE(name() << " Getting per event Geo and Mag map");
  Acts::MagneticFieldContext mctx = getMagneticFieldContext(ctx);
  const auto& gctx = m_trackingGeometryTool->getGeometryContext(ctx);
  auto anygctx = gctx.context();
  // Loop over ISFParticleVector and process each separately
  ATH_MSG_VERBOSE(name() << " Processing particles in ISFParticleVector.");
  for (const auto isfp : selectedParticles) {
    // ====ACTSFatras Simulation====
    // //  
    // input/output particle and hits containers
    // Convert to ActsFatras::Particle
    // ISF: Energy, mass, and momentum are in MeV, position in mm
    // Acts: Energy, mass, and momentum are in GeV, position in mm
    ATH_MSG_DEBUG(name() << " Convert ISF::Particle(mass) " << isfp->id()<<"|" << *isfp<<"(" << isfp->mass() << ")");
    std::vector<ActsFatras::Particle> input = std::vector<ActsFatras::Particle>{
      ActsFatras::Particle(ActsFatras::Barcode().withVertexPrimary(0).withParticle(isfp->id()), static_cast<Acts::PdgParticle>(isfp->pdgCode()),
                           isfp->charge(),isfp->mass() * Acts::UnitConstants::MeV)
        .setDirection(Acts::makeDirectionFromPhiEta(isfp->momentum().phi(), isfp->momentum().eta()))
        .setAbsoluteMomentum(isfp->momentum().mag() * Acts::UnitConstants::MeV)
        .setPosition4(ActsTrk::convertPosToActs(isfp->position(), isfp->timeStamp()))};
    ATH_MSG_DEBUG(name() << " Propagating ActsFatras::Particle  vertex|particle|generation|subparticle, " << input[0]);
    std::vector<ActsFatras::Particle> simulatedInitial;
    std::vector<ActsFatras::Particle> simulatedFinal;
    std::vector<ActsFatras::Hit> hits;
    // simulate
    auto result=simulator.simulate(anygctx, mctx, generator, input, simulatedInitial, simulatedFinal, hits);
    auto simulatedFailure=result.value();
    if (simulatedFailure.size()>0){
      for (const auto& simfail : simulatedFailure){
        auto errCode = Acts::make_error_code(Acts::PropagatorError(simfail.error.value()));
        ATH_MSG_WARNING(name() << " Particle id " <<simfail.particle.particleId()<< ": fail to be simulated during Propagation: " << errCode.message());
        ATH_MSG_WARNING(name() << " Particle vertex|particle|generation|subparticle"<<simfail.particle << " starts from position" << Acts::toString(simfail.particle.position()) << " and direction " << Acts::toString(simfail.particle.direction()));
        return StatusCode::SUCCESS;
      }
    }
 
    ATH_MSG_DEBUG(name() << " initial particle " << simulatedInitial[0]);
    ATH_MSG_DEBUG(name() << " ActsFatras simulator hits: " << hits.size());
    int i = 0;
    for (const auto& hit : hits) {
      ATH_MSG_DEBUG(name() << " hit pos: " << hit.position() );
      ++i;
      if (i>5) break;
    }
    ATH_MSG_DEBUG(name() << " No. of particles after ActsFatras simulator: " << simulatedFinal.size());
    if (!simulatedFinal.empty()){
      ATH_MSG_DEBUG(name() << " start procesing secondaries");
      auto itr = simulatedFinal.begin();
      // Save hits of isfp
      std::vector<ActsFatras::Hit> particle_hits;
      if (itr->numberOfHits() > 0) {
        std::copy(hits.begin(), hits.begin()+itr->numberOfHits(), std::back_inserter(particle_hits));
        m_ActsFatrasWriteHandler->createHits(*isfp, m_trackingGeometry,particle_hits,m_pixelSiHits,m_sctSiHits);
      }
      // Process secondaries
      auto isKilled = !itr->isAlive();
      int maxGeneration = simulatedFinal.back().particleId().generation();
      ATH_MSG_DEBUG(name() << " maxGeneration: "<< maxGeneration);
      for (int gen = 0; gen <= maxGeneration; ++gen){
        ATH_MSG_DEBUG(name() << " start with generation "<< gen << "|" << maxGeneration << ": "<< *itr);
        auto vecsecisfp = std::make_unique<ISF::ISFParticleVector>();
        std::unique_ptr<ISF::ISFParticle> newisfp = nullptr;  // Boundary crossing particle
        
        while (itr != simulatedFinal.end() && static_cast<int>(itr->particleId().generation()) == gen) {
          ATH_MSG_DEBUG(name() << " genration "<< gen << "|" << maxGeneration << ": "<< *itr);
          if(itr->isSecondary()){
            // convert final particles to ISF::particle
            const auto pos = ActsTrk::convertPosFromActs(itr->fourPosition()).first;
            const auto mom = ActsTrk::convertMomFromActs(itr->fourMomentum()).first;
            double mass = itr->mass() / Acts::UnitConstants::MeV;
            double charge = itr->charge();
            int pdgid = itr->pdg();
            auto properTime = ActsTrk::timeToAthena(itr->time());
            const int status = 1 + HepMC::SIM_STATUS_THRESHOLD;
            const int id = HepMC::UNDEFINED_ID;
            auto secisfp = std::make_unique<ISF::ISFParticle>(pos,mom,mass,charge,pdgid,status,properTime,*isfp,id);
            secisfp->setNextGeoID(m_geoIDSvc->identifyNextGeoID(*secisfp));
            ATH_MSG_DEBUG(name() <<" secondaries particle (ACTS): "<<*itr<< "("<<itr->momentum()<<")|time "<<itr->time()<<"|process "<< getATLASProcessCode(itr->process()));
            ATH_MSG_DEBUG(name() <<" secondaries particle (ISF): pdg=" << secisfp->pdgCode() 
              << " pos=" << secisfp->position() << " mom=" << secisfp->momentum() 
              << " GeoID=" << m_geoIDSvc->identifyNextGeoID(*secisfp));
            vecsecisfp->push_back(secisfp.release());
          }
          else{
            // Primary particle handling
            ATH_MSG_DEBUG(name() <<" primary particle found with generation ("<< gen <<")");
            // After simulation, check particle's final state
            if (!isKilled) {
              auto fisfp = std::make_unique<ISF::ISFParticle>(*isfp);
              fisfp->updateMomentum(ActsTrk::convertMomFromActs(itr->fourMomentum()).first);
              fisfp->updatePosition(ActsTrk::convertPosFromActs(itr->fourPosition()).first);
              ATH_MSG_DEBUG(name() << " After simulation, primary particle state: " << *fisfp);
              if (!m_particleFilter.empty() && !m_particleFilter->passFilter(*fisfp)) {
                ATH_MSG_VERBOSE("ISFParticle" << fisfp << "  after simulation does not pass selection. Ignoring for boundary check.");
                continue;
              }
              ATH_MSG_DEBUG(name() << " [ISF] original GeoID: " <<  m_geoIDSvc->identifyGeoID(*isfp) 
                            << " new particle GeoID: " << m_geoIDSvc->identifyGeoID(*fisfp) 
                            << ", nextGeoID: " << m_geoIDSvc->identifyNextGeoID(*fisfp));
 
              // Use ActsExtrapolationTool
              ATH_MSG_DEBUG(name() << " Extrapolating using ActsExtrapolationTool");
              
              // Convert to ACTS BoundTrackParameters for extrapolation
              Acts::BoundTrackParameters startParams = Acts::BoundTrackParameters::createCurvilinear(
                  itr->fourPosition(), itr->direction(), itr->qOverP(), std::nullopt, itr->hypothesis());
 
              //=============== try if a starting surface exist before passing to Extrapolator ==
              auto do_exit_startsurface = checkStartSurface(mctx, anygctx, surfaceCheckPropagator, startParams);
              ATH_MSG_DEBUG(name() << " checkStartSurface returned: " << do_exit_startsurface);
              if (do_exit_startsurface) {
                ATH_MSG_DEBUG(name() << " Particle starts at a valid surface, doing extrapolation...");
              
                // Extrapolate and get propagation steps
                auto nextGeoID = AtlasDetDescr::fUndefinedAtlasRegion;
                Amg::Vector3D entryPos{Amg::Vector3D::Zero()};
                try {
                  auto stepsResult = m_extrapolationTool->propagationSteps(ctx, startParams, Acts::Direction::Forward());
                  auto steps = stepsResult.value().first;
                  ATH_MSG_DEBUG(name() << " Number of propagation steps: " << steps.size());
                  if (steps.size() != 0) {
                    for (const auto& step : steps) {
                      ATH_MSG_DEBUG(name() << " [Acts] Step at position " << step.position 
                                    << " (eta " << Acts::VectorHelpers::eta(step.position) 
                                    << ") with GeoID " << step.geoID);
                      entryPos = convertPos3FromActs(step.position);
                      nextGeoID = m_geoIDSvc->identifyGeoID(entryPos);
                      ATH_MSG_DEBUG(name() << " [Acts] GeoID from service: " << nextGeoID);
                      if (nextGeoID > AtlasDetDescr::fAtlasID) { // Valid boundary crossing
                        ATH_MSG_DEBUG(name() << " Boundary crossing detected at GeoID " << nextGeoID);
                        break;
                      }
                    }
                  } else {
                    ATH_MSG_WARNING(name() << " No propagation steps returned by ActsExtrapolationTool");
                  }
                }
                catch (const std::exception& e) {
                  ATH_MSG_WARNING(name() << " extrapolation [" << m_extrapolationTool.name() << "] failed: " << e.what() << "\nSkip boundary check for " << *fisfp);
                  break; // Skip boundary check for this particle and continue with next one
                }
 
                if (fisfp && nextGeoID > AtlasDetDescr::fAtlasID){
                  const auto mom = ActsTrk::convertMomFromActs(itr->fourMomentum()).first;
                  double mass = itr->mass() / Acts::UnitConstants::MeV;
                  double charge = itr->charge();
                  int pdgid = itr->pdg();
                  auto properTime = ActsTrk::timeToAthena(itr->time());
                  
                  // Create boundary crossing particle
                  newisfp = std::make_unique<ISF::ISFParticle>(entryPos, mom, mass, charge, pdgid, isfp->status(), properTime, *isfp, isfp->id(), isfp->barcode());
                  newisfp->setNextGeoID(nextGeoID);
                  ATH_MSG_DEBUG(name() << " Truthbinding of parent ISFParticle: " << (isfp->getTruthBinding() ? "exists" : "null"));
                  if (isfp->getTruthBinding()) {
                    ATH_MSG_DEBUG(name() << " Current GenParticle: " << isfp->getTruthBinding()->getCurrentGenParticle());
                  }
                  ATH_MSG_DEBUG(name() << " Created new ISFParticle at boundary with nextGeoID: " 
                                  << AtlasDetDescr::AtlasRegionHelper::getName(nextGeoID) 
                                  << "(" << nextGeoID << ")");
                }
 
                // Handle boundary crossing particle separately - DON'T add to vecsecisfp yet
                if (newisfp && nextGeoID > AtlasDetDescr::fAtlasID) {
                  ATH_MSG_DEBUG(name() << " [ISF] Processing boundary particle with nextGeoID: " 
                                << AtlasDetDescr::AtlasRegionHelper::getName(newisfp->nextGeoID()) 
                                << "(" << newisfp->nextGeoID() << ")");
                  
                  // Identify Entrylayer
                  ISF::EntryLayer entryLayer = ISF::fUnsetEntryLayer;
                  
                  switch(nextGeoID) {
                    case AtlasDetDescr::fAtlasCalo:
                      entryLayer = ISF::fAtlasCaloEntry;
                      ATH_MSG_DEBUG("Particle crossing to Calorimeter");
                      break;
                    case AtlasDetDescr::fAtlasMS:
                      entryLayer = ISF::fAtlasMuonEntry;
                      ATH_MSG_DEBUG("Particle crossing to Muon System");
                      break;
                    default:
                      ATH_MSG_DEBUG("Particle at unspecified boundary");
                      break;
                  }
                  
                  if (entryLayer != ISF::fUnsetEntryLayer) {
                        vecsecisfp->push_back(newisfp.release()); // Add boundary crossing particle to secondaries vector
                  } else {
                    ATH_MSG_WARNING("Invalid entry layer for boundary particle");
                  }
                }
              }
              else {
                ATH_MSG_DEBUG(name() << " No starting surface found, skipping boundary check and extrapolation.");
              }
            } // end of !isKilled
          } // end of primary vs secondary
          ++itr;
        } // end of while loop over particles in generation
 
        // Process truth for this generation
        if (!vecsecisfp->empty()) {
          // Determine process code and geoID based on whether we have boundary crossing
          int processCode = 0;
          AtlasDetDescr::AtlasRegion geoID = AtlasDetDescr::fAtlasID;
          auto isParentKilled = ISF::fPrimarySurvives;
          
          if (newisfp) {
            // Boundary crossing - use boundary info
            processCode = 91;  // Boundary crossing has no process
            geoID = newisfp->nextGeoID();
            isParentKilled = ISF::fKillsPrimary;
          } else {
            // Regular secondaries - use process from last particle
            processCode = getATLASProcessCode((itr-1)->process());
            geoID = (isfp->nextGeoID() <= AtlasDetDescr::fUndefinedAtlasRegion) ? 
                    AtlasDetDescr::fAtlasID : isfp->nextGeoID();
            isParentKilled = isKilled && gen==maxGeneration ? ISF::fKillsPrimary : ISF::fPrimarySurvives;
          }
          
          ISF::ISFTruthIncident truth(*isfp,
                                      *vecsecisfp,
                                      processCode,
                                      geoID,
                                      isParentKilled);
          
          ATH_MSG_DEBUG(name() << " Truth incident parentPt2(MinPt2) " << truth.parentPt2() <<" (100 MeV)");
          ATH_MSG_DEBUG(name() << " Truth incident ChildPt2(MinPt2) " << truth.childrenPt2Pass(300) <<" (300 MeV)");
          m_truthRecordSvc->registerTruthIncident(truth,  true);
          truth.updateParentAfterIncidentProperties();
          truth.updateChildParticleProperties();          
          for (auto *secisfp : *vecsecisfp){
            if (secisfp->getTruthBinding()) {
              secondaries.push_back(secisfp);
              ATH_MSG_DEBUG(name() << " Secondary particle written out to truth.\n Parent (" 
                              << *isfp << ")\n Secondary (" << *secisfp <<")");
 
              ATH_MSG_DEBUG("Secondary particle push back to ISF, TruthBinding: " << secisfp->getTruthBinding()->getCurrentGenParticle() << " (current) | " << secisfp->getTruthBinding()->getPrimaryGenParticle() << " (primary) | " << secisfp->getTruthBinding()->getGenerationZeroGenParticle() << " (zero)");
              if (secisfp->getTruthBinding()->getCurrentGenParticle() != nullptr) ATH_MSG_DEBUG("Secondary particle GenParticle EndVertex: " << (secisfp->getTruthBinding()->getCurrentGenParticle()->end_vertex() ? HepMC::barcode(secisfp->getTruthBinding()->getCurrentGenParticle()->end_vertex()) : 1));
            } else {
              ATH_MSG_WARNING("Secondary particle not written out to truth.\n Parent (" 
                              << *isfp << ")\n Secondary (" << *secisfp <<")");
              delete secisfp; // Clean up particles without truth binding
            }
          }
        }
      } // end of generation loop
    } // end of !simulatedFinal.empty()
    ATH_MSG_VERBOSE(name() << " No. of secondaries: " << secondaries.size());
    ATH_MSG_DEBUG(name() << " End of particle " << isfp->id());
 
    std::vector<ActsFatras::Particle>().swap(input);
    std::vector<ActsFatras::Particle>().swap(simulatedInitial);
    std::vector<ActsFatras::Particle>().swap(simulatedFinal);
    std::vector<ActsFatras::Hit>().swap(hits);
  } // end of isfp loop
  return StatusCode::SUCCESS;
}

sysInitialize()

virtual StatusCode ISF::BaseSimulatorTool::sysInitialize ( )

inlineoverridevirtualinherited

Gaudi sysInitialize() methods.

Definition at line 48 of file BaseSimulatorTool.h.

    {
      ATH_CHECK( AthAlgTool::sysInitialize() );
      ATH_CHECK( m_chrono.retrieve() );
      return StatusCode::SUCCESS;
    }

Member Data Documentation

ATLAS_THREAD_SAFE

ATHRNG::RNGWrapper* m_randomEngine ISF::ActsFatrasSimTool::ATLAS_THREAD_SAFE {}

private

Definition at line 277 of file ActsFatrasSimTool.h.

{};

m_ActsFatrasWriteHandler

ToolHandle<ActsFatrasWriteHandler> ISF::ActsFatrasSimTool::m_ActsFatrasWriteHandler

private

Initial value:

{
      this, "ActsFatrasWriteHandler", "ActsFatrasWriteHandler"}

Definition at line 305 of file ActsFatrasSimTool.h.

                                                             {
      this, "ActsFatrasWriteHandler", "ActsFatrasWriteHandler"};

m_chrono

ServiceHandle<IChronoStatSvc> ISF::BaseSimulatorTool::m_chrono {this, "ChronoStatService", "ChronoStatSvc"}

protectedinherited

The timing service for general usage.

Definition at line 114 of file BaseSimulatorTool.h.

{this, "ChronoStatService", "ChronoStatSvc"};

m_extrapolationTool

PublicToolHandle<ActsTrk::IExtrapolationTool> ISF::ActsFatrasSimTool::m_extrapolationTool {this, "ExtrapolationTool", "ActsExtrapolationTool"}

private

Definition at line 285 of file ActsFatrasSimTool.h.

{this, "ExtrapolationTool", "ActsExtrapolationTool"};

m_fieldCacheCondObjInputKey

SG::ReadCondHandleKey<AtlasFieldCacheCondObj> ISF::ActsFatrasSimTool::m_fieldCacheCondObjInputKey {this, "AtlasFieldCacheCondObj", "fieldCondObj", "Name of the Magnetic Field conditions object key"}

private

Definition at line 293 of file ActsFatrasSimTool.h.

{this, "AtlasFieldCacheCondObj", "fieldCondObj", "Name of the Magnetic Field conditions object key"};

m_geoIDSvc

ServiceHandle<ISF::IGeoIDSvc> ISF::ActsFatrasSimTool::m_geoIDSvc {this, "GeoIDSvc", "ISF::GeoIDSvc"}

private

Definition at line 282 of file ActsFatrasSimTool.h.

{this, "GeoIDSvc", "ISF::GeoIDSvc"};

m_includeGgradient

Gaudi::Property<bool> ISF::ActsFatrasSimTool::m_includeGgradient {this, "IncludeGgradient", true, "Boolean flag for inclusion of d(dEds)d(q/p) into energy loss"}

private

Definition at line 313 of file ActsFatrasSimTool.h.

{this, "IncludeGgradient", true, "Boolean flag for inclusion of d(dEds)d(q/p) into energy loss"};

m_interact_minPt

Gaudi::Property<double> ISF::ActsFatrasSimTool::m_interact_minPt

private

Initial value:

{this, "Interact_MinPt", 50.0,
      "Min pT of the interactions (MeV)"}

Definition at line 308 of file ActsFatrasSimTool.h.

                                        {this, "Interact_MinPt", 50.0,
      "Min pT of the interactions (MeV)"};

m_logger

std::shared_ptr<const Acts::Logger> ISF::ActsFatrasSimTool::m_logger {nullptr}

private

Definition at line 296 of file ActsFatrasSimTool.h.

{nullptr};

m_loopFraction

Gaudi::Property<double> ISF::ActsFatrasSimTool::m_loopFraction

private

Initial value:

{this, "LoopFraction", 0.5,
      "Allowed loop fraction, 1 is a full loop"}

Definition at line 326 of file ActsFatrasSimTool.h.

                                      {this, "LoopFraction", 0.5,
      "Allowed loop fraction, 1 is a full loop"};

m_loopProtection

Gaudi::Property<bool> ISF::ActsFatrasSimTool::m_loopProtection

private

Initial value:

{this, "LoopProtection", true,
      "Loop protection, it adapts the pathLimit"}

Definition at line 324 of file ActsFatrasSimTool.h.

                                      {this, "LoopProtection", true,
      "Loop protection, it adapts the pathLimit"};

m_maxRungeKuttaStepTrials

Gaudi::Property<double> ISF::ActsFatrasSimTool::m_maxRungeKuttaStepTrials

private

Initial value:

{this, "MaxRungeKuttaStepTrials", 10000,
       "Maximum number of Runge-Kutta steps for the stepper step call"}

Definition at line 318 of file ActsFatrasSimTool.h.

                                                 {this, "MaxRungeKuttaStepTrials", 10000,
       "Maximum number of Runge-Kutta steps for the stepper step call"};

m_maxStep

Gaudi::Property<double> ISF::ActsFatrasSimTool::m_maxStep

private

Initial value:

{this, "MaxSteps", 1000,
       "Max number of steps"}

Definition at line 316 of file ActsFatrasSimTool.h.

                                 {this, "MaxSteps", 1000,
       "Max number of steps"};

m_maxStepSize

Gaudi::Property<double> ISF::ActsFatrasSimTool::m_maxStepSize

private

Initial value:

{this, "MaxStepSize", 3.0,
      "Max step size (converted to Acts::UnitConstants::m)"}

Definition at line 320 of file ActsFatrasSimTool.h.

                                     {this, "MaxStepSize", 3.0,
      "Max step size (converted to Acts::UnitConstants::m)"};

m_meanEnergyLoss

Gaudi::Property<bool> ISF::ActsFatrasSimTool::m_meanEnergyLoss {this, "MeanEnergyLoss", true, "Toggle between mean and mode evaluation of energy loss"}

private

Definition at line 312 of file ActsFatrasSimTool.h.

{this, "MeanEnergyLoss", true, "Toggle between mean and mode evaluation of energy loss"};

m_momentumCutOff

Gaudi::Property<double> ISF::ActsFatrasSimTool::m_momentumCutOff {this, "MomentumCutOff", 0., "Cut-off value for the momentum in SI units"}

private

Definition at line 314 of file ActsFatrasSimTool.h.

{this, "MomentumCutOff", 0., "Cut-off value for the momentum in SI units"};

m_particleFilter

PublicToolHandle<ISF::IParticleFilter> ISF::ActsFatrasSimTool::m_particleFilter

private

Initial value:

{
      this, "ParticleFilter", "", "Particle filter kinematic cuts, etc."}

Definition at line 299 of file ActsFatrasSimTool.h.

                                                       {
      this, "ParticleFilter", "", "Particle filter kinematic cuts, etc."};

m_pathLimit

Gaudi::Property<double> ISF::ActsFatrasSimTool::m_pathLimit

private

Initial value:

{this, "PathLimit", 100.0,
      "Track path limit (converted to Acts::UnitConstants::cm)"}

Definition at line 322 of file ActsFatrasSimTool.h.

                                   {this, "PathLimit", 100.0,
      "Track path limit (converted to Acts::UnitConstants::cm)"};

m_pixelSiHits

SiHitCollection ISF::ActsFatrasSimTool::m_pixelSiHits

private

Definition at line 256 of file ActsFatrasSimTool.h.

m_processTypeMap

Gaudi::Property<std::map<int,int> > ISF::ActsFatrasSimTool::m_processTypeMap

private

Initial value:

{this, "ProcessTypeMap",
      {{0,0}, {1,201}, {2,14}, {3,3}, {4,121}}, "proessType map <ActsFatras,G4>"}

Definition at line 334 of file ActsFatrasSimTool.h.

                                                 {this, "ProcessTypeMap",
      {{0,0}, {1,201}, {2,14}, {3,3}, {4,121}}, "proessType map <ActsFatras,G4>"};

m_randomEngineName

Gaudi::Property<std::string> ISF::ActsFatrasSimTool::m_randomEngineName

private

Initial value:

{this, "RandomEngineName",
    "RandomEngineName", "Name of random number stream"}

Definition at line 278 of file ActsFatrasSimTool.h.

                                             {this, "RandomEngineName",
    "RandomEngineName", "Name of random number stream"};

m_rngSvc

ServiceHandle<IAthRNGSvc> ISF::ActsFatrasSimTool::m_rngSvc {this, "RNGService", "AthRNGSvc"}

private

Definition at line 276 of file ActsFatrasSimTool.h.

{this, "RNGService", "AthRNGSvc"};

m_sctSiHits

SiHitCollection ISF::ActsFatrasSimTool::m_sctSiHits

private

Definition at line 257 of file ActsFatrasSimTool.h.

m_stepSizeCutOff

Gaudi::Property<double> ISF::ActsFatrasSimTool::m_stepSizeCutOff

private

Initial value:

{this, "StepSizeCutOff", 0.,
       "Cut-off value for the step size"}

Definition at line 330 of file ActsFatrasSimTool.h.

                                        {this, "StepSizeCutOff", 0.,
       "Cut-off value for the step size"};

m_tolerance

Gaudi::Property<double> ISF::ActsFatrasSimTool::m_tolerance

private

Initial value:

{this, "Tolerance", 0.0001,
       "Tolerance for the error of the integration"}

Definition at line 328 of file ActsFatrasSimTool.h.

                                   {this, "Tolerance", 0.0001,
       "Tolerance for the error of the integration"};

m_trackingGeometry

std::shared_ptr<const Acts::TrackingGeometry> ISF::ActsFatrasSimTool::m_trackingGeometry

private

Definition at line 290 of file ActsFatrasSimTool.h.

m_trackingGeometryTool

PublicToolHandle<ActsTrk::ITrackingGeometryTool> ISF::ActsFatrasSimTool::m_trackingGeometryTool

private

Initial value:

{
      this, "TrackingGeometryTool", "ActsTrackingGeometryTool"}

Definition at line 288 of file ActsFatrasSimTool.h.

                                                                       {
      this, "TrackingGeometryTool", "ActsTrackingGeometryTool"};

m_truthRecordSvc

ServiceHandle<ISF::ITruthSvc> ISF::ActsFatrasSimTool::m_truthRecordSvc {this, "TruthRecordService", "ISF_TruthRecordSvc", ""}

private

Definition at line 302 of file ActsFatrasSimTool.h.

{this, "TruthRecordService", "ISF_TruthRecordSvc", ""};

---

The documentation for this class was generated from the following files:

• ActsFatrasSimTool.h
• ActsFatrasSimTool.cxx