#include "EmEveIdCalculator.h"

Inheritance diagram for sim::EmEveIdCalculator:

Public Member Functions
	EmEveIdCalculator ()

virtual	~EmEveIdCalculator ()

void	Init (const sim::ParticleList *list)
	Initialize this calculator for a particular ParticleList. More...

const sim::ParticleList *	ParticleList () const

int	CalculateEveId (const int trackID)

Protected Attributes
const sim::ParticleList *	m_particleList

Private Member Functions
virtual int	DoCalculateEveId (const int trackID)

Detailed Description

Definition at line 63 of file EmEveIdCalculator.h.

Constructor & Destructor Documentation

sim::EmEveIdCalculator::EmEveIdCalculator ( )

inline

Definition at line 67 of file EmEveIdCalculator.h.

68 : EveIdCalculator() // Make sure the parent class constructor is called

69 {}

sim::EveIdCalculator::EveIdCalculator

EveIdCalculator()

Constructor and destructor.

Definition: EveIdCalculator.cxx:19

virtual sim::EmEveIdCalculator::~EmEveIdCalculator ( )

inlinevirtual

Definition at line 70 of file EmEveIdCalculator.h.

References DoCalculateEveId().

70 {}

Member Function Documentation

int sim::EveIdCalculator::CalculateEveId ( const int trackID )

inherited

The main eve ID calculation method. This is the reason why we use the Template Method for this class: because no matter what the core eve ID calculation is, we want to perform the following an additional task: The eve ID calculation can be lengthy. If the user is going through a LArVoxelList and trying to figuring out the eve ID associated with each voxel, this routine may be called many times. To save on time, keep the results of previous eve ID calculations for the current particle list. Only do the complete eve ID calculation if we haven't done it already for a given track ID.

Definition at line 42 of file EveIdCalculator.cxx.

References sim::EveIdCalculator::DoCalculateEveId(), and sim::EveIdCalculator::m_previousList.

Referenced by sim::EveIdCalculator::ParticleList().

   {
     // Look to see if the eve ID has been previously calculated for
     // this track.
     m_previousList_ptr search = m_previousList.find( trackID );
     if ( search == m_previousList.end() ){
       // It hasn't been calculated before. Do the full eve ID
       // calculation.
       int eveID = DoCalculateEveId( trackID );
       
       // Save the result of the calculation.
       m_previousList[ trackID ] = eveID;
       
       return eveID;
     }
 
     // If we get here, we've calculated the eve ID for this track
     // before. Return that result.
     return (*search).second;
   }

int sim::EmEveIdCalculator::DoCalculateEveId ( const int trackID )

privatevirtual

This is the core method to calculate the eve ID. If another class is going to override the default calculation, this the method that must be implemented.

Reimplemented from sim::EveIdCalculator.

Definition at line 22 of file EmEveIdCalculator.cxx.

References sim::EveIdCalculator::m_particleList.

Referenced by ~EmEveIdCalculator().

   {
     // Almost any eve ID calculation will use this: Get the entire
     // history of the particle and its ancestors in the simulated
     // event. (m_particleList is defined in EveIdCalculator.h)
     const sim::ParticleHistory particleHistory( m_particleList, trackID );
 
     // You can treat particleHistory like an array, and do something
     // like:
 
     // for ( int i = particleHistory.size(); i >= 0; --i ) 
     // { const simb::MCParticle* particle = particleHistory[i]; ... }
 
     // But we know how to use the Standard Template Library (Yes, you
     // do! Don't doubt yourself!) so let's treat particleHistory in
     // the most efficient manner, as an STL container. We want to scan
     // the container from its last element to its first, from the base
     // of the particle production chain towards the primary particle.
 
     for(auto i = particleHistory.rbegin(); i != particleHistory.rend(); ++i){
       // Get the text string that describes the process that created
       // the particle.
       std::string process = (*i)->Process();
 
       // Skip it if it was created by pair production, compton
       // scattering, photoelectric effect, bremstrahlung,
       // annihilation, or any ionization. (The ultimate source of
       // the process names are the physics lists used in Geant4.)
       
       if ( process.find("conv")              != std::string::npos ||
            process.find("LowEnConversion")   != std::string::npos ||
            process.find("Pair")              != std::string::npos ||
            process.find("compt")             != std::string::npos ||
            process.find("Compt")             != std::string::npos ||
            process.find("Brem")              != std::string::npos ||
            process.find("phot")              != std::string::npos ||
            process.find("Photo")             != std::string::npos ||
            process.find("Ion")               != std::string::npos ||
            process.find("annihil")           != std::string::npos) continue;         
 
       // If we get here, the particle wasn't created by any of the
       // above processes. Return its ID.
       return (*i)->TrackId();
     }
 
     // If we get here, we've skipped every particle in the
     // chain. Perhaps it was empty.
     return 0;
   }

void sim::EveIdCalculator::Init ( const sim::ParticleList * list )

inherited

Initialize this calculator for a particular ParticleList.

Definition at line 31 of file EveIdCalculator.cxx.

References sim::EveIdCalculator::m_particleList, and sim::EveIdCalculator::m_previousList.

   {
     // Save the ParticleList associated with this simulated chain of
     // particles.
     m_particleList = list;
 
     // Reset the results of previous calculations.
     m_previousList.clear();
   }