larg4::ParticleListAction Class Reference

#include "ParticleListAction.h"

Inheritance diagram for larg4::ParticleListAction:

Classes
struct	ParticleInfo_t

Public Types
using	GeneratedParticleIndex_t = simb::GeneratedParticleIndex_t

Public Member Functions
	ParticleListAction (double energyCut, bool storeTrajectories=false, bool keepEMShowerDaughters=false, bool keepMCParticleList=true, bool storeDroppedMCParticles=false)
virtual void	BeginOfEventAction (const G4Event *)
	G4UserEventAction interfaces. More...
virtual void	EndOfEventAction (const G4Event *)
virtual void	PreTrackingAction (const G4Track *)
	G4UserTrackingAction interfaces. More...
virtual void	PostTrackingAction (const G4Track *)
virtual void	SteppingAction (const G4Step *)
	G4UserSteppingAction interface. More...
void	ParticleFilter (std::unique_ptr< util::PositionInVolumeFilter > &&filter)
	Grabs a particle filter. More...
void	ResetTrackIDOffset ()
const sim::ParticleList *	GetList () const
std::map< int, GeneratedParticleIndex_t > const &	GetPrimaryTruthMap () const
bool	hasList () const
	Returns whether a particle list is being kept. More...
GeneratedParticleIndex_t	GetPrimaryTruthIndex (int trackId) const
	Returns the index of primary truth (sim::NoGeneratorIndex if none). More...
sim::ParticleList &&	YieldList ()
sim::ParticleList &&	YieldDroppedList ()
	Yields the (dropped) ParticleList accumulated during the current event. More...
virtual void	Config (fhicl::ParameterSet const &)
	Override Config() to extract any necessary parameters. More...
virtual void	PrintConfig (std::string const &)
	Override PrintConfig() to print out current configuration. More...
virtual void	BeginOfRunAction (const G4Run *)
	G4UserRunAction interfaces. More...
virtual void	EndOfRunAction (const G4Run *)
virtual bool	ProvidesStacking ()
virtual G4ClassificationOfNewTrack	StackClassifyNewTrack (const G4Track *)
	G4UserStackingAction interfaces. More...
virtual void	StackNewStage ()
virtual void	StackPrepareNewEvent ()
std::string const &	GetName () const
void	SetName (std::string const &name)

Static Public Member Functions
static int	GetCurrentTrackID ()
static int	GetCurrentOrigTrackID ()
static int	GetCurrentPdgCode ()
static bool	isDropped (simb::MCParticle const *p)
	returns whether the specified particle has been marked as dropped More...

Private Member Functions
int	GetParentage (int trackid, bool useOrigTrackIDMap=false) const
void	AddPointToCurrentParticle (TLorentzVector const &pos, TLorentzVector const &mom, std::string const &process)
	Adds a trajectory point to the current particle, and runs the filter. More...

Private Attributes
G4double	fenergyCut
ParticleInfo_t	fCurrentParticle
std::unique_ptr< sim::ParticleList >	fparticleList
std::unique_ptr< sim::ParticleList >	fdroppedParticleList
G4bool	fstoreTrajectories
	Whether to store particle trajectories with each particle. More...
std::map< int, int >	fParentIDMap
	key is current track ID, value is parent ID More...
std::map< int, int >	fParentIDMap_OrigTrackID
	key is current track ID, value is parent ID – for real G4 track ID tracking only More...
bool	fKeepEMShowerDaughters
	whether to keep EM shower secondaries, tertiaries, etc More...
std::unique_ptr< util::PositionInVolumeFilter >	fFilter
	filter for particles to be kept More...
std::map< int, GeneratedParticleIndex_t >	fPrimaryTruthMap
	Map: particle track ID -> index of primary information in MC truth. More...

Static Private Attributes
static int	fCurrentTrackID = sim::NoParticleId
static int	fCurrentOrigTrackID = sim::NoParticleId
	except for EM shower particles where it always shows the original track ID More...
static int	fCurrentPdgCode = 0
	pdg code of current particle More...
static int	fTrackIDOffset = 0

Detailed Description

Definition at line 45 of file ParticleListAction.h.

Member Typedef Documentation

using larg4::ParticleListAction::GeneratedParticleIndex_t = simb::GeneratedParticleIndex_t

Definition at line 47 of file ParticleListAction.h.

Constructor & Destructor Documentation

larg4::ParticleListAction::ParticleListAction	(	double	energyCut,
		bool	storeTrajectories = false,
		bool	keepEMShowerDaughters = false,
		bool	keepMCParticleList = true,
		bool	storeDroppedMCParticles = false
	)

Definition at line 57 of file ParticleListAction.cxx.

    : fenergyCut(energyCut * CLHEP::GeV)
    , fparticleList(keepMCParticleList ? std::make_unique<sim::ParticleList>() : nullptr)
    , fdroppedParticleList(storeDroppedMCParticles ? std::make_unique<sim::ParticleList>() :
                                                     nullptr)
    , fstoreTrajectories(storeTrajectories)
    , fKeepEMShowerDaughters(keepEMShowerDaughters)
  {}

Member Function Documentation

void larg4::ParticleListAction::AddPointToCurrentParticle ( TLorentzVector const &  pos, TLorentzVector const &  mom, std::string const &  process  )

private

Adds a trajectory point to the current particle, and runs the filter.

Definition at line 567 of file ParticleListAction.cxx.

References fCurrentParticle, fFilter, larg4::ParticleListAction::ParticleInfo_t::keep, and larg4::ParticleListAction::ParticleInfo_t::particle.

Referenced by SteppingAction().

  {

    // Add the first point in the trajectory.
    fCurrentParticle.particle->AddTrajectoryPoint(pos, mom, process);

    // also see if we can decide to keep the particle
    if (!fCurrentParticle.keep) fCurrentParticle.keep = fFilter->mustKeep(pos);

  } // ParticleListAction::AddPointToCurrentParticle()

void larg4::ParticleListAction::BeginOfEventAction ( const G4Event *  )

virtual

G4UserEventAction interfaces.

Reimplemented from g4b::UserAction.

Definition at line 72 of file ParticleListAction.cxx.

References larg4::ParticleListAction::ParticleInfo_t::clear(), fCurrentOrigTrackID, fCurrentParticle, fCurrentPdgCode, fCurrentTrackID, fdroppedParticleList, fParentIDMap, fParentIDMap_OrigTrackID, fparticleList, and sim::NoParticleId.

  {
    // Clear any previous particle information.
    fCurrentParticle.clear();
    if (fparticleList) fparticleList->clear();
    if (fdroppedParticleList) fdroppedParticleList->clear();
    fParentIDMap.clear();
    fParentIDMap_OrigTrackID.clear();
    fCurrentTrackID = sim::NoParticleId;
    fCurrentOrigTrackID = sim::NoParticleId;
    fCurrentPdgCode = 0;
  }

virtual void g4b::UserAction::BeginOfRunAction ( const G4Run *  )

inlinevirtualinherited

G4UserRunAction interfaces.

The following a list of methods that correspond to the available user action classes in Geant 4.0.1 and higher.

Reimplemented in larg4::VisualizationAction.

Definition at line 74 of file UserAction.h.

{};

virtual void g4b::UserAction::Config ( fhicl::ParameterSet const &  )

inlinevirtualinherited

Override Config() to extract any necessary parameters.

Reimplemented in altns::ExampleAction.

Definition at line 65 of file UserAction.h.

Referenced by g4b::UserAction::UserAction().

{};

void larg4::ParticleListAction::EndOfEventAction ( const G4Event *  )

virtual

Reimplemented from g4b::UserAction.

Definition at line 462 of file ParticleListAction.cxx.

References fparticleList, and larg4::UpdateDaughterInformation::SetParticleList().

  {
    if (!fparticleList) return;

    // Set up the utility class for the "for_each" algorithm.  (We only
    // need a separate set-up for the utility class because we need to
    // give it the pointer to the particle list.  We're using the STL
    // "for_each" instead of the C++ "for loop" because it's supposed
    // to be faster.
    UpdateDaughterInformation updateDaughterInformation;
    updateDaughterInformation.SetParticleList(fparticleList.get());

    // Update the daughter information for each particle in the list.
    std::for_each(fparticleList->begin(), fparticleList->end(), updateDaughterInformation);
  }

virtual void g4b::UserAction::EndOfRunAction ( const G4Run *  )

inlinevirtualinherited

Reimplemented in larg4::VisualizationAction.

Definition at line 75 of file UserAction.h.

{};

static int larg4::ParticleListAction::GetCurrentOrigTrackID ( )

inlinestatic

Definition at line 104 of file ParticleListAction.h.

Referenced by larg4::LArVoxelReadout::ProcessHits(), and larg4::OpFastScintillation::ProcessStep().

{ return fCurrentOrigTrackID; }

static int larg4::ParticleListAction::GetCurrentPdgCode ( )

inlinestatic

Definition at line 105 of file ParticleListAction.h.

{ return fCurrentPdgCode; }

static int larg4::ParticleListAction::GetCurrentTrackID ( )

inlinestatic

Definition at line 103 of file ParticleListAction.h.

Referenced by larg4::AuxDetReadout::ProcessHits(), larg4::LArVoxelReadout::ProcessHits(), larg4::OpFastScintillation::ProcessStep(), and larg4::OpFastScintillation::RecordPhotonsProduced().

{ return fCurrentTrackID; }

const sim::ParticleList * larg4::ParticleListAction::GetList

(

)

const

Definition at line 480 of file ParticleListAction.cxx.

References fdroppedParticleList, fparticleList, and fTrackIDOffset.

  {
    if (!fparticleList) return nullptr;

    // check if the ParticleNavigator has entries, and if
    // so grab the highest track id value from it to
    // add to the fTrackIDOffset
    int highestID = 0;
    for (auto pn = fparticleList->begin(); pn != fparticleList->end(); pn++)
      if ((*pn).first > highestID) highestID = (*pn).first;

    // If we have stored dropped particles,
    // include them in the offset.
    if (fdroppedParticleList) {
      for (auto pn = fdroppedParticleList->begin(); pn != fdroppedParticleList->end(); pn++)
        if ((*pn).first > highestID) highestID = (*pn).first;
    }

    //Only change the fTrackIDOffset if there is in fact a particle to add to the event
    if ((fparticleList->size()) != 0) { fTrackIDOffset = highestID + 1; }

    return fparticleList.get();
  }

std::string const& g4b::UserAction::GetName ( ) const

inlineinherited

Definition at line 98 of file UserAction.h.

References g4b::UserAction::myName.

Referenced by g4b::UserActionManager::PrintActionList().

{ return myName; }

int larg4::ParticleListAction::GetParentage ( int  trackid, bool  useOrigTrackIDMap = false  ) const

private

Definition at line 90 of file ParticleListAction.cxx.

References fParentIDMap, fParentIDMap_OrigTrackID, MF_LOG_DEBUG, and sim::NoParticleId.

Referenced by PreTrackingAction().

  {
    int parentid = sim::NoParticleId;
    const std::map<int, int>* parentIDMap =
      useOrigTrackIDMap ? &fParentIDMap_OrigTrackID : &fParentIDMap;

    // search the fParentIDMap recursively until we have the parent id
    // of the first EM particle that led to this one
    std::map<int, int>::const_iterator itr = parentIDMap->find(trackid);
    while (itr != parentIDMap->end()) {
      MF_LOG_DEBUG("ParticleListAction") << "parentage for " << trackid << " " << (*itr).second;

      // set the parentid to the current parent ID, when the loop ends
      // this id will be the first EM particle
      parentid = (*itr).second;
      itr = parentIDMap->find(parentid);
    }
    MF_LOG_DEBUG("ParticleListAction") << "final parent ID " << parentid;

    return parentid;
  }

simb::GeneratedParticleIndex_t larg4::ParticleListAction::GetPrimaryTruthIndex

(

int

trackId

)

const

Returns the index of primary truth (sim::NoGeneratorIndex if none).

Definition at line 505 of file ParticleListAction.cxx.

References util::end(), GetPrimaryTruthMap(), and simb::NoGeneratedParticleIndex.

Referenced by larg4::LArG4::produce().

  {
    auto const iInfo = GetPrimaryTruthMap().find(trackId);
    return (iInfo == GetPrimaryTruthMap().end()) ? simb::NoGeneratedParticleIndex : iInfo->second;
  } // ParticleListAction::GetPrimaryTruthIndex()

std::map<int, GeneratedParticleIndex_t> const& larg4::ParticleListAction::GetPrimaryTruthMap ( ) const

inline

Returns a map of truth record information index for each of the primary particles (by track ID).

Definition at line 114 of file ParticleListAction.h.

Referenced by GetPrimaryTruthIndex().

    {
      return fPrimaryTruthMap;
    }

bool larg4::ParticleListAction::hasList ( ) const

inline

Returns whether a particle list is being kept.

Definition at line 120 of file ParticleListAction.h.

{ return static_cast<bool>(fparticleList); }

bool larg4::ParticleListAction::isDropped ( simb::MCParticle const *  p )

static

returns whether the specified particle has been marked as dropped

Definition at line 50 of file ParticleListAction.cxx.

References simb::MCTrajectory::empty(), and simb::MCParticle::Trajectory().

Referenced by larg4::LArG4::produce().

  {
    return !p || p->Trajectory().empty();
  } // ParticleListAction::isDropped()

void larg4::ParticleListAction::ParticleFilter ( std::unique_ptr< util::PositionInVolumeFilter > &&  filter )

inline

Grabs a particle filter.

Definition at line 97 of file ParticleListAction.h.

Referenced by larg4::LArG4::beginRun().

    {
      fFilter = std::move(filter);
    }

void larg4::ParticleListAction::PostTrackingAction ( const G4Track *  aTrack )

virtual

Reimplemented from g4b::UserAction.

Definition at line 276 of file ParticleListAction.cxx.

References larg4::ParticleListAction::ParticleInfo_t::clear(), larg4::ParticleListAction::ParticleInfo_t::drop, fCurrentParticle, fdroppedParticleList, fparticleList, fPrimaryTruthMap, larg4::ParticleListAction::ParticleInfo_t::hasParticle(), larg4::ParticleListAction::ParticleInfo_t::isPrimary(), larg4::ParticleListAction::ParticleInfo_t::keep, larg4::ParticleListAction::ParticleInfo_t::particle, and larg4::ParticleListAction::ParticleInfo_t::truthInfoIndex().

  {
    if (!fCurrentParticle.hasParticle()) return;
    assert(fparticleList);

    if (aTrack) {
      fCurrentParticle.particle->SetWeight(aTrack->GetWeight());
      G4String process =
        aTrack->GetStep()->GetPostStepPoint()->GetProcessDefinedStep()->GetProcessName();
      fCurrentParticle.particle->SetEndProcess(process);
    }

    // We would keep it if it wasn't for KeepEMShowerDaughters = false
    // It goes into fDroppedParticleList in case LArG4 is configured
    // to keep a minimal version of it.
    if (fCurrentParticle.drop) {
      if (!fCurrentParticle.keep && fdroppedParticleList)
        fdroppedParticleList->Archive(fCurrentParticle.particle.get());
      fCurrentParticle.clear();
      return;
    }

    // if we have found no reason to keep it, drop it!
    // (we might still need parentage information though)
    if (!fCurrentParticle.keep) {
      fparticleList->Archive(fCurrentParticle.particle.get());
      // after the particle is archived, it is deleted
      fCurrentParticle.clear();
      return;
    }

    // store truth record pointer, only if it is available
    if (fCurrentParticle.isPrimary()) {
      fPrimaryTruthMap[fCurrentParticle.particle->TrackId()] = fCurrentParticle.truthInfoIndex();
    }

    return;
  }

void larg4::ParticleListAction::PreTrackingAction ( const G4Track *  )

virtual

G4UserTrackingAction interfaces.

Reimplemented from g4b::UserAction.

Definition at line 114 of file ParticleListAction.cxx.

References larg4::ParticleListAction::ParticleInfo_t::clear(), larg4::ParticleListAction::ParticleInfo_t::drop, energy, fCurrentOrigTrackID, fCurrentParticle, fCurrentPdgCode, fCurrentTrackID, fdroppedParticleList, fenergyCut, fFilter, fKeepEMShowerDaughters, fParentIDMap, fParentIDMap_OrigTrackID, fparticleList, fTrackIDOffset, GetParentage(), larg4::ParticleListAction::ParticleInfo_t::keep, g4b::PrimaryParticleInformation::MCParticleIndex(), MF_LOG_WARNING, simb::NoGeneratedParticleIndex, sim::NoParticleId, larg4::ParticleListAction::ParticleInfo_t::particle, and larg4::ParticleListAction::ParticleInfo_t::truthIndex.

  {
    // Particle type.
    G4ParticleDefinition* particleDefinition = track->GetDefinition();
    G4int pdgCode = particleDefinition->GetPDGEncoding();

    // Get Geant4's ID number for this track.  This will be the same
    // ID number that we'll use in the ParticleList.
    // It is offset by the number of tracks accumulated from the previous Geant4
    // runs (if any)
    G4int trackID = track->GetTrackID() + fTrackIDOffset;
    fCurrentTrackID = trackID;
    fCurrentOrigTrackID = trackID;
    fCurrentPdgCode = pdgCode;

    if (!fparticleList) {
      // the rest is about adding a new particle to the list: skip
      return; // note that fCurrentParticle is clear()'ed
    }

    // And the particle's parent (same offset as above):
    G4int parentID = track->GetParentID() + fTrackIDOffset;

    std::string process_name = "unknown";
    bool drop_shower_daughter = false;

    // Is there an MCTruth object associated with this G4Track?  We
    // have to go up a "chain" of information to find out:
    const G4DynamicParticle* dynamicParticle = track->GetDynamicParticle();
    const G4PrimaryParticle* primaryParticle = dynamicParticle->GetPrimaryParticle();
    simb::GeneratedParticleIndex_t primaryIndex = simb::NoGeneratedParticleIndex;
    if (primaryParticle != 0) {
      const G4VUserPrimaryParticleInformation* gppi = primaryParticle->GetUserInformation();
      const g4b::PrimaryParticleInformation* ppi =
        dynamic_cast<const g4b::PrimaryParticleInformation*>(gppi);
      if (ppi != 0) {
        primaryIndex = ppi->MCParticleIndex();

        // If we've made it this far, a PrimaryParticleInformation
        // object exists and we are using a primary particle, set the
        // process name accordingly
        process_name = "primary";

        // primary particles should have parentID = 0, even if there
        // are multiple MCTruths for this event
        parentID = 0;
      } // end else no primary particle information
    }   // Is there a G4PrimaryParticle?
    // If this is not a primary particle...
    else {
      // check if this particle was made in an EM shower, don't put it in the particle
      // list as we don't care about secondaries, tertiaries, etc for these showers
      // figure out what process is making this track - skip it if it is
      // one of pair production, compton scattering, photoelectric effect
      // bremstrahlung, annihilation, any ionization - who wants to save
      // a buttload of electrons that arent from a CC interaction?
      process_name = track->GetCreatorProcess()->GetProcessName();
      drop_shower_daughter =
        (!fKeepEMShowerDaughters && (process_name.find("conv") != std::string::npos ||
                                     process_name.find("LowEnConversion") != std::string::npos ||
                                     process_name.find("Pair") != std::string::npos ||
                                     process_name.find("compt") != std::string::npos ||
                                     process_name.find("Compt") != std::string::npos ||
                                     process_name.find("Brem") != std::string::npos ||
                                     process_name.find("phot") != std::string::npos ||
                                     process_name.find("Photo") != std::string::npos ||
                                     process_name.find("Ion") != std::string::npos ||
                                     process_name.find("annihil") != std::string::npos));
      if (drop_shower_daughter) {

        // figure out the ultimate parentage of this particle
        // first add this track id and its parent to the fParentIDMap
        fParentIDMap[trackID] = parentID;

        fCurrentTrackID = -1 * this->GetParentage(
                                 trackID); // the real trackID remains stored in fCurrentOrigTrackID

        // check that fCurrentTrackID is in the particle list - it is possible
        // that this particle's parent is a particle that did not get tracked.
        // An example is a partent that was made due to muMinusCaptureAtRest
        // and the daughter was made by the phot process.  The parent likely
        // isn't saved in the particle list because it is below the energy cut
        // which will put a bogus track id value into the sim::IDE object for
        // the sim::SimChannel if we don't check it.
        if (!fparticleList->KnownParticle(fCurrentTrackID)) fCurrentTrackID = sim::NoParticleId;

      } // end if keeping EM shower daughters

      // Check the energy of the particle.  If it falls below the energy
      // cut, don't add it to our list.
      G4double energy = track->GetKineticEnergy();
      if (energy < fenergyCut) {
        fCurrentParticle.clear();

        // do add the particle to the parent id map though
        // and set the current track id to be it's ultimate parent
        fParentIDMap[trackID] = parentID;
        fParentIDMap_OrigTrackID[trackID] = parentID;

        fCurrentTrackID = -1 * this->GetParentage(trackID);
        fCurrentOrigTrackID = -1 * this->GetParentage(trackID, true);

        return;
      }

      // check to see if the parent particle has been stored in the particle navigator
      // if not, then see if it is possible to walk up the fParentIDMap to find the
      // ultimate parent of this particle.  Use that ID as the parent ID for this
      // particle
      if (!fparticleList->KnownParticle(parentID) &&
          !(fdroppedParticleList && fdroppedParticleList->KnownParticle(parentID))) {
        // do add the particle to the parent id map
        // just in case it makes a daughter that we have to track as well
        fParentIDMap[trackID] = parentID;
        fParentIDMap_OrigTrackID[trackID] = parentID;
        int pid = this->GetParentage(parentID);

        // if we still can't find the parent in the particle navigator,
        // we have to give up
        if (!fparticleList->KnownParticle(pid) &&
            !(fdroppedParticleList && fdroppedParticleList->KnownParticle(parentID))) {
          MF_LOG_WARNING("ParticleListAction")
            << "can't find parent id: " << parentID << " in the particle list, or fParentIDMap."
            << " Make " << parentID << " the mother ID for"
            << " track ID " << fCurrentTrackID << " in the hope that it will aid debugging.";
        }
        else
          parentID = pid;
      }

    } // end if not a primary particle

    // This is probably the PDG mass, but just in case:
    double mass = dynamicParticle->GetMass() / CLHEP::GeV;

    // Create the sim::Particle object.
    fCurrentParticle.clear();
    fCurrentParticle.particle =
      new simb::MCParticle(trackID, pdgCode, process_name, parentID, mass);
    fCurrentParticle.truthIndex = primaryIndex;

    // if we are not filtering, we have a decision already
    if (!fFilter) fCurrentParticle.keep = true;

    // Polarization.
    const G4ThreeVector& polarization = track->GetPolarization();
    fCurrentParticle.particle->SetPolarization(
      TVector3(polarization.x(), polarization.y(), polarization.z()));

    // if KeepEMShowerDaughters = False and we decided to drop this particle,
    // record it before throwing it away.
    if (drop_shower_daughter) {
      fCurrentParticle.drop = true;
      if (fdroppedParticleList) fdroppedParticleList->Add(fCurrentParticle.particle.get());
      return;
    }

    // Save the particle in the ParticleList.
    fparticleList->Add(fCurrentParticle.particle.get());
  }

virtual void g4b::UserAction::PrintConfig ( std::string const &  )

inlinevirtualinherited

Override PrintConfig() to print out current configuration.

Reimplemented in altns::ExampleAction.

Definition at line 68 of file UserAction.h.

Referenced by g4b::UserActionManager::PrintActionList().

{};

virtual bool g4b::UserAction::ProvidesStacking ( )

inlinevirtualinherited

Does this UserAction do stacking? Override to return "true" if the following interfaces are implemented

Reimplemented in altns::ExampleAction.

Definition at line 90 of file UserAction.h.

Referenced by g4b::UserActionManager::PrintActionList().

{ return false; } 

void larg4::ParticleListAction::ResetTrackIDOffset ( )

inline

Definition at line 107 of file ParticleListAction.h.

Referenced by larg4::LArG4::produce().

{ fTrackIDOffset = 0; }

void g4b::UserAction::SetName ( std::string const &  name )

inlineinherited

Definition at line 99 of file UserAction.h.

References g4b::UserAction::myName.

Referenced by g4b::UserActionFactory::GetUserAction().

{ myName = name; }

virtual G4ClassificationOfNewTrack g4b::UserAction::StackClassifyNewTrack ( const G4Track *  )

inlinevirtualinherited

G4UserStackingAction interfaces.

Reimplemented in altns::ExampleAction.

Definition at line 93 of file UserAction.h.

{ return fUrgent; }

virtual void g4b::UserAction::StackNewStage ( )

inlinevirtualinherited

Reimplemented in altns::ExampleAction.

Definition at line 94 of file UserAction.h.

{};

virtual void g4b::UserAction::StackPrepareNewEvent ( )

inlinevirtualinherited

Reimplemented in altns::ExampleAction.

Definition at line 95 of file UserAction.h.

{};

void larg4::ParticleListAction::SteppingAction ( const G4Step *  )

virtual

G4UserSteppingAction interface.

Reimplemented from g4b::UserAction.

Definition at line 317 of file ParticleListAction.cxx.

References AddPointToCurrentParticle(), energy, fCurrentParticle, fstoreTrajectories, globalTime, larg4::ParticleListAction::ParticleInfo_t::hasParticle(), MF_LOG_DEBUG, larg4::ParticleListAction::ParticleInfo_t::particle, velocity_G4, and velocity_step.

  {

    if (!fCurrentParticle.hasParticle()) { return; }

    // Temporary fix for problem where  DeltaTime on the first step
    // of optical photon propagation is calculated incorrectly. -wforeman
    globalTime = step->GetTrack()->GetGlobalTime();
    velocity_G4 = step->GetTrack()->GetVelocity();
    velocity_step = step->GetStepLength() / step->GetDeltaTime();
    if ((step->GetTrack()->GetDefinition()->GetPDGEncoding() == 0) &&
        fabs(velocity_G4 - velocity_step) > 0.0001) {
      // Subtract the faulty step time from the global time,
      // and add the correct step time based on G4 velocity.
      step->GetPostStepPoint()->SetGlobalTime(globalTime - step->GetDeltaTime() +
                                              step->GetStepLength() / velocity_G4);
    }

    // For the most part, we just want to add the post-step
    // information to the particle's trajectory.  There's one
    // exception: In PreTrackingAction, the correct time information
    // is not available.  So add the correct vertex information here.

    if (fCurrentParticle.particle->NumberTrajectoryPoints() == 0) {

      // Get the pre/along-step information from the G4Step.
      const G4StepPoint* preStepPoint = step->GetPreStepPoint();

      const G4ThreeVector position = preStepPoint->GetPosition();
      G4double time = preStepPoint->GetGlobalTime();

      // Remember that LArSoft uses cm, ns, GeV.
      TLorentzVector fourPos(position.x() / CLHEP::cm,
                             position.y() / CLHEP::cm,
                             position.z() / CLHEP::cm,
                             time / CLHEP::ns);

      const G4ThreeVector momentum = preStepPoint->GetMomentum();
      const G4double energy = preStepPoint->GetTotalEnergy();
      TLorentzVector fourMom(momentum.x() / CLHEP::GeV,
                             momentum.y() / CLHEP::GeV,
                             momentum.z() / CLHEP::GeV,
                             energy / CLHEP::GeV);

      // Add the first point in the trajectory.
      AddPointToCurrentParticle(fourPos, fourMom, "Start");

    } // end if this is the first step

    // At this point, the particle is being transported through the
    // simulation. This method is being called for every voxel that
    // the track passes through, but we don't want to update the
    // trajectory information if we're just updating voxels. To check
    // for this, look at the process name for the step, and compare it
    // against the voxelization process name (set in PhysicsList.cxx).
    G4String process = step->GetPostStepPoint()->GetProcessDefinedStep()->GetProcessName();
    G4bool ignoreProcess = process.contains("LArVoxel") || process.contains("OpDetReadout");

    MF_LOG_DEBUG("ParticleListAction::SteppingAction")
      << ": DEBUG - process='" << process << "'"
      << " ignoreProcess=" << ignoreProcess << " fstoreTrajectories=" << fstoreTrajectories;

    // We store the initial creation point of the particle
    // and its final position (ie where it has no more energy, or at least < 1 eV) no matter
    // what, but whether we store the rest of the trajectory depends
    // on the process, and on a user switch
    if (fstoreTrajectories && !ignoreProcess) {
      // If the particle was marked to drop (EM shower daughters),
      // then skip unless this step is last in volume.
      //if (fCurrentParticle.drop && !step->IsLastStepInVolume()) return;

      // Get the post-step information from the G4Step.
      const G4StepPoint* postStepPoint = step->GetPostStepPoint();

      const G4ThreeVector position = postStepPoint->GetPosition();
      G4double time = postStepPoint->GetGlobalTime();

      // Remember that LArSoft uses cm, ns, GeV.
      TLorentzVector fourPos(position.x() / CLHEP::cm,
                             position.y() / CLHEP::cm,
                             position.z() / CLHEP::cm,
                             time / CLHEP::ns);

      const G4ThreeVector momentum = postStepPoint->GetMomentum();
      const G4double energy = postStepPoint->GetTotalEnergy();
      TLorentzVector fourMom(momentum.x() / CLHEP::GeV,
                             momentum.y() / CLHEP::GeV,
                             momentum.z() / CLHEP::GeV,
                             energy / CLHEP::GeV);

      // Add another point in the trajectory.
      AddPointToCurrentParticle(fourPos, fourMom, std::string(process));
    }
  }

sim::ParticleList && larg4::ParticleListAction::YieldDroppedList

(

)

Yields the (dropped) ParticleList accumulated during the current event.

Definition at line 542 of file ParticleListAction.cxx.

References fdroppedParticleList, fparticleList, and fTrackIDOffset.

Referenced by larg4::LArG4::produce().

  {
    if (!fdroppedParticleList) {
      throw cet::exception("ParticleListAction")
        << "ParticleListAction::YieldDroppedList(): dropped particle list not build by user "
           "request.\n";
    }
    // check if the ParticleNavigator has entries, and if
    // so grab the highest track id value from it to
    // add to the fTrackIDOffset
    int highestID = 0;
    for (auto pn = fparticleList->begin(); pn != fparticleList->end(); pn++)
      if ((*pn).first > highestID) highestID = (*pn).first;

    // If we have stored dropped particles,
    // include them in the offset.
    for (auto pn = fdroppedParticleList->begin(); pn != fdroppedParticleList->end(); pn++)
      if ((*pn).first > highestID) highestID = (*pn).first;

    //Only change the fTrackIDOffset if there is in fact a particle to add to the event
    if ((fparticleList->size()) != 0) { fTrackIDOffset = highestID + 1; }

    return std::move(*fdroppedParticleList);
  } // ParticleList&& ParticleListAction::YieldDroppedList()

sim::ParticleList && larg4::ParticleListAction::YieldList

(

)

Definition at line 513 of file ParticleListAction.cxx.

References fdroppedParticleList, fparticleList, and fTrackIDOffset.

Referenced by larg4::LArG4::produce().

  {
    if (!fparticleList) {
      // check with `hasList()` before calling this method
      throw cet::exception("ParticleListAction")
        << "ParticleListAction::YieldList(): particle list not build by user request.\n";
    }
    // check if the ParticleNavigator has entries, and if
    // so grab the highest track id value from it to
    // add to the fTrackIDOffset
    int highestID = 0;
    for (auto pn = fparticleList->begin(); pn != fparticleList->end(); pn++)
      if ((*pn).first > highestID) highestID = (*pn).first;

    // If we have stored dropped particles,
    // include them in the offset.
    if (fdroppedParticleList) {
      for (auto pn = fdroppedParticleList->begin(); pn != fdroppedParticleList->end(); pn++)
        if ((*pn).first > highestID) highestID = (*pn).first;
    }

    //Only change the fTrackIDOffset if there is in fact a particle to add to the event
    if ((fparticleList->size()) != 0) { fTrackIDOffset = highestID + 1; }

    return std::move(*fparticleList);
  } // ParticleList&& ParticleListAction::YieldList()

Member Data Documentation

int larg4::ParticleListAction::fCurrentOrigTrackID = sim::NoParticleId

staticprivate

except for EM shower particles where it always shows the original track ID

g4 real track ID of the current particle (including for EM shower daughters)

Definition at line 155 of file ParticleListAction.h.

Referenced by BeginOfEventAction(), and PreTrackingAction().

ParticleInfo_t larg4::ParticleListAction::fCurrentParticle

private

information about the particle currently being simulated for a single particle.

Definition at line 141 of file ParticleListAction.h.

Referenced by AddPointToCurrentParticle(), BeginOfEventAction(), PostTrackingAction(), PreTrackingAction(), and SteppingAction().

int larg4::ParticleListAction::fCurrentPdgCode = 0

staticprivate

pdg code of current particle

Definition at line 157 of file ParticleListAction.h.

Referenced by BeginOfEventAction(), and PreTrackingAction().

int larg4::ParticleListAction::fCurrentTrackID = sim::NoParticleId

staticprivate

track ID of the current particle, set to eve ID for EM shower particles

Definition at line 152 of file ParticleListAction.h.

Referenced by BeginOfEventAction(), and PreTrackingAction().

std::unique_ptr<sim::ParticleList> larg4::ParticleListAction::fdroppedParticleList

private

The accumulated particle information for all dropped particles in the event.

Definition at line 146 of file ParticleListAction.h.

Referenced by BeginOfEventAction(), GetList(), PostTrackingAction(), PreTrackingAction(), YieldDroppedList(), and YieldList().

G4double larg4::ParticleListAction::fenergyCut

private

The minimum energy for a particle to be included in the list.

Definition at line 139 of file ParticleListAction.h.

Referenced by PreTrackingAction().

std::unique_ptr<util::PositionInVolumeFilter> larg4::ParticleListAction::fFilter

private

filter for particles to be kept

Definition at line 162 of file ParticleListAction.h.

Referenced by AddPointToCurrentParticle(), and PreTrackingAction().

bool larg4::ParticleListAction::fKeepEMShowerDaughters

private

whether to keep EM shower secondaries, tertiaries, etc

Definition at line 160 of file ParticleListAction.h.

Referenced by PreTrackingAction().

std::map<int, int> larg4::ParticleListAction::fParentIDMap

private

key is current track ID, value is parent ID

Definition at line 149 of file ParticleListAction.h.

Referenced by BeginOfEventAction(), GetParentage(), and PreTrackingAction().

std::map<int, int> larg4::ParticleListAction::fParentIDMap_OrigTrackID

private

key is current track ID, value is parent ID – for real G4 track ID tracking only

Definition at line 151 of file ParticleListAction.h.

Referenced by BeginOfEventAction(), GetParentage(), and PreTrackingAction().

std::unique_ptr<sim::ParticleList> larg4::ParticleListAction::fparticleList

private

The accumulated particle information for all particles in the event.

Definition at line 143 of file ParticleListAction.h.

Referenced by BeginOfEventAction(), EndOfEventAction(), GetList(), PostTrackingAction(), PreTrackingAction(), YieldDroppedList(), and YieldList().

std::map<int, GeneratedParticleIndex_t> larg4::ParticleListAction::fPrimaryTruthMap

private

Map: particle track ID -> index of primary information in MC truth.

Definition at line 165 of file ParticleListAction.h.

Referenced by PostTrackingAction().

G4bool larg4::ParticleListAction::fstoreTrajectories

private

Whether to store particle trajectories with each particle.

Definition at line 148 of file ParticleListAction.h.

Referenced by SteppingAction().

int larg4::ParticleListAction::fTrackIDOffset = 0

staticprivate

offset added to track ids when running over multiple MCTruth objects.

Definition at line 158 of file ParticleListAction.h.

Referenced by GetList(), PreTrackingAction(), YieldDroppedList(), and YieldList().

---

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

• larsim/v09_43_00/source/larsim/LegacyLArG4/ParticleListAction.h
• larsim/v09_43_00/source/larsim/LegacyLArG4/ParticleListAction.cxx