G4UA::MCTruthSteppingAction Class Reference

User action which handles recording-envelope truth tracks. More...

#include <MCTruthSteppingAction.h>

Inheritance diagram for G4UA::MCTruthSteppingAction:

Collaboration diagram for G4UA::MCTruthSteppingAction:

Public Types
using	VolumeCollectionMap_t = std::map<std::string, std::string>
	Map of volume name to output TrackRecordCollection name.

Public Member Functions
	MCTruthSteppingAction (const VolumeCollectionMap_t &collMap, int secondarySavingLevel, int subDetVolLevel, IMessageSvc *msgSvc, MSG::Level level)
	Construct the action with specified volumes and output collections.
virtual void	BeginOfEventAction (const G4Event *) override final
	Called at the start of each G4 event.
virtual void	UserSteppingAction (const G4Step *) override final
	Process one particle step.
bool	msgLvl (const MSG::Level lvl) const
	Test the output level.
MsgStream &	msg () const
	The standard message stream.
MsgStream &	msg (const MSG::Level lvl) const
	The standard message stream.
void	setLevel (MSG::Level lvl)
	Change the current logging level.

Private Member Functions
void	setupRecEnvelopes ()
	Setup the list of RecordingEnvelope helpers.
void	propagatePrimaryInfoToSecondaries (const G4Step *) const
	Propagate parent primary truth attribution to ordinary secondaries.
void	initMessaging () const
	Initialize our message level and MessageSvc.

Private Attributes
bool	m_isInitialized
	Used to delay initialization until the event loop, after geo is ready.
int	m_secondarySavingLevel
	The saving level for secondaries.
int	m_subDetVolLevel
	The level in the G4 volume hierarchy at which we find the sub-detector.
VolumeCollectionMap_t	m_volumeCollectionMap
	Map of volume name to output collection name.
std::vector< RecordingEnvelope >	m_recordingEnvelopes
	List of RecordingEnvelope helpers to invoke.
std::string	m_nm
	Message source name.
boost::thread_specific_ptr< MsgStream >	m_msg_tls
	MsgStream instance (a std::cout like with print-out levels).
std::atomic< IMessageSvc * >	m_imsg { nullptr }
	MessageSvc pointer.
std::atomic< MSG::Level >	m_lvl { MSG::NIL }
	Current logging level.
std::atomic_flag m_initialized	ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT
	Messaging initialized (initMessaging).

Detailed Description

User action which handles recording-envelope truth tracks.

This user action utilizes RecordingEnvelope objects to save truth tracks at entry/exit layers of certain configured detector layers.

Definition at line 34 of file MCTruthSteppingAction.h.

Member Typedef Documentation

VolumeCollectionMap_t

using G4UA::MCTruthSteppingAction::VolumeCollectionMap_t = std::map<std::string, std::string>

Map of volume name to output TrackRecordCollection name.

Definition at line 42 of file MCTruthSteppingAction.h.

Constructor & Destructor Documentation

MCTruthSteppingAction()

G4UA::MCTruthSteppingAction::MCTruthSteppingAction	(	const VolumeCollectionMap_t &	collMap,
		int	secondarySavingLevel,
		int	subDetVolLevel,
		IMessageSvc *	msgSvc,
		MSG::Level	level )

Construct the action with specified volumes and output collections.

Parameters

[in]

collMap

A map of recording envelope volume name to output TrackRecordCollection name.

Definition at line 25 of file MCTruthSteppingAction.cxx.

    : AthMessaging(msgSvc, "MCTruthSteppingAction"),
      m_isInitialized(false),
      m_secondarySavingLevel(secondarySavingLevel),
      m_subDetVolLevel(subDetVolLevel),
      m_volumeCollectionMap(volCollMap)
  {
    msg().setLevel(level);
  }

Member Function Documentation

BeginOfEventAction()

void G4UA::MCTruthSteppingAction::BeginOfEventAction ( const G4Event * event )

finaloverridevirtual

Called at the start of each G4 event.

Used to ensure that the TrackRecordCollection WriteHandles are valid.

Definition at line 74 of file MCTruthSteppingAction.cxx.

  {
    // First time initialization
    if(!m_isInitialized) {
      setupRecEnvelopes();
      if (m_recordingEnvelopes.size() == 0) {
        ATH_MSG_WARNING("No recording envelopes found!");
      }
      m_isInitialized = true;
    }
    // Every event initialization
    for (auto& recEnvelope : m_recordingEnvelopes) {
      if(auto* eventInfo = static_cast<AtlasG4EventUserInfo*>( event->GetUserInformation())){
        recEnvelope.BeginOfEvent(eventInfo->GetHitCollectionMap()->Find<TrackRecordCollection>(recEnvelope.GetTrackRecordCollectionName()));
      }
    }
  }

initMessaging()

void AthMessaging::initMessaging ( ) const

privateinherited

Initialize our message level and MessageSvc.

This method should only be called once.

Definition at line 39 of file AthMessaging.cxx.

{
  m_imsg = Athena::getMessageSvc();
  // If user did not set an explicit level, set a default
  if (m_lvl == MSG::NIL) {
    m_lvl = m_imsg ?
      static_cast<MSG::Level>( m_imsg.load()->outputLevel(m_nm) ) :
      MSG::INFO;
  }
}

msg() [1/2]

MsgStream & AthMessaging::msg ( ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 167 of file AthMessaging.h.

{
  MsgStream* ms = m_msg_tls.get();
  if (!ms) {
    if (!m_initialized.test_and_set()) initMessaging();
    ms = new MsgStream(m_imsg,m_nm);
    m_msg_tls.reset( ms );
  }
 
  ms->setLevel (m_lvl);
  return *ms;
}

msg() [2/2]

MsgStream & AthMessaging::msg ( const MSG::Level lvl ) const

inlineinherited

The standard message stream.

Returns a reference to the default message stream May not be invoked before sysInitialize() has been invoked.

Definition at line 182 of file AthMessaging.h.

{ return msg() << lvl; }

msgLvl()

bool AthMessaging::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Test the output level.

Parameters

lvl	The message level to test against

Returns

boolean Indicating if messages at given level will be printed

Return values

true	Messages at level "lvl" will be printed

Definition at line 151 of file AthMessaging.h.

{
  // If user did not set explicit message level we have to initialize
  // the messaging and retrieve the default via the MessageSvc.
  if (m_lvl==MSG::NIL && !m_initialized.test_and_set()) initMessaging();
 
  if (m_lvl <= lvl) {
    msg() << lvl;
    return true;
  } else {
    return false;
  }
}

propagatePrimaryInfoToSecondaries()

void G4UA::MCTruthSteppingAction::propagatePrimaryInfoToSecondaries ( const G4Step * aStep ) const

private

Propagate parent primary truth attribution to ordinary secondaries.

Definition at line 157 of file MCTruthSteppingAction.cxx.

  {
    if (!aStep) {
      return;
    }
 
    TrackHelper parentHelper(aStep->GetTrack());
    TrackInformation* parentInfo = parentHelper.GetTrackInformation();
    HepMC::GenParticlePtr primaryGenParticle = parentInfo ? parentInfo->GetPrimaryGenParticle() : nullptr;
    if (!primaryGenParticle) {
      return;
    }
 
    const std::vector<const G4Track*>* secondaries = aStep->GetSecondaryInCurrentStep();
    if (!secondaries) {
      return;
    }
 
    for (const G4Track* secondary : *secondaries) {
      if (!secondary || secondary->GetUserInformation()) {
        continue;
      }
 
      auto trackInfo = std::make_unique<TrackInformation>();
      trackInfo->SetPrimaryGenParticle(primaryGenParticle);
      trackInfo->SetClassification(TrackInformation::Secondary);
      secondary->SetUserInformation(trackInfo.release());
    }
  }

setLevel()

void AthMessaging::setLevel ( MSG::Level lvl )

inherited

Change the current logging level.

Use this rather than msg().setLevel() for proper operation with MT.

Definition at line 28 of file AthMessaging.cxx.

{
  m_lvl = lvl;
}

setupRecEnvelopes()

void G4UA::MCTruthSteppingAction::setupRecEnvelopes ( )

private

Setup the list of RecordingEnvelope helpers.

Definition at line 42 of file MCTruthSteppingAction.cxx.

  {
    ATH_MSG_DEBUG("Setting up " << m_volumeCollectionMap.size() <<
                  " recording envelopes:");
    m_recordingEnvelopes.reserve( m_volumeCollectionMap.size() );
    for(const auto& volCollPair : m_volumeCollectionMap) {
      ATH_MSG_DEBUG("  " << volCollPair.first << ", " << volCollPair.second);
 
      // Construct the helper in place on the vector
      m_recordingEnvelopes.emplace_back(volCollPair.first, volCollPair.second);
      RecordingEnvelope& recEnvelope = m_recordingEnvelopes.back();
 
      // Make sure the RecEnvelope can initialize properly
      if(!recEnvelope.Initialize()) {
        //FIXME - should this be an error?
        ATH_MSG_WARNING("Envelope volume " << recEnvelope.GetVolumeName() <<
                        " not found in geometry!");
        ATH_MSG_WARNING("TrackRecordCollection " <<
                        recEnvelope.GetTrackRecordCollectionName() <<
                        " will NOT be recorded");
        // Throw away uninitialized RecordingEnvelope
        m_recordingEnvelopes.pop_back();
      }
    }
    if (m_recordingEnvelopes.size() == 0) {
      ATH_MSG_WARNING("No recording envelopes found!");
    }
  }

UserSteppingAction()

void G4UA::MCTruthSteppingAction::UserSteppingAction ( const G4Step * aStep )

finaloverridevirtual

Process one particle step.

If the step crosses a recording envelope volume boundary, passes the step to the corresponding RecordingEnvelope to add a TrackRecord.

Definition at line 95 of file MCTruthSteppingAction.cxx.

  {
    TrackHelper trackHelper(aStep->GetTrack());
    const std::vector<const G4Track*>* secondaries = aStep->GetSecondaryInCurrentStep();
 
    // info must be propagated to secondaries before MC truth incident can be created
    propagatePrimaryInfoToSecondaries(aStep);
 
    // A saved primary is reclassified, but its old trajectory stayed active.
    const bool processTruth =
      trackHelper.IsPrimary() || trackHelper.IsRegeneratedPrimary() ||
      (trackHelper.IsRegisteredSecondary() && m_secondarySavingLevel > 1);
 
    if (secondaries && !secondaries->empty() && processTruth) {
      const TruthStrategyManager& sManager =
        TruthStrategyManager::GetStrategyManager();
      sManager.CreateTruthIncident(aStep, m_subDetVolLevel);
    }
 
    if (m_recordingEnvelopes.size() == 0) return;
    if (trackHelper.IsSecondary()) return;
 
    G4StepPoint* preStep = aStep->GetPreStepPoint();
    G4StepPoint* postStep = aStep->GetPostStepPoint();
 
    G4VPhysicalVolume* preVol = preStep->GetPhysicalVolume();
    G4VPhysicalVolume* postVol = postStep->GetPhysicalVolume();
 
    if (preVol == postVol) return;
 
    const G4TouchableHistory* preTHist = static_cast<const G4TouchableHistory*>(preStep->GetTouchable());
    const G4TouchableHistory* postTHist = static_cast<const G4TouchableHistory*>(postStep->GetTouchable());
    const int preStepVolDepth = preTHist->GetHistoryDepth();
    const int postStepVolDepth = postTHist->GetHistoryDepth();
 
    for (auto& recEnvelope : m_recordingEnvelopes)
    {
      const int envelopeLevel = recEnvelope.GetLevel();
      if (envelopeLevel <= preStepVolDepth)
      {
        //NB  preTHist->GetVolume(preStepVolDepth) would just give us the World volume.
        const G4LogicalVolume* logicalVolume1 =
          preTHist->GetVolume(preStepVolDepth-envelopeLevel)->GetLogicalVolume();
        if (logicalVolume1 != recEnvelope.GetLogicalVolume()) continue;
 
        if (envelopeLevel <= postStepVolDepth &&
            logicalVolume1 == postTHist->GetVolume(postStepVolDepth-envelopeLevel)
                              ->GetLogicalVolume())
        {
          continue;
        }
 
        // We have a track crossing a recording envelope
        // volume boundary, so make a TrackRecord
        recEnvelope.AddTrackRecord(aStep);
 
        // Done with this volume.
        break;
      }
    }
  }

Member Data Documentation

ATLAS_THREAD_SAFE

std::atomic_flag m_initialized AthMessaging::ATLAS_THREAD_SAFE = ATOMIC_FLAG_INIT

mutableprivateinherited

Messaging initialized (initMessaging).

Definition at line 141 of file AthMessaging.h.

m_imsg

std::atomic<IMessageSvc*> AthMessaging::m_imsg { nullptr }

mutableprivateinherited

MessageSvc pointer.

Definition at line 135 of file AthMessaging.h.

{ nullptr };

m_isInitialized

bool G4UA::MCTruthSteppingAction::m_isInitialized

private

Used to delay initialization until the event loop, after geo is ready.

Definition at line 70 of file MCTruthSteppingAction.h.

m_lvl

std::atomic<MSG::Level> AthMessaging::m_lvl { MSG::NIL }

mutableprivateinherited

Current logging level.

Definition at line 138 of file AthMessaging.h.

{ MSG::NIL };

m_msg_tls

boost::thread_specific_ptr<MsgStream> AthMessaging::m_msg_tls

mutableprivateinherited

MsgStream instance (a std::cout like with print-out levels).

Definition at line 132 of file AthMessaging.h.

m_nm

std::string AthMessaging::m_nm

privateinherited

Message source name.

Definition at line 129 of file AthMessaging.h.

m_recordingEnvelopes

std::vector<RecordingEnvelope> G4UA::MCTruthSteppingAction::m_recordingEnvelopes

private

List of RecordingEnvelope helpers to invoke.

Definition at line 82 of file MCTruthSteppingAction.h.

m_secondarySavingLevel

int G4UA::MCTruthSteppingAction::m_secondarySavingLevel

private

The saving level for secondaries.

Definition at line 73 of file MCTruthSteppingAction.h.

m_subDetVolLevel

int G4UA::MCTruthSteppingAction::m_subDetVolLevel

private

The level in the G4 volume hierarchy at which we find the sub-detector.

Definition at line 76 of file MCTruthSteppingAction.h.

m_volumeCollectionMap

VolumeCollectionMap_t G4UA::MCTruthSteppingAction::m_volumeCollectionMap

private

Map of volume name to output collection name.

Definition at line 79 of file MCTruthSteppingAction.h.

---

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

• MCTruthSteppingAction.h
• MCTruthSteppingAction.cxx