biasing::utility::StepPrinter Class Reference

User stepping action used to print the details of a step. More...

#include <StepPrinter.h>

Public Member Functions
	StepPrinter (const std::string &name, framework::config::Parameters &parameters)
	Constructor.
virtual	~StepPrinter ()=default
	Destructor.
void	stepping (const G4Step *step) override
	Stepping action called when a step is taken during tracking of a particle.
std::vector< simcore::TYPE >	getTypes () override
	Retrieve the type of actions this class defines.
Public Member Functions inherited from simcore::UserAction
	UserAction (const std::string &name, framework::config::Parameters &parameters)
	Constructor.
	DECLARE_FACTORY (UserAction, std::shared_ptr< UserAction >, const std::string &, framework::config::Parameters &)
	factory for user actions
virtual	~UserAction ()=default
	Destructor.
virtual void	BeginOfEventAction (const G4Event *)
	Method called at the beginning of every event.
virtual void	EndOfEventAction (const G4Event *)
	Method called at the end of every event.
virtual void	BeginOfRunAction (const G4Run *)
	Method called at the beginning of a run.
virtual void	EndOfRunAction (const G4Run *)
	Method called at the end of a run.
virtual void	PreUserTrackingAction (const G4Track *)
	Method called before the UserTrackingAction.
virtual void	PostUserTrackingAction (const G4Track *)
	Method called after the UserTrackingAction.
virtual G4ClassificationOfNewTrack	ClassifyNewTrack (const G4Track *, const G4ClassificationOfNewTrack &cl)
	Method called when a track is updated.
virtual void	NewStage ()
	Method called at the beginning of a new stage.
virtual void	PrepareNewEvent ()
	Method called at the beginning of a new event.

Private Attributes
int	track_id_ {-9999}
	The track ID to filter on.
std::string	process_name_ {"UNDEFINED"}
int	depth_ {0}
std::unordered_map< int, int >	track_parents_ {}

Additional Inherited Members
Protected Member Functions inherited from simcore::UserAction
UserEventInformation *	getEventInfo () const
	Get a handle to the event information.
const std::map< int, ldmx::SimParticle > &	getCurrentParticleMap () const
	Get the current particle map.
Protected Attributes inherited from simcore::UserAction
std::string	name_ {""}
	Name of the UserAction.
framework::config::Parameters	parameters_
	The set of parameters used to configure this class.
mutable::framework::logging::logger	the_log_
	the logging channel user actions can use ldmx_log with

Detailed Description

User stepping action used to print the details of a step.

Definition at line 16 of file StepPrinter.h.

Constructor & Destructor Documentation

StepPrinter()

biasing::utility::StepPrinter::StepPrinter	(	const std::string &	name,
		framework::config::Parameters &	parameters )

Constructor.

Parameters

[in]	name	the name of the instance of this UserAction.
[in]	parameters	the parameters used to configure this UserAction.

Definition at line 12 of file StepPrinter.cxx.

    : simcore::UserAction(name, parameters) {
  track_id_ = parameters.get<int>("track_id");
  process_name_ = parameters.get<std::string>("process_name");
  depth_ = parameters.get<int>("depth");
}

References framework::config::Parameters::get(), and track_id_.

Member Function Documentation

getTypes()

std::vector< simcore::TYPE > biasing::utility::StepPrinter::getTypes ( )

inlineoverridevirtual

Retrieve the type of actions this class defines.

Implements simcore::UserAction.

Definition at line 40 of file StepPrinter.h.

                                             {
    return {simcore::TYPE::STEPPING};
  }

stepping()

void biasing::utility::StepPrinter::stepping ( const G4Step * step )

overridevirtual

Stepping action called when a step is taken during tracking of a particle.

Parameters

[in]

step

Geant4 step

Reimplemented from simcore::UserAction.

Definition at line 20 of file StepPrinter.cxx.

                                             {
  // Get the track associated with this step
  auto track{step->GetTrack()};
 
  const auto track_id{track->GetTrackID()};
  const auto parent{track->GetParentID()};
  // Don't bother filling the map if we aren't going to use it
  if (depth_ > 0) {
    track_parents_[track_id] = parent;
  }
 
  auto process{track->GetCreatorProcess()};
  std::string process_name{process ? process->GetProcessName() : "Primary"};
  // Unwrap biasing part of process name if present
  if (process_name.find("biasWrapper") != std::string::npos) {
    std::size_t pos_ = process_name.find_first_of("(") + 1;
    process_name = process_name.substr(pos_, process_name.size() - pos_ - 1);
  }
 
  // This could be a negated condition, but it is easier to read this way
  //
  auto track_map{simcore::g4user::TrackingAction::get()->getTrackMap()};
  if (track_id == track_id_ ||  // We are the track of interest
      track_map.isDescendant(
          track_id, track_id_,
          depth_) ||  // We are a descendent of the track of interest
      process_name ==
          process_name_  // The parent process was the process of interest
  ) {
    // This is an interesting track -> Carry on processing
  } else {
    return;
  }
  // Get the particle name.
  const auto particle_name{track->GetParticleDefinition()->GetParticleName()};
 
  // Get the energy of the particle
  const auto energy{step->GetPostStepPoint()->GetTotalEnergy()};
 
  // Get the volume the particle is in.
  auto volume{track->GetVolume()};
  auto volume_name{volume ? volume->GetName() : "undefined"};
 
  // Get the next volume (can fail if current volume is WorldPV and next is
  // outside the world)
  auto next_volume_ptr{track->GetNextVolume()};
  auto next_volume{next_volume_ptr ? next_volume_ptr->GetName() : "undefined"};
 
  // Get the region
  G4String region_name{"undefined"};
  if (volume) {
    auto lv{volume->GetLogicalVolume()};
    if (lv) {
      auto region{lv->GetRegion()};
      if (region) {
        region_name = region->GetName();
      }
    }
  }
 
  std::cout << " Step " << track->GetCurrentStepNumber() << " ("
            << track->GetParticleDefinition()->GetParticleName() << ") {"
            << " Energy: " << energy << " Track ID: " << track->GetTrackID()
            << " Particle currently in: " << volume_name
            << " Region: " << region_name << " Next volume: " << next_volume
            << " Weight: " << track->GetWeight() << " Parent: " << parent
            << " (" << process_name << ") " << " Children:";
  for (auto const& child : *(step->GetSecondaryInCurrentStep())) {
    std::cout << " (" << child->GetTotalEnergy()
              << "): " << child->GetParticleDefinition()->GetPDGEncoding();
  }
 
  std::cout << " }" << std::endl;
}

References simcore::g4user::TrackingAction::get(), simcore::g4user::TrackingAction::getTrackMap(), and track_id_.

Member Data Documentation

depth_

int biasing::utility::StepPrinter::depth_ {0}

private

Definition at line 48 of file StepPrinter.h.

{0};

process_name_

std::string biasing::utility::StepPrinter::process_name_ {"UNDEFINED"}

private

Definition at line 47 of file StepPrinter.h.

{"UNDEFINED"};

track_id_

int biasing::utility::StepPrinter::track_id_ {-9999}

private

The track ID to filter on.

Definition at line 46 of file StepPrinter.h.

{-9999};

Referenced by stepping(), and StepPrinter().

track_parents_

std::unordered_map<int, int> biasing::utility::StepPrinter::track_parents_ {}

private

Definition at line 49 of file StepPrinter.h.

{};

---

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

• Biasing/include/Biasing/Utility/StepPrinter.h
• Biasing/src/Biasing/Utility/StepPrinter.cxx