ParticleListAction.h

Go to the documentation of this file.

//

#ifndef LArG4_ParticleListAction_h
#define LArG4_ParticleListAction_h

#include "Geant4/G4Types.hh"
#include "TLorentzVector.h"

#include "cetlib/exempt_ptr.h"
#include "larcorealg/CoreUtils/ParticleFilters.h" // util::PositionInVolumeFilter
#include "nug4/G4Base/UserAction.h"
#include "nusimdata/SimulationBase/simb.h" // simb::GeneratedParticleIndex_t

#include <map>
#include <memory>

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

namespace sim {
  class ParticleList;
}

namespace simb {
  class MCParticle;
}

namespace larg4 {

  class ParticleListAction : public g4b::UserAction {
  public:
    using GeneratedParticleIndex_t = simb::GeneratedParticleIndex_t;

    struct ParticleInfo_t {

      cet::exempt_ptr<simb::MCParticle> particle; 
      bool keep = false;                          
      bool drop =
        false; 
      GeneratedParticleIndex_t truthIndex = simb::NoGeneratedParticleIndex;

      void clear()
      {
        particle = nullptr;
        keep = false;
        drop = false;
        truthIndex = simb::NoGeneratedParticleIndex;
      }

      bool hasParticle() const { return !particle.empty(); }

      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,
                       bool keepMCParticleList = true,
                       bool storeDroppedMCParticles = false);

    // 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 GetCurrentOrigTrackID() { return fCurrentOrigTrackID; }
    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;
    }

    bool hasList() const { return static_cast<bool>(fparticleList); }

    GeneratedParticleIndex_t GetPrimaryTruthIndex(int trackId) const;

    // Yields the ParticleList accumulated during the current event.
    sim::ParticleList&& YieldList();

    sim::ParticleList&& YieldDroppedList();

    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, bool useOrigTrackIDMap = false) const;

    G4double fenergyCut;             
    ParticleInfo_t fCurrentParticle; 
    std::unique_ptr<sim::ParticleList> fparticleList; 
    std::unique_ptr<sim::ParticleList>
      fdroppedParticleList;          
    G4bool fstoreTrajectories;       
    std::map<int, int> fParentIDMap; 
    std::map<int, int>
      fParentIDMap_OrigTrackID; 
    static int fCurrentTrackID; 
    static int
      fCurrentOrigTrackID; 
    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