simcore::TrackMap Class Reference

Defines a map of particle ancestry and particles to be saved. More...

#include <TrackMap.h>

Public Member Functions
void	insert (const G4Track *track)
	Add a record in the map for the input track.
bool	contains (const G4Track *track) const
	Check if the passed track has already been inserted into the track map.
bool	isDescendant (int trackID, int ancestorID, int maximum_depth) const
	Check if the track with the given ID is a descendant of the track with the given ancestor ID up to a given depth.
int	findIncident (int trackID) const
	Find a trajectory's nearest parent that is incident on the calorimeter region.
bool	isSaved (int trackID) const
	Return true if the given track ID is saved i.e.
void	save (const G4Track *track)
	Add a track to be stored into output map.
void	traceAncestry ()
	Trace the ancestry for the particles that will be stored.
void	clear ()
	Clear the internal maps.
std::map< int, ldmx::SimParticle > &	getParticleMap ()
	Get the map of particles to be stored in output event.

Private Member Functions
bool	isInCalorimeterRegion (const G4Track *track) const
	Was the input track generated inside the calorimeter region?

Private Attributes
std::unordered_map< int, std::pair< int, bool > >	ancestry_
	ancestry map of particles in event (child -> parent)
std::unordered_map< int, std::vector< int > >	descendents_
	descendents map of particles in event (parent -> children)
std::map< int, ldmx::SimParticle >	particle_map_
	map of SimParticles that will be stored

Detailed Description

Defines a map of particle ancestry and particles to be saved.

This class keeps track of the ancestry (child -> parent) and descendents (parent -> children) of ALL particles generated in an event. This allows the particles that are chosen to be saved (via the TrackMap::save method) to have their parent and children faithfully recorded in the output file.

Definition at line 25 of file TrackMap.h.

Member Function Documentation

clear()

void simcore::TrackMap::clear

(

)

Clear the internal maps.

This should be called at the beginning of an event. The maps need to persist through the end of the event so that they are available to be written to the output file.

Definition at line 128 of file TrackMap.cxx.

                     {
  ancestry_.clear();
  descendents_.clear();
  particle_map_.clear();
}

References ancestry_, descendents_, and particle_map_.

Referenced by simcore::g4user::EventAction::BeginOfEventAction().

contains()

bool simcore::TrackMap::contains ( const G4Track * track ) const

inline

Check if the passed track has already been inserted into the track map.

Definition at line 37 of file TrackMap.h.

                                                   {
    return ancestry_.find(track->GetTrackID()) != ancestry_.end();
  }

References ancestry_.

Referenced by simcore::g4user::TrackingAction::PreUserTrackingAction().

findIncident()

int simcore::TrackMap::findIncident

(

int

trackID

)

const

Find a trajectory's nearest parent that is incident on the calorimeter region.

We assume that the primary particles have a parent ID of 0.

If this track ID does not have such a trajectory, then the track ID of the primary in its parentage is returned.

Parameters

trackID

The track ID to search its parentage for the incident

Definition at line 36 of file TrackMap.cxx.

                                              {
  int curr_track_id = trackID;
  bool found_incident{false};
  while (not found_incident) {
    auto& [parentID, inCalRegion] = ancestry_.at(curr_track_id);
    if (not inCalRegion or parentID == 0) {
      // current track ID is nearest ancestor
      // originating outside cal region
      // or is a primary particle
      found_incident = true;
    } else {
      // still in cal region, keep going
      curr_track_id = parentID;
    }
  }
  return curr_track_id;
}

References ancestry_.

getParticleMap()

std::map< int, ldmx::SimParticle > & simcore::TrackMap::getParticleMap ( )

inline

Get the map of particles to be stored in output event.

Definition at line 98 of file TrackMap.h.

{ return particle_map_; }

References particle_map_.

Referenced by simcore::UserAction::getCurrentParticleMap().

insert()

void simcore::TrackMap::insert

(

const G4Track *

track

)

Add a record in the map for the input track.

Parameters

track

G4Track to insert

Definition at line 30 of file TrackMap.cxx.

                                          {
  ancestry_[track->GetTrackID()] =
      std::make_pair(track->GetParentID(), isInCalorimeterRegion(track));
  descendents_[track->GetParentID()].push_back(track->GetTrackID());
}

References ancestry_, descendents_, and isInCalorimeterRegion().

Referenced by simcore::g4user::TrackingAction::PreUserTrackingAction().

isDescendant()

bool simcore::TrackMap::isDescendant	(	int	trackID,
		int	ancestorID,
		int	maximum_depth ) const

Check if the track with the given ID is a descendant of the track with the given ancestor ID up to a given depth.

Definition at line 10 of file TrackMap.cxx.

                                                     {
  int current_depth{0};
  int current_track{trackID};
  // Walk the tree until we either no longer have a parent or we reach the
  // desired depth
  while (current_depth < maximum_depth &&
         (ancestry_.find(current_track) != ancestry_.end())) {
    // See if we have encountered the parent of the current track
    //
    // operator[] is not const, so we need to use at()
    current_track = ancestry_.at(current_track).first;
    if (current_track == ancestorID) {
      // If one of the parents is the track of interest, we are done!
      return true;
    }
    current_depth++;
  }
  return false;
}

References ancestry_.

isInCalorimeterRegion()

bool simcore::TrackMap::isInCalorimeterRegion ( const G4Track * track ) const

private

Was the input track generated inside the calorimeter region?

We rely on the fact that the calorimeter region is named 'CalorimeterRegion' and no other region names contain the string 'Calorimeter'

Definition at line 134 of file TrackMap.cxx.

                                                               {
  auto region{track->GetLogicalVolumeAtVertex()->GetRegion()->GetName()};
  return region.contains("Calorimeter");
}

Referenced by insert().

isSaved()

bool simcore::TrackMap::isSaved ( int trackID ) const

inline

Return true if the given track ID is saved i.e.

will be stored in output file

Parameters

trackID

The track ID.

Returns

True if the track ID has been inserted in output particle map

Definition at line 65 of file TrackMap.h.

                                         {
    return particle_map_.find(trackID) != particle_map_.end();
  }

References particle_map_.

save()

void simcore::TrackMap::save

(

const G4Track *

track

)

Add a track to be stored into output map.

Note

We assume that the track is at the end of processing so that its current kinematics can be labeled as the "end-point" kinematics.

Parameters

track

G4Track to store into output

Definition at line 54 of file TrackMap.cxx.

                                        {
  // create sim particle in map, keep reference to the newly created particle
  ldmx::SimParticle& particle{particle_map_[track->GetTrackID()]};
 
  // TODO: default gen status?
  particle.setGenStatus(0);
 
  // Update the gen status from the primary particle.
  if (track->GetDynamicParticle()->GetPrimaryParticle() != nullptr) {
    G4VUserPrimaryParticleInformation* primary_info =
        track->GetDynamicParticle()->GetPrimaryParticle()->GetUserInformation();
    if (primary_info != nullptr) {
      particle.setGenStatus(
          ((UserPrimaryParticleInformation*)primary_info)->getHepEvtStatus());
    }
  }
 
  auto particle_def{track->GetDefinition()};
 
  particle.setPdgID(particle_def->GetPDGEncoding());
  particle.setCharge(particle_def->GetPDGCharge());
  particle.setMass(track->GetDynamicParticle()->GetMass());
  particle.setEnergy(track->GetVertexKineticEnergy() +
                     track->GetDynamicParticle()->GetMass());
 
  auto track_info{UserTrackInformation::get(track)};
  particle.setVertexVolume(track_info->getVertexVolume());
  particle.setInteractionMaterial(track->GetMaterial()->GetName());
 
  auto vert{track->GetVertexPosition()};
  particle.setVertex(vert.x(), vert.y(), vert.z());
  particle.setTime(track_info->getVertexTime());
 
  auto init_momentum{track_info->getInitialMomentum()};
  particle.setMomentum(init_momentum.x(), init_momentum.y(), init_momentum.z());
 
  const G4VProcess* process{track->GetCreatorProcess()};
  if (process) {
    const G4String& name{process->GetProcessName()};
    particle.setProcessType(ldmx::SimParticle::findProcessType(name));
  } else {
    if (track->GetParentID() == 0) {
      particle.setProcessType(ldmx::SimParticle::ProcessType::Primary);
    } else {
      particle.setProcessType(ldmx::SimParticle::ProcessType::unknown);
    }
  }
 
  // track's current kinematics is its end point kinematics
  //  because we are assuming this track is being stopped/killed
 
  auto momentum{track->GetMomentum()};
  particle.setEndPointMomentum(momentum.x(), momentum.y(), momentum.z());
 
  auto end_pt{track->GetPosition()};
  particle.setEndPoint(end_pt.x(), end_pt.y(), end_pt.z());
}

References ldmx::SimParticle::findProcessType(), simcore::UserTrackInformation::get(), particle_map_, and ldmx::SimParticle::setGenStatus().

Referenced by simcore::g4user::TrackingAction::PostUserTrackingAction().

traceAncestry()

void simcore::TrackMap::traceAncestry

(

)

Trace the ancestry for the particles that will be stored.

This should be done at the end of the event before writing the particle map to the event bus and involves looping through the particles that will be saved.

Use [] instead of at() for descendents_ so that if it wasn't previously created, we will just silently create an empty vector and move on.

Definition at line 112 of file TrackMap.cxx.

                             {
  for (auto& [id, particle] : particle_map_) {
    particle.addParent(ancestry_.at(id).first);
 
    for (auto& child : descendents_[id]) {
      particle.addDaughter(child);
    }
  }
}

References ancestry_, descendents_, and particle_map_.

Member Data Documentation

ancestry_

std::unordered_map<int, std::pair<int, bool> > simcore::TrackMap::ancestry_

private

ancestry map of particles in event (child -> parent)

Primary particles are given a "parent" ID of 0 to reflect that they don't have a parent. This is the default in Geant4 and we assume that holds here.

This is helpful for the findIncident method which looks up through a track's history to find the first ancestor which originated outside of the calorimeter region.

The key value is a pair where the first entry is the parent track ID and the second entry is whether the child track is in the calorimeter region.

See also

isInCalorimeterRegion for how we check if a track originated in the calorimeter region.

Definition at line 129 of file TrackMap.h.

Referenced by clear(), contains(), findIncident(), insert(), isDescendant(), and traceAncestry().

descendents_

std::unordered_map<int, std::vector<int> > simcore::TrackMap::descendents_

private

descendents map of particles in event (parent -> children)

Definition at line 132 of file TrackMap.h.

Referenced by clear(), insert(), and traceAncestry().

particle_map_

std::map<int, ldmx::SimParticle> simcore::TrackMap::particle_map_

private

map of SimParticles that will be stored

Definition at line 135 of file TrackMap.h.

Referenced by clear(), getParticleMap(), isSaved(), save(), and traceAncestry().

---

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

• SimCore/include/SimCore/G4User/TrackMap.h
• SimCore/src/SimCore/G4User/TrackMap.cxx