ParticleListAction.h

Go to the documentation of this file.

//

#ifndef LArG4_ParticleListAction_h
#define LArG4_ParticleListAction_h

#include "larcorealg/CoreUtils/ParticleFilters.h" // util::PositionInVolumeFilter
#include "lardataobj/Simulation/sim.h" // sim::GeneratorIndex_t, ...
#include "nutools/ParticleNavigation/ParticleList.h"

#include "nusimdata/SimulationBase/MCParticle.h"
#include "nusimdata/SimulationBase/simb.h" // simb::GeneratedParticleIndex_t
#include "nutools/G4Base/UserAction.h"

#include "Geant4/globals.hh"
#include <map>
#include <limits> // std::numeric_limits<>
#include <cstddef> // std::size_t

// Forward declarations.
class G4Event;
class G4Track;
class G4Step;

namespace sim { 
  class ParticleList; 
}

namespace larg4 {
  
  class ParticleListAction : public g4b::UserAction
  {
  public:
    using GeneratedParticleIndex_t = simb::GeneratedParticleIndex_t;
    
    struct ParticleInfo_t {
      
      simb::MCParticle* particle = nullptr;  
      bool              keep = false;        
      GeneratedParticleIndex_t truthIndex = simb::NoGeneratedParticleIndex;
      
      void clear()
        {
          particle = nullptr;
          keep = false;
          truthIndex = simb::NoGeneratedParticleIndex;
        }
      
      bool hasParticle() const { return particle; }
      
      bool isPrimary() const { return simb::isGeneratedParticleIndex(truthIndex); }
      
      bool keepParticle() const { return hasParticle() && keep; }
      
      GeneratedParticleIndex_t truthInfoIndex() const { return truthIndex; }
      
    }; // ParticleInfo_t

    // Standard constructors and destructors;
    ParticleListAction(double energyCut, bool storeTrajectories=false, bool keepEMShowerDaughters=false);
    virtual ~ParticleListAction();

    // UserActions method that we'll override, to obtain access to
    // Geant4's particle tracks and trajectories.
    virtual void             BeginOfEventAction(const G4Event*);
    virtual void             EndOfEventAction  (const G4Event*);
    virtual void             PreTrackingAction (const G4Track*);
    virtual void             PostTrackingAction(const G4Track*);
    virtual void             SteppingAction    (const G4Step* );

    void ParticleFilter(std::unique_ptr<util::PositionInVolumeFilter>&& filter)
      { fFilter = std::move(filter); }
  

    // TrackID of the current particle, EveID if the particle is from an EM shower
    static int               GetCurrentTrackID() { return fCurrentTrackID; }
    static int               GetCurrentPdgCode() { return fCurrentPdgCode; }
                                                                             
    void                     ResetTrackIDOffset() { fTrackIDOffset = 0;     }

    // Returns the ParticleList accumulated during the current event.
    const sim::ParticleList* GetList() const;
    
    std::map<int, GeneratedParticleIndex_t> const& GetPrimaryTruthMap() const
      { return fPrimaryTruthMap; }
    
    GeneratedParticleIndex_t GetPrimaryTruthIndex(int trackId) const;
    
    // Yields the ParticleList accumulated during the current event.
    sim::ParticleList&& YieldList();

    static bool isDropped(simb::MCParticle const* p);

  private:

    // this method will loop over the fParentIDMap to get the 
    // parentage of the provided trackid
    int                      GetParentage(int trackid) const;

    G4double                 fenergyCut;             
    ParticleInfo_t           fCurrentParticle;       
    sim::ParticleList*       fparticleList;          
    G4bool                   fstoreTrajectories;     
    std::map<int, int>       fParentIDMap;           
    static int               fCurrentTrackID;        
    static int               fCurrentPdgCode;        
    static int               fTrackIDOffset;         
    bool                     fKeepEMShowerDaughters; 
    
    std::unique_ptr<util::PositionInVolumeFilter> fFilter; 
    
    std::map<int, GeneratedParticleIndex_t> fPrimaryTruthMap;
    
    void AddPointToCurrentParticle(TLorentzVector const& pos,
                                   TLorentzVector const& mom,
                                   std::string    const& process);

  };

} // namespace LArG4

#endif // LArG4_ParticleListAction_h