Tool for ACTS Fatras G4. More...

#include <ActsFatrasG4Tool.h>

Inheritance diagram for ActsFatrasG4Tool:

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...
struct	EventCache

Public Member Functions
virtual	~ActsFatrasG4Tool ()=default
virtual StatusCode	initialize () override
	AlgTool initialize method.
virtual StatusCode	finalize () override
	AlgTool finalize method.
StatusCode	initializePhysics () override
	AlgTool initializePhysics method.
virtual void	simulateFatrasTrack (const G4FastTrack &fastTrack, G4FastStep &fastStep) override
	create ActsFatras track, exposed via interface
virtual const std::vector< SiHit > &	getPixelHitsCache (const EventContext &ctx) const override
	for saving si hits caches, expose to the interface
virtual const std::vector< SiHit > &	getSCTHitsCache (const EventContext &ctx) const override
virtual void	clearCaches (const EventContext &ctx) const override

Protected Attributes
const PixelID *	m_pixIdHelper {nullptr}
	the Pixel ID helper
const SCT_ID *	m_sctIdHelper {nullptr}
	the SCT ID helper

Private 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 = ActsFatras::StandardChargedElectroMagneticInteractions
using	ChargedSimulation
using	NeutralSelector = ActsFatras::NeutralSelector
using	NeutralInteractions = ActsFatras::InteractionList<ActsFatras::PhotonConversion>
using	NeutralSimulation
using	Simulation

Private Member Functions
StatusCode	configureSimulator ()
void	debugTrackRegion (const G4FastTrack &fastTrack) const
std::vector< ActsFatras::Particle >	buildActsInputFromG4 (const G4Track &track)
void	handleSimulationFailures (const Acts::Result< ActsFatras::SingleParticleSimulationResult > &result)
StatusCode	applyPrimaryUpdate (const G4Track &, const std::vector< ActsFatras::Particle > &simulatedFinalParticles, G4FastStep &fastStep)
StatusCode	spawnSecondaries (const std::vector< ActsFatras::Particle > &simulatedFinal, const G4Track &, G4FastStep &fastStep)
StatusCode	createHitsFromG4 (const EventContext &ctx, const G4Track &track, const Acts::TrackingGeometry &trackingGeometry, const std::vector< ActsFatras::Hit > &hits) const
StatusCode	runDebugInjection (const EventContext &ctx, const G4Track &track, const Acts::GeometryContext &anygctx, const Acts::MagneticFieldContext &mctx, Generator &generator, G4FastStep &fastStep)
int	getATLASProcessCode (ActsFatras::GenerationProcess actspt)
EventCache &	getCache (const EventContext &ctx) const

Private Attributes
ActsTrk::ContextUtility	m_ctxProvider {this}
	Context provider for geometry, magnetic field and calibration contexts.
std::unique_ptr< Navigator >	m_navigator
std::shared_ptr< ATLASMagneticFieldWrapper >	m_bField
std::unique_ptr< Simulation >	m_simulator
ServiceHandle< IAthRNGSvc >	m_rngSvc {this, "RNGService", "AthRNGSvc"}
ATHRNG::RNGWrapper *m_randomEngine	ATLAS_THREAD_SAFE {}
Gaudi::Property< std::string >	m_randomEngineName {this, "RandomEngineName", "RandomEngineName", "Name of random number stream"}
ServiceHandle< ActsTrk::ITrackingGeometrySvc >	m_trackingGeometrySvc {this, "TrackingGeometrySvc", "ActsTrackingGeometrySvc"}
std::shared_ptr< const Acts::TrackingGeometry >	m_trackingGeometry
std::shared_ptr< const Acts::Logger >	m_logger {nullptr}
Gaudi::Property< double >	m_interact_minPt {this, "Interact_MinPt", 50.0, "Min pT of the interactions (MeV)"}
Gaudi::Property< bool >	m_meanEnergyLoss {this, "MeanEnergyLoss", true, "Toggle between mean and mode evaluation of energy loss"}
Gaudi::Property< bool >	m_includeGradient {this, "IncludeGradient", 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 {this, "MaxSteps", 2000, "Max number of steps"}
Gaudi::Property< double >	m_maxRungeKuttaStepTrials {this, "MaxRungeKuttaStepTrials", 10000, "Max number of Runge-Kutta steps for the stepper step call"}
Gaudi::Property< double >	m_maxStepSize {this, "MaxStepSize", 3.0, "Max step size (converted to Acts::UnitConstants::m)"}
Gaudi::Property< double >	m_pathLimit {this, "PathLimit", 3000.0, "Track path limit (converted to Acts::UnitConstants::cm)"}
Gaudi::Property< bool >	m_loopProtection {this, "LoopProtection", true, "Loop protection, it adapts the pathLimit"}
Gaudi::Property< double >	m_loopFraction {this, "LoopFraction", 0.5, "Allowed loop fraction, 1 is a full loop"}
Gaudi::Property< double >	m_tolerance {this, "Tolerance", 0.0001, "Tolerance for the error of the integration"}
Gaudi::Property< double >	m_stepSizeCutOff {this, "StepSizeCutOff", 0., "Cut-off value for the step size"}
Gaudi::Property< std::map< int, int > >	m_processTypeMap
SG::SlotSpecificObj< EventCache > m_eventCache	ATLAS_THREAD_SAFE
Gaudi::Property< bool >	m_debugInject {this, "DebugInjectParticle", false}

Detailed Description

Tool for ACTS Fatras G4.

Author: maril.nosp@m.ena..nosp@m.bandi.nosp@m.eram.nosp@m.onte@.nosp@m.cern.nosp@m..ch, rui.w.nosp@m.ang@.nosp@m.cern..nosp@m.ch, firda.nosp@m.us.s.nosp@m.oberi.nosp@m.@cer.nosp@m.n.ch

Definition at line 89 of file ActsFatrasG4Tool.h.

Member Typedef Documentation

◆ ChargedInteractions

using ActsFatrasG4Tool::ChargedInteractions = ActsFatras::StandardChargedElectroMagneticInteractions

private

Definition at line 229 of file ActsFatrasG4Tool.h.

◆ ChargedPropagator

using ActsFatrasG4Tool::ChargedPropagator = Acts::Propagator<ChargedStepper, Navigator>

private

Definition at line 223 of file ActsFatrasG4Tool.h.

◆ ChargedSelector

using ActsFatrasG4Tool::ChargedSelector = ActsFatras::ChargedSelector

private

Definition at line 228 of file ActsFatrasG4Tool.h.

◆ ChargedSimulation

using ActsFatrasG4Tool::ChargedSimulation

private

Initial value:

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

Definition at line 230 of file ActsFatrasG4Tool.h.

◆ ChargedStepper

using ActsFatrasG4Tool::ChargedStepper = Acts::EigenStepper<Acts::EigenStepperDefaultExtension>

private

Definition at line 222 of file ActsFatrasG4Tool.h.

◆ Generator

using ActsFatrasG4Tool::Generator = std::ranlux48

private

Definition at line 215 of file ActsFatrasG4Tool.h.

◆ Navigator

using ActsFatrasG4Tool::Navigator = Acts::Navigator

private

Definition at line 220 of file ActsFatrasG4Tool.h.

◆ NeutralInteractions

using ActsFatrasG4Tool::NeutralInteractions = ActsFatras::InteractionList<ActsFatras::PhotonConversion>

private

Definition at line 235 of file ActsFatrasG4Tool.h.

◆ NeutralPropagator

using ActsFatrasG4Tool::NeutralPropagator = Acts::Propagator<NeutralStepper, Navigator>

private

Definition at line 226 of file ActsFatrasG4Tool.h.

◆ NeutralSelector

using ActsFatrasG4Tool::NeutralSelector = ActsFatras::NeutralSelector

private

Definition at line 234 of file ActsFatrasG4Tool.h.

◆ NeutralSimulation

using ActsFatrasG4Tool::NeutralSimulation

private

Initial value:

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

Definition at line 236 of file ActsFatrasG4Tool.h.

◆ NeutralStepper

using ActsFatrasG4Tool::NeutralStepper = Acts::StraightLineStepper

private

Definition at line 225 of file ActsFatrasG4Tool.h.

◆ Simulation

using ActsFatrasG4Tool::Simulation

private

Initial value:

ActsFatras::MultiParticleSimulation<ChargedSelector, ChargedSimulation,

NeutralSelector, NeutralSimulation>

ActsFatrasG4Tool::ChargedSimulation

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

Definition ActsFatrasG4Tool.h:230

ActsFatrasG4Tool::NeutralSimulation

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

Definition ActsFatrasG4Tool.h:236

ActsFatrasG4Tool::ChargedSelector

ActsFatras::ChargedSelector ChargedSelector

Definition ActsFatrasG4Tool.h:228

ActsFatrasG4Tool::NeutralSelector

ActsFatras::NeutralSelector NeutralSelector

Definition ActsFatrasG4Tool.h:234

Definition at line 240 of file ActsFatrasG4Tool.h.

Constructor & Destructor Documentation

◆ ~ActsFatrasG4Tool()

virtual ActsFatrasG4Tool::~ActsFatrasG4Tool ( )

virtualdefault

Member Function Documentation

◆ applyPrimaryUpdate()

StatusCode ActsFatrasG4Tool::applyPrimaryUpdate	(	const G4Track &	,
		const std::vector< ActsFatras::Particle > &	simulatedFinalParticles,
		G4FastStep &	fastStep )

private

Definition at line 192 of file ActsFatrasG4Tool.cxx.

{
  if (simulatedFinalParticles.empty()){return StatusCode::SUCCESS;}
 
  const auto& primary = simulatedFinalParticles.front();
 
  if (!primary.isAlive()) { // if not alive, kill the track in G4
    fastStep.KillPrimaryTrack();
    return StatusCode::SUCCESS;
  }
 
  double p = primary.absoluteMomentum(); // MeV
  double m = primary.mass();             // MeV
 
  double energy = std::sqrt(p*p + m*m); // total energy in MeV
  double kinetic = (energy - m) * CLHEP::MeV; // convert back to kinetic energy in MeV for G4
 
  fastStep.ProposePrimaryTrackFinalKineticEnergy(kinetic);
 
  fastStep.ProposePrimaryTrackFinalMomentumDirection(
    G4ThreeVector(primary.direction().x(), primary.direction().y(), primary.direction().z()).unit()
  );
 
  fastStep.ProposePrimaryTrackFinalPosition(
    G4ThreeVector(primary.position().x(), primary.position().y(), primary.position().z())
  );
  return StatusCode::SUCCESS;
}

◆ buildActsInputFromG4()

std::vector< ActsFatras::Particle > ActsFatrasG4Tool::buildActsInputFromG4 ( const G4Track & track )

private

Definition at line 140 of file ActsFatrasG4Tool.cxx.

{
  TrackHelper helper(&track);
 
  int barcode = helper.GetBarcode();
  if (barcode == 0){
    barcode = track.GetTrackID();
    ATH_MSG_DEBUG("Track barcode is 0, using TrackID " << barcode
                    << " PDG=" << track.GetDefinition()->GetPDGEncoding()
                    << " Ekin=" << track.GetKineticEnergy()
                  );
  }
 
  ActsFatras::Barcode fatrasBarcode = ActsFatras::Barcode().withVertexPrimary(0).withParticle(barcode);
  auto fatrasPDG      = static_cast<Acts::PdgParticle>(track.GetDefinition()->GetPDGEncoding());
  double fatrasCharge = track.GetDefinition()->GetPDGCharge();
  double fatrasMass   = track.GetDefinition()->GetPDGMass(); // already MeV
 
  ActsFatras::Particle particle(fatrasBarcode, fatrasPDG, fatrasCharge, fatrasMass);
 
  // ---- Direction magnitude ----
  particle.setDirection(track.GetMomentum().x(), track.GetMomentum().y(), track.GetMomentum().z());
 
  // ---- Momentum magnitude ----
  double momentumMeV = track.GetMomentum().mag();  // already MeV
  particle.setAbsoluteMomentum(momentumMeV);
 
  // ---- Unit direction ----
  G4ThreeVector momDir = track.GetMomentumDirection(); // already unit
  particle.setDirection(momDir.x(), momDir.y(), momDir.z());
 
  // ---- 4-Position (mm, ns already) ----
  particle.setPosition4(Acts::Vector4(
      track.GetPosition().x(),
      track.GetPosition().y(),
      track.GetPosition().z(),
      track.GetGlobalTime()));
 
  ATH_MSG_DEBUG("Converted G4->Acts:"
      << " p(MeV)=" << momentumMeV
      << " mass(MeV)=" << fatrasMass);
 
    return { particle };
}

◆ clearCaches()

void ActsFatrasG4Tool::clearCaches ( const EventContext & ctx ) const

overridevirtual

Definition at line 556 of file ActsFatrasG4Tool.cxx.

{
  EventCache* cache = m_eventCache.get(ctx);
  if (!cache) { return; }
  cache->pixelHits.clear();
  cache->sctHits.clear();
}

◆ configureSimulator()

StatusCode ActsFatrasG4Tool::configureSimulator ( )

private

Definition at line 81 of file ActsFatrasG4Tool.cxx.

{
    ATH_MSG_INFO("Configuring Fatras simulator...");
    // protection against multiple calls
    if (m_simulator) {
      ATH_MSG_DEBUG("Simulator already configured — skipping");
      return StatusCode::SUCCESS;
    }
 
    // construct the ACTS simulator
    // Magnetic field
    m_bField = std::make_shared<ATLASMagneticFieldWrapper>();
    // Navigator (needs tracking geometry ready)
    m_navigator = std::make_unique<Navigator>(Navigator::Config{ m_trackingGeometry }, m_logger);
    // Steppers
    ChargedStepper chargedStepper(m_bField);
    NeutralStepper neutralStepper;
    // Propagators
    ChargedPropagator chargedPropagator(std::move(chargedStepper), *m_navigator, m_logger);
    NeutralPropagator neutralPropagator(std::move(neutralStepper), *m_navigator, m_logger);
    // Single-particle simulations
 
    // Single particle simulations 
    ChargedSimulation simCharged(std::move(chargedPropagator), m_logger);
    NeutralSimulation simNeutral(std::move(neutralPropagator), m_logger);
 
    // construct the ACTS simulator/dispatcher
    m_simulator = std::make_unique<Simulation>(std::move(simCharged), std::move(simNeutral));
 
    // Acts propagater options (charged) particles
    m_simulator->charged.maxStepSize             = m_maxStepSize;
    m_simulator->charged.maxStep                 = m_maxStep;
    m_simulator->charged.pathLimit               = m_pathLimit;
    m_simulator->charged.maxRungeKuttaStepTrials = m_maxRungeKuttaStepTrials;
    m_simulator->charged.loopProtection          = m_loopProtection;
    m_simulator->charged.loopFraction            = m_loopFraction;
    m_simulator->charged.targetTolerance         = m_tolerance;
    m_simulator->charged.stepSizeCutOff          = m_stepSizeCutOff;
 
    // Create interaction list
    ATH_MSG_VERBOSE(name() << " Min pT for interaction " << m_interact_minPt * Acts::UnitConstants::MeV << " MeV");
    m_simulator->charged.interactions = ActsFatras::makeStandardChargedElectroMagneticInteractions(m_interact_minPt * Acts::UnitConstants::MeV);
 
    ATH_MSG_VERBOSE("Simulator configured:");
    ATH_MSG_VERBOSE("  maxStepSize = " << m_maxStepSize);
    ATH_MSG_VERBOSE("  maxStep     = " << m_maxStep);
    ATH_MSG_INFO("Fatras simulator configured successfully.");
 
    return StatusCode::SUCCESS;
}

◆ createHitsFromG4()

StatusCode ActsFatrasG4Tool::createHitsFromG4	(	const EventContext &	ctx,
		const G4Track &	track,
		const Acts::TrackingGeometry &	trackingGeometry,
		const std::vector< ActsFatras::Hit > &	hits ) const

private

Definition at line 569 of file ActsFatrasG4Tool.cxx.

{
  if (hits.empty()) {
    return StatusCode::SUCCESS;
  }
 
  // ============================================
  // Get per-slot event cache (MT safe)
  // ============================================
  EventCache& evtCache = getCache(ctx);
 
  // ============================================
  // Truth handling via TrackHelper (from G4Track case)
  // ============================================
  TrackHelper helper(&track);
  int barcode = helper.GetBarcode();
 
  // initialize partLink
  HepMcParticleLink partLink(HepMC::UNDEFINED_ID, 0, HepMcParticleLink::IS_POSITION, HepMcParticleLink::IS_BARCODE);
 
  if (barcode != 0 && barcode != HepMC::UNDEFINED_ID && barcode != HepMC::INVALID_PARTICLE_ID) {
    partLink = HepMcParticleLink(barcode, 0, HepMcParticleLink::IS_POSITION, HepMcParticleLink::IS_BARCODE);
  }
 
  // ============================================
  // Loop over Fatras hits
  // ============================================
  for (const auto& hit : hits) {
 
    double energyDeposit = hit.depositedEnergy() / Acts::UnitConstants::MeV;
    double time          = ActsTrk::timeToAthena(hit.time());
    auto   geoID         = hit.geometryId();
 
    try {
 
      auto acts_surface = trackingGeometry.findSurface(geoID);
      if (!acts_surface) continue;
 
      const auto *acts_de = getActsDetectorElement(acts_surface);
      if (!acts_de) continue;
 
      const Trk::Surface& atlasSurface = acts_de->atlasSurface();
      Identifier hitId = atlasSurface.associatedDetectorElementIdentifier();
 
      const Trk::TrkDetElementBase* detBase = atlasSurface.associatedDetectorElement();
      const InDetDD::SiDetectorElement* siDet = dynamic_cast<const InDetDD::SiDetectorElement*>(detBase);
 
      if (!siDet) continue;
 
      // ============================================
      // Global -> local intersection
      // ============================================
      auto intersection = atlasSurface.globalToLocal(hit.position());
      if (!intersection) continue;
 
      double interX = (*intersection)(0);
      double interY = (*intersection)(1);
      double thickness = siDet->thickness();
 
      // ============================================
      // Direction handling, compute entry/exit positions
      // ============================================
      // get hit direction 
      const auto& actsDir = hit.direction();
      // Convert to Amg only when applying transform
      Amg::Vector3D amgDir(actsDir.x(), actsDir.y(), actsDir.z());
 
      // ATLAS surface transform using Amg
      const Amg::Transform3D surfaceTransform = atlasSurface.transform();
      const Amg::Transform3D invSurfaceTransform = surfaceTransform.inverse();
      Amg::Vector3D localDirAmg = invSurfaceTransform.linear() * amgDir;
 
      // calculate cosTheta using norm
      double norm = localDirAmg.norm();
      if (norm < 1e-9) continue;
      double cosTheta = localDirAmg.z() / norm;
      if (std::abs(cosTheta) < 1e-6) continue;
 
      // calculate local entry and exit in X and Y based on intersection and distance
      localDirAmg *= thickness / std::abs(cosTheta);
 
      int movingDir = localDirAmg.z() > 0. ? 1 : -1;
 
      double distX = localDirAmg.x();
      double distY = localDirAmg.y();
      
      double localEntryX = interX - 0.5 * distX;
      double localEntryY = interY - 0.5 * distY;
      double localExitX  = interX + 0.5 * distX;
      double localExitY  = interY + 0.5 * distY;
 
      // calculate hit transform with silicon detector using Amg
      const Amg::Transform3D& hitTransform = siDet->transformHit().inverse();
      // create entry and exit surfaces
      Amg::Vector3D surfaceEntry(localEntryX, localEntryY, -0.5 * movingDir * thickness);
      Amg::Vector3D surfaceExit(localExitX, localExitY, 0.5 * movingDir * thickness);
 
      Amg::Vector3D globalEntry = surfaceTransform * surfaceEntry;
      Amg::Vector3D globalExit  = surfaceTransform * surfaceExit;
      Amg::Vector3D localEntry  = hitTransform * globalEntry;
      Amg::Vector3D localExit   = hitTransform * globalExit;
 
      HepGeom::Point3D<double> entryHep(localEntry.x(), localEntry.y(), localEntry.z());
      HepGeom::Point3D<double> exitHep(localExit.x(), localExit.y(), localExit.z());
 
      bool isPixel = siDet->isPixel();
 
      // ============================================
      // Create SiHit
      // ============================================
      SiHit siHit(
          entryHep,
          exitHep,
          energyDeposit,
          time,
          partLink,
          isPixel ? 0 : 1,
          isPixel ? m_pixIdHelper->barrel_ec(hitId) : m_sctIdHelper->barrel_ec(hitId),
          isPixel ? m_pixIdHelper->layer_disk(hitId) : m_sctIdHelper->layer_disk(hitId),
          isPixel ? m_pixIdHelper->eta_module(hitId) : m_sctIdHelper->eta_module(hitId),
          isPixel ? m_pixIdHelper->phi_module(hitId) : m_sctIdHelper->phi_module(hitId),
          isPixel ? 0 : m_sctIdHelper->side(hitId)
        );
 
      // ============================================
      // Store into MT-safe cache
      // ============================================
      if (isPixel) {
        evtCache.pixelHits.emplace_back(std::move(siHit));
      } else {
        evtCache.sctHits.emplace_back(std::move(siHit));
      }
      ATH_MSG_VERBOSE(name() << " convert and store 1 hit, total " << evtCache.pixelHits.size() << " Pixel | " << evtCache.sctHits.size()   << " SCT hits stored.");
    }
    catch (const std::exception& e) {
      ATH_MSG_DEBUG(name() << "Can not find Acts Surface (" << e.what() << ")...Skip...");
      continue;
    }
  }
  ATH_MSG_VERBOSE("Cache now contains " << evtCache.pixelHits.size() << " pixel hits and " << evtCache.sctHits.size()   << " SCT hits");
  return StatusCode::SUCCESS;
}

◆ debugTrackRegion()

void ActsFatrasG4Tool::debugTrackRegion ( const G4FastTrack & fastTrack ) const

private

Definition at line 253 of file ActsFatrasG4Tool.cxx.

{
    const G4Track& track = *fastTrack.GetPrimaryTrack();
 
    ATH_MSG_DEBUG("=========== FATRAS REGION DEBUG ===========");
    // FastSim envelope solid
    const G4VSolid* envelope = fastTrack.GetEnvelopeSolid();
    if (envelope) {ATH_MSG_DEBUG("FastSim envelope solid: " << envelope->GetName());} 
    else {ATH_MSG_DEBUG("FastSim envelope solid: NONE");}
 
    // Physical volume
    const G4VPhysicalVolume* pv = track.GetVolume();
    if (pv) {
        ATH_MSG_DEBUG("Physical volume: " << pv->GetName());
        const G4LogicalVolume* lv = pv->GetLogicalVolume();
        if (lv) {
            const G4Region* region = lv->GetRegion();
            if (region) {ATH_MSG_DEBUG("Region: " << region->GetName());} 
            else {ATH_MSG_DEBUG("Region: NONE");}
        }
    } else {
        ATH_MSG_DEBUG("Physical volume: NONE");
    }
 
    const G4ThreeVector& pos = track.GetPosition();
    double r = std::sqrt(pos.x()*pos.x() + pos.y()*pos.y());
 
    ATH_MSG_DEBUG("Position (mm): (" << pos.x()/CLHEP::mm << ", " << pos.y()/CLHEP::mm << ", " << pos.z()/CLHEP::mm << ")");
    ATH_MSG_DEBUG("R (mm): " << r / CLHEP::mm);
    ATH_MSG_DEBUG("Ekin (MeV): " << track.GetKineticEnergy()/CLHEP::MeV);
    ATH_MSG_DEBUG("PDG: " << track.GetDefinition()->GetPDGEncoding());
    ATH_MSG_DEBUG("===========================================");
}

◆ finalize()

StatusCode ActsFatrasG4Tool::finalize ( )

overridevirtual

AlgTool finalize method.

Definition at line 717 of file ActsFatrasG4Tool.cxx.

{
  ATH_MSG_DEBUG( "[ActsFatrasG4Tool] finalize() starting" );
  ATH_MSG_DEBUG( "[ActsFatrasG4Tool] finalize() successful" );
  return StatusCode::SUCCESS;
}

◆ getATLASProcessCode()

int ActsFatrasG4Tool::getATLASProcessCode ( ActsFatras::GenerationProcess actspt )

inlineprivate

Definition at line 317 of file ActsFatrasG4Tool.h.

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

ActsFatrasG4Tool::m_processTypeMap

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

Definition ActsFatrasG4Tool.h:312

xAOD::uint32_t

setEventNumber uint32_t

Definition EventInfo_v1.cxx:127

◆ getCache()

ActsFatrasG4Tool::EventCache & ActsFatrasG4Tool::getCache ( const EventContext & ctx ) const

private

Definition at line 564 of file ActsFatrasG4Tool.cxx.

                                                                                    {
  return *m_eventCache.get(ctx);
}

◆ getPixelHitsCache()

const std::vector< SiHit > & ActsFatrasG4Tool::getPixelHitsCache ( const EventContext & ctx ) const

overridevirtual

for saving si hits caches, expose to the interface

Definition at line 540 of file ActsFatrasG4Tool.cxx.

{
  const EventCache* cache = m_eventCache.get(ctx);
  static const std::vector<SiHit> empty;
  if (!cache) { return empty; }
  return cache->pixelHits;
}

◆ getSCTHitsCache()

const std::vector< SiHit > & ActsFatrasG4Tool::getSCTHitsCache ( const EventContext & ctx ) const

overridevirtual

Definition at line 548 of file ActsFatrasG4Tool.cxx.

{
  const EventCache* cache = m_eventCache.get(ctx);
  static const std::vector<SiHit> empty;
  if (!cache) { return empty; }
  return cache->sctHits;
}

◆ handleSimulationFailures()

void ActsFatrasG4Tool::handleSimulationFailures ( const Acts::Result< ActsFatras::SingleParticleSimulationResult > & result )

private

Definition at line 185 of file ActsFatrasG4Tool.cxx.

{
  if (!result.ok()) {
    ATH_MSG_ERROR("Fatras simulation failed: " << result.error().message());
  }
}

◆ initialize()

StatusCode ActsFatrasG4Tool::initialize ( )

overridevirtual

AlgTool initialize method.

Definition at line 42 of file ActsFatrasG4Tool.cxx.

                                        {
  // print version name
  ATH_MSG_INFO(name() << " initialize start" );
  ATH_MSG_INFO("ActsFatrasG4Tool updated with ACTS version: v"
    << Acts::VersionMajor << "." << Acts::VersionMinor << "."
    << Acts::VersionPatch << " [" << Acts::CommitHash.value_or("unknown hash") << "]");
 
  // setup logger
  m_logger = makeActsAthenaLogger(this, std::string("ActsFatras"),std::string("ActsFatrasG4Tool"));
 
  // retrieve tracking geo tool
  ATH_CHECK(m_trackingGeometrySvc.retrieve());
  m_trackingGeometry = m_trackingGeometrySvc->trackingGeometry();
  ATH_MSG_DEBUG("Tracking geometry OK");  
  ATH_CHECK(m_ctxProvider.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;
  }
  ATH_MSG_DEBUG("Random number services OK");
 
  // Get the Pixel Identifier-helper, must be in initialize() after calling detector store
  ATH_CHECK(detStore()->retrieve(m_pixIdHelper, "PixelID"));
  // Get the SCT Identifier-helper
  ATH_CHECK(detStore()->retrieve(m_sctIdHelper, "SCT_ID"));
  ATH_MSG_DEBUG("Pixel and SCT identifiers OK");
 
  return StatusCode::SUCCESS;
}

◆ initializePhysics()

StatusCode ActsFatrasG4Tool::initializePhysics ( )

override

AlgTool initializePhysics method.

Definition at line 132 of file ActsFatrasG4Tool.cxx.

                                              {
  ATH_MSG_INFO("ActsFatrasG4Tool::initializePhysics() called");
  // make simulator
  ATH_CHECK( configureSimulator());
  return StatusCode::SUCCESS;
}

◆ runDebugInjection()

StatusCode ActsFatrasG4Tool::runDebugInjection	(	const EventContext &	ctx,
		const G4Track &	track,
		const Acts::GeometryContext &	anygctx,
		const Acts::MagneticFieldContext &	mctx,
		Generator &	generator,
		G4FastStep &	fastStep )

private

Definition at line 287 of file ActsFatrasG4Tool.cxx.

{
  // NOTE: block below is only meant for DEBUGGING, 
  // Retained here for future debugging purposes
  // -- It injects a muon particle in InDet, 
  // --- to test if FATRAS properly simulates it and produces/writes expected hits. 
  // DO NOT USE in actual production
  // PLEASE set m_debugInject in header or jobOption config to false for actual production use.
 
  ATH_MSG_DEBUG("### DEBUG INJECTION ACTIVE ###");
 
  // --- Build fake muon ---
  ActsFatras::Barcode bc = ActsFatras::Barcode().withVertexPrimary(0).withParticle(1);
 
  Acts::PdgParticle pdg = Acts::PdgParticle(13);  // mu-
  double charge = -1.0;
  double mass   = 105.7; // MeV
 
  ActsFatras::Particle fakeMuon(bc, pdg, charge, mass);
 
  fakeMuon.setPosition4({50., 0., 0., 0.});
  fakeMuon.setDirection(0., 1., 0.);
  fakeMuon.setAbsoluteMomentum(10000.0); // 10 GeV
 
  // create input particle with ActsFatras::Particle 
  std::vector<ActsFatras::Particle> inputParticle{ fakeMuon };
  // declare variables to be passed
  std::vector<ActsFatras::Particle> simulatedInitialParticles;
  std::vector<ActsFatras::Particle> simulatedFinalParticles;
  std::vector<ActsFatras::Hit> hits;
 
  if (!m_simulator) {
    ATH_MSG_ERROR("Simulator not configured");
    return StatusCode::FAILURE;
  }
 
  auto result = m_simulator->simulate(anygctx, mctx, generator, inputParticle, simulatedInitialParticles, simulatedFinalParticles, hits);
 
  if (!result.ok()) {
    ATH_MSG_ERROR("Fatras debug injection failed: " << result.error().message());
    fastStep.KillPrimaryTrack();
    return StatusCode::FAILURE;
  }
 
  ATH_MSG_DEBUG("Injected muon hits produced: " << hits.size());
 
  if (createHitsFromG4(ctx, track, *m_trackingGeometry, hits).isFailure()) {
    ATH_MSG_ERROR("Failed to write debug injected hits");
    fastStep.KillPrimaryTrack();
    return StatusCode::FAILURE;
  }
 
  fastStep.KillPrimaryTrack();
  // Do not call here below methods, only for simple injection:
  //   applyPrimaryUpdate()
  //   spawnSecondaries()
  //   buildActsInputFromG4()
 
  ATH_MSG_DEBUG("===================================");
 
  return StatusCode::SUCCESS;
}

◆ simulateFatrasTrack()

void ActsFatrasG4Tool::simulateFatrasTrack	(	const G4FastTrack &	fastTrack,
		G4FastStep &	fastStep )

overridevirtual

create ActsFatras track, exposed via interface

Definition at line 356 of file ActsFatrasG4Tool.cxx.

{
  // Get primary track
  const G4Track& track = *fastTrack.GetPrimaryTrack();
  TrackHelper helper(&track);
 
  int trackID  = track.GetTrackID();
  int parentID = track.GetParentID();
  int barcode  = helper.GetBarcode();
  int pdg      = track.GetDefinition()->GetPDGEncoding();
  double ekin  = track.GetKineticEnergy() / CLHEP::MeV;
 
  ATH_MSG_DEBUG("==== G4 Track entering Fatras ====");
  ATH_MSG_DEBUG("TrackID  = " << trackID);
  ATH_MSG_DEBUG("ParentID = " << parentID);
  ATH_MSG_DEBUG("Barcode  = " << barcode);
  ATH_MSG_DEBUG("PDG      = " << pdg);
  ATH_MSG_DEBUG("Ekin(MeV)= " << ekin);
  ATH_MSG_DEBUG("===================================");
 
  // get EventContext
  const EventContext& ctx = Gaudi::Hive::currentContext();
 
  // random seeds
  m_randomEngine->setSeed(m_randomEngineName, ctx);
  CLHEP::HepRandomEngine* randomEngine = m_randomEngine->getEngine(ctx);
 
  // RNG
  Generator generator(CLHEP::RandFlat::shoot(randomEngine->flat()));
 
  // get Mag field context, and Geo context
  ATH_MSG_VERBOSE(name() << " Getting per event Geo and Mag map");
  auto mctx = m_ctxProvider.getMagneticFieldContext(ctx);
  auto anygctx = m_ctxProvider.getGeometryContext(ctx);
 
  // Build Acts input from G4 track
  std::vector<ActsFatras::Particle> inputParticle;
 
  // Skip very low energy particles (e.g 1MeV)
  if (ekin < 1.0) { // in MeV
    ATH_MSG_DEBUG("Skipping and killing low energy track");
    fastStep.KillPrimaryTrack();
    return;
  }
 
  if (msgLvl(MSG::DEBUG)){ATH_MSG_DEBUG("m_debugInject runtime value = " << m_debugInject);}  
  if (m_debugInject) {
    // run the debug injection
    if (runDebugInjection(ctx, track, anygctx, mctx, generator, fastStep).isFailure()){
      ATH_MSG_DEBUG("runDebugInjection failed");
    }
    return; // return so we escape scope after run, and so we don't enter production loop below
  } else {
    // Actual production code: build input from G4 track
    inputParticle = buildActsInputFromG4(track);
  }
 
  // safeguard against geometry pointer returned null or undefined (usually with being outside defined geometry)
  Acts::Vector3 startPos(track.GetPosition().x(), track.GetPosition().y(), track.GetPosition().z());
  auto startVolume = m_trackingGeometry->resolveLowestTrackingVolume(anygctx, startPos);
 
  if(not startVolume.ok() or *startVolume == nullptr){
    ATH_MSG_DEBUG("Could not resolve the lowest tracking volume, skip FATRAS.");
    return;
  }
 
  // debug region
  if (msgLvl(MSG::DEBUG)) {
    const G4VSolid* envelope = fastTrack.GetEnvelopeSolid();
    if (envelope) {ATH_MSG_DEBUG("FastSim envelope solid name: "  << envelope->GetName());}
    const G4VPhysicalVolume* pv = track.GetVolume();
    if (pv) {
        const G4LogicalVolume* lv = pv->GetLogicalVolume();
        if (lv) {
            const G4Region* region = lv->GetRegion();
            if (region) {
                ATH_MSG_DEBUG("Region name: " << region->GetName());
            }
        }
    }
  }
 
  // declare variables to be passed
  std::vector<ActsFatras::Particle> simulatedInitialParticles;
  std::vector<ActsFatras::Particle> simulatedFinalParticles;
  std::vector<ActsFatras::Hit> hits;
 
  // safety: returns early if m_simulator not called in initializePhysics, or if failed for some reason
  if (!m_simulator) {
    ATH_MSG_ERROR("Simulator not configured");
    return;
  }
 
  // do the actual Fatras simulation  
  auto result = m_simulator->simulate(anygctx, mctx, generator, inputParticle, simulatedInitialParticles, simulatedFinalParticles, hits);
  if (!result.ok()) {
    const std::string& msg = result.error().message();
      // volume error
      if (msg.find("No Volume") != std::string::npos) {
        const G4VSolid* envelope = fastTrack.GetEnvelopeSolid();
        const G4ThreeVector& pos = track.GetPosition();
        double r = std::sqrt(pos.x()*pos.x() + pos.y()*pos.y());
        auto inside = envelope->Inside(pos);
        ATH_MSG_ERROR("G4 envelope Inside() = " << inside << ", " 
                                        << "(Position mm, R mm) = ((" 
                                        << pos.x()/CLHEP::mm << ", " 
                                        << pos.y()/CLHEP::mm << ", " 
                                        << pos.z()/CLHEP::mm << "), " 
                                        << r/CLHEP::mm       << ")"
                      );
        ATH_MSG_ERROR("ActsFatras simulation failed with 'No Volume' error: " << msg);
        if (msgLvl(MSG::DEBUG)) {
          const G4ThreeVector& mom = track.GetMomentumDirection();
          ATH_MSG_DEBUG("=== FATRAS NO VOLUME DEBUG ===");
          ATH_MSG_DEBUG("PDG      = " << track.GetDefinition()->GetPDGEncoding());
          ATH_MSG_DEBUG("Ekin MeV = " << track.GetKineticEnergy() / CLHEP::MeV);
          ATH_MSG_DEBUG("Position mm = (" << pos.x()/CLHEP::mm << ", " << pos.y()/CLHEP::mm << ", " << pos.z()/CLHEP::mm << ")");
          ATH_MSG_DEBUG("R (mm)   = " << r / CLHEP::mm);
          ATH_MSG_DEBUG("Z (mm)   = " << pos.z() / CLHEP::mm);
          ATH_MSG_DEBUG("Direction = (" << mom.x() << ", " << mom.y() << ", " << mom.z() << ")");
          ATH_MSG_DEBUG("==============================");          
        }
        ATH_MSG_DEBUG("Track outside Acts tracking geometry -> let G4 continue.");
        return;   // do not kill track, let to G4
      }
      // other kinds of error 
      else {
        // real fatal error
        ATH_MSG_ERROR("ActsFatras simulation failed: " << msg);
        fastStep.KillPrimaryTrack();
        return;
      }
  }
 
  // =========================================================
  // ======= FATRAS DEBUG PRINTING ===========================
  // =========================================================
  if (msgLvl(MSG::DEBUG)) {
    if (!simulatedInitialParticles.empty()) {
      const auto& initial = simulatedInitialParticles.front();
      double totalEdep = 0.;
      for (const auto& h : hits) {totalEdep += h.depositedEnergy() / Acts::UnitConstants::MeV;}
      ATH_MSG_DEBUG("===============================================");
      ATH_MSG_DEBUG("FATRAS TRACK DEBUG");
      ATH_MSG_DEBUG("PDG: " << static_cast<int>(initial.pdg()));
      ATH_MSG_DEBUG("Initial momentum [MeV]: " << initial.absoluteMomentum());
      ATH_MSG_DEBUG("Initial mass     [MeV]: " << initial.mass());
      ATH_MSG_DEBUG("Hits produced: " << hits.size());
      ATH_MSG_DEBUG("Final particles: " << simulatedFinalParticles.size());
      ATH_MSG_DEBUG("Total deposited energy [MeV]: " << totalEdep);
      ATH_MSG_DEBUG("===============================================");
    }
 
    // some sanity printing, prints simulatedInitialParticles[0] if it exists, and the number of hits
    if (!simulatedInitialParticles.empty()) {
      ATH_MSG_DEBUG(name() << " initial particle " << simulatedInitialParticles.front());
    }
    ATH_MSG_DEBUG(name() << " ActsFatras simulator hits: " << hits.size());
  }
 
  // Actual part to create hits: fill MT cache only of non-zero detector hits
  if (!hits.empty()) {
    if (createHitsFromG4(ctx, track, *m_trackingGeometry, hits).isFailure()) {
      ATH_MSG_ERROR("Failed to create hits");
      return;
    }
 }
 
  // Apply propagation result to G4
  if (applyPrimaryUpdate(track, simulatedFinalParticles, fastStep).isFailure()) {
    ATH_MSG_ERROR("Failed to apply primary update");
    return;
  }
 
  // Spawn secondaries in Geant4
  if (spawnSecondaries(simulatedFinalParticles, track, fastStep).isFailure()) {
    ATH_MSG_ERROR("Failed to spawn secondaries");
    return;
  }
}

◆ spawnSecondaries()

StatusCode ActsFatrasG4Tool::spawnSecondaries	(	const std::vector< ActsFatras::Particle > &	simulatedFinal,
		const G4Track &	,
		G4FastStep &	fastStep )

private

Definition at line 224 of file ActsFatrasG4Tool.cxx.

{
    for (size_t i = 1; i < simulatedFinal.size(); ++i) {
      const auto& sec = simulatedFinal[i];
 
      G4ParticleDefinition* def = G4ParticleTable::GetParticleTable()->FindParticle(sec.pdg());
 
      if (!def){continue;}
 
      G4ThreeVector dir(sec.direction().x(), sec.direction().y(), sec.direction().z());
      dir = dir.unit();
      double momentumMeV = sec.absoluteMomentum();
 
      G4DynamicParticle dyn(def, dir, momentumMeV);
      fastStep.CreateSecondaryTrack(
          dyn,
          G4ThreeVector(sec.position().x(),
                        sec.position().y(),
                        sec.position().z()),
          sec.time(),
          true   // is local time
      );
    }
    return StatusCode::SUCCESS;
}

Member Data Documentation

◆ ATLAS_THREAD_SAFE [1/2]

SG::SlotSpecificObj<EventCache> m_eventCache ActsFatrasG4Tool::ATLAS_THREAD_SAFE

mutableprivate

Definition at line 326 of file ActsFatrasG4Tool.h.

◆ ATLAS_THREAD_SAFE [2/2]

ATHRNG::RNGWrapper* m_randomEngine ActsFatrasG4Tool::ATLAS_THREAD_SAFE {}

private

Definition at line 286 of file ActsFatrasG4Tool.h.

286{};

◆ m_bField

std::shared_ptr<ATLASMagneticFieldWrapper> ActsFatrasG4Tool::m_bField

private

Definition at line 247 of file ActsFatrasG4Tool.h.

◆ m_ctxProvider

ActsTrk::ContextUtility ActsFatrasG4Tool::m_ctxProvider {this}

private

Context provider for geometry, magnetic field and calibration contexts.

Definition at line 113 of file ActsFatrasG4Tool.h.

113{this};

◆ m_debugInject

Gaudi::Property<bool> ActsFatrasG4Tool::m_debugInject {this, "DebugInjectParticle", false}

private

Definition at line 330 of file ActsFatrasG4Tool.h.

330{this, "DebugInjectParticle", false};

◆ m_includeGradient

Gaudi::Property<bool> ActsFatrasG4Tool::m_includeGradient {this, "IncludeGradient", true, "Boolean flag for inclusion of d(dEds)d(q/p) into energy loss"}

private

Definition at line 301 of file ActsFatrasG4Tool.h.

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

◆ m_interact_minPt

Gaudi::Property<double> ActsFatrasG4Tool::m_interact_minPt {this, "Interact_MinPt", 50.0, "Min pT of the interactions (MeV)"}

private

Definition at line 298 of file ActsFatrasG4Tool.h.

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

◆ m_logger

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

private

Definition at line 295 of file ActsFatrasG4Tool.h.

295{nullptr};

◆ m_loopFraction

Gaudi::Property<double> ActsFatrasG4Tool::m_loopFraction {this, "LoopFraction", 0.5, "Allowed loop fraction, 1 is a full loop"}

private

Definition at line 309 of file ActsFatrasG4Tool.h.

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

◆ m_loopProtection

Gaudi::Property<bool> ActsFatrasG4Tool::m_loopProtection {this, "LoopProtection", true, "Loop protection, it adapts the pathLimit"}

private

Definition at line 308 of file ActsFatrasG4Tool.h.

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

◆ m_maxRungeKuttaStepTrials

Gaudi::Property<double> ActsFatrasG4Tool::m_maxRungeKuttaStepTrials {this, "MaxRungeKuttaStepTrials", 10000, "Max number of Runge-Kutta steps for the stepper step call"}

private

Definition at line 305 of file ActsFatrasG4Tool.h.

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

◆ m_maxStep

Gaudi::Property<double> ActsFatrasG4Tool::m_maxStep {this, "MaxSteps", 2000, "Max number of steps"}

private

Definition at line 304 of file ActsFatrasG4Tool.h.

304{this, "MaxSteps", 2000, "Max number of steps"};

◆ m_maxStepSize

Gaudi::Property<double> ActsFatrasG4Tool::m_maxStepSize {this, "MaxStepSize", 3.0, "Max step size (converted to Acts::UnitConstants::m)"}

private

Definition at line 306 of file ActsFatrasG4Tool.h.

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

◆ m_meanEnergyLoss

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

private

Definition at line 300 of file ActsFatrasG4Tool.h.

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

◆ m_momentumCutOff

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

private

Definition at line 302 of file ActsFatrasG4Tool.h.

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

◆ m_navigator

std::unique_ptr<Navigator> ActsFatrasG4Tool::m_navigator

private

Definition at line 246 of file ActsFatrasG4Tool.h.

◆ m_pathLimit

Gaudi::Property<double> ActsFatrasG4Tool::m_pathLimit {this, "PathLimit", 3000.0, "Track path limit (converted to Acts::UnitConstants::cm)"}

private

Definition at line 307 of file ActsFatrasG4Tool.h.

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

◆ m_pixIdHelper

const PixelID* ActsFatrasG4Tool::m_pixIdHelper {nullptr}

protected

the Pixel ID helper

Definition at line 337 of file ActsFatrasG4Tool.h.

337{nullptr};

◆ m_processTypeMap

Gaudi::Property<std::map<int,int> > ActsFatrasG4Tool::m_processTypeMap

private

Initial value:

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

Definition at line 312 of file ActsFatrasG4Tool.h.

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

◆ m_randomEngineName

Gaudi::Property<std::string> ActsFatrasG4Tool::m_randomEngineName {this, "RandomEngineName", "RandomEngineName", "Name of random number stream"}

private

Definition at line 287 of file ActsFatrasG4Tool.h.

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

◆ m_rngSvc

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

private

Definition at line 285 of file ActsFatrasG4Tool.h.

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

◆ m_sctIdHelper

const SCT_ID* ActsFatrasG4Tool::m_sctIdHelper {nullptr}

protected

the SCT ID helper

Definition at line 338 of file ActsFatrasG4Tool.h.

338{nullptr};

◆ m_simulator

std::unique_ptr<Simulation> ActsFatrasG4Tool::m_simulator

private

Definition at line 252 of file ActsFatrasG4Tool.h.

◆ m_stepSizeCutOff

Gaudi::Property<double> ActsFatrasG4Tool::m_stepSizeCutOff {this, "StepSizeCutOff", 0., "Cut-off value for the step size"}

private

Definition at line 311 of file ActsFatrasG4Tool.h.

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

◆ m_tolerance

Gaudi::Property<double> ActsFatrasG4Tool::m_tolerance {this, "Tolerance", 0.0001, "Tolerance for the error of the integration"}

private

Definition at line 310 of file ActsFatrasG4Tool.h.

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

◆ m_trackingGeometry

std::shared_ptr<const Acts::TrackingGeometry> ActsFatrasG4Tool::m_trackingGeometry

private

Definition at line 291 of file ActsFatrasG4Tool.h.

◆ m_trackingGeometrySvc

ServiceHandle<ActsTrk::ITrackingGeometrySvc> ActsFatrasG4Tool::m_trackingGeometrySvc {this, "TrackingGeometrySvc", "ActsTrackingGeometrySvc"}

private

Definition at line 290 of file ActsFatrasG4Tool.h.

290{this, "TrackingGeometrySvc", "ActsTrackingGeometrySvc"};

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

Classes

Public Member Functions

Protected Attributes

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ ChargedInteractions

◆ ChargedPropagator

◆ ChargedSelector

◆ ChargedSimulation

◆ ChargedStepper

◆ Generator

◆ Navigator

◆ NeutralInteractions

◆ NeutralPropagator

◆ NeutralSelector

◆ NeutralSimulation

◆ NeutralStepper

◆ Simulation

Constructor & Destructor Documentation

◆ ~ActsFatrasG4Tool()

Member Function Documentation

◆ applyPrimaryUpdate()

◆ buildActsInputFromG4()

◆ clearCaches()

◆ configureSimulator()

◆ createHitsFromG4()

◆ debugTrackRegion()

◆ finalize()

◆ getATLASProcessCode()

◆ getCache()

◆ getPixelHitsCache()

◆ getSCTHitsCache()

◆ handleSimulationFailures()

◆ initialize()

◆ initializePhysics()

◆ runDebugInjection()

◆ simulateFatrasTrack()

◆ spawnSecondaries()

Member Data Documentation

◆ ATLAS_THREAD_SAFE [1/2]

◆ ATLAS_THREAD_SAFE [2/2]

◆ m_bField

◆ m_ctxProvider

◆ m_debugInject

◆ m_includeGradient

◆ m_interact_minPt

◆ m_logger

◆ m_loopFraction

◆ m_loopProtection

◆ m_maxRungeKuttaStepTrials

◆ m_maxStep

◆ m_maxStepSize

◆ m_meanEnergyLoss

◆ m_momentumCutOff

◆ m_navigator

◆ m_pathLimit

◆ m_pixIdHelper

◆ m_processTypeMap

◆ m_randomEngineName

◆ m_rngSvc

◆ m_sctIdHelper

◆ m_simulator

◆ m_stepSizeCutOff

◆ m_tolerance

◆ m_trackingGeometry

◆ m_trackingGeometrySvc