LArPandoraHelper.h

Go to the documentation of this file.

 
#ifndef LAR_PANDORA_HELPER_H
#define LAR_PANDORA_HELPER_H
 
namespace art {
  class Event;
}
 
#include "canvas/Persistency/Common/Ptr.h"
 
#include <map>
#include <set>
#include <unordered_set>
#include <vector>
 
namespace anab {
  class CosmicTag;
  class T0;
}
namespace pandora {
  class ParticleFlowObject;
  class Vertex;
  typedef std::vector<int> IntVector;
}
namespace recob {
  class Cluster;
  class Hit;
  class PFParticle;
  class Seed;
  class Shower;
  class Slice;
  class SpacePoint;
  class Track;
  class Vertex;
  class Wire;
}
namespace larpandoraobj {
  class PFParticleMetadata;
}
 
#include "lardataobj/Simulation/SimChannel.h"
#include "nusimdata/SimulationBase/MCParticle.h"
 
namespace simb {
  class MCTruth;
}
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
namespace lar_pandora {
 
  typedef std::set<art::Ptr<recob::Hit>> HitList;
 
  typedef std::vector<art::Ptr<recob::Wire>> WireVector;
  typedef std::vector<art::Ptr<recob::Hit>> HitVector;
  typedef std::vector<art::Ptr<recob::SpacePoint>> SpacePointVector;
  typedef std::vector<art::Ptr<recob::Cluster>> ClusterVector;
  typedef std::vector<art::Ptr<recob::Seed>> SeedVector;
  typedef std::vector<art::Ptr<recob::Vertex>> VertexVector;
  typedef std::vector<art::Ptr<recob::Track>> TrackVector;
  typedef std::vector<art::Ptr<recob::Shower>> ShowerVector;
  typedef std::vector<art::Ptr<recob::PFParticle>> PFParticleVector;
  typedef std::vector<art::Ptr<simb::MCTruth>> MCTruthVector;
  typedef std::vector<art::Ptr<simb::MCParticle>> MCParticleVector;
  typedef std::vector<simb::MCParticle> RawMCParticleVector;
  typedef std::vector<art::Ptr<sim::SimChannel>> SimChannelVector;
  typedef std::vector<sim::TrackIDE> TrackIDEVector;
  typedef std::vector<art::Ptr<anab::CosmicTag>> CosmicTagVector;
  typedef std::vector<art::Ptr<anab::T0>> T0Vector;
  typedef std::vector<art::Ptr<larpandoraobj::PFParticleMetadata>> MetadataVector;
 
  typedef std::unordered_set<art::Ptr<recob::Hit>> HitSet;
 
  typedef std::map<art::Ptr<recob::PFParticle>, TrackVector> PFParticlesToTracks;
  typedef std::map<art::Ptr<recob::PFParticle>, ShowerVector> PFParticlesToShowers;
  typedef std::map<art::Ptr<recob::PFParticle>, ClusterVector> PFParticlesToClusters;
  typedef std::map<art::Ptr<recob::PFParticle>, SeedVector> PFParticlesToSeeds;
  typedef std::map<art::Ptr<recob::PFParticle>, VertexVector> PFParticlesToVertices;
  typedef std::map<art::Ptr<recob::PFParticle>, SpacePointVector> PFParticlesToSpacePoints;
  typedef std::map<art::Ptr<recob::PFParticle>, HitVector> PFParticlesToHits;
  typedef std::map<art::Ptr<recob::PFParticle>, MetadataVector> PFParticlesToMetadata;
  typedef std::map<art::Ptr<recob::Track>, HitVector> TracksToHits;
  typedef std::map<art::Ptr<recob::Shower>, HitVector> ShowersToHits;
  typedef std::map<art::Ptr<recob::Cluster>, HitVector> ClustersToHits;
  typedef std::map<art::Ptr<recob::Seed>, art::Ptr<recob::Hit>> SeedsToHits;
  typedef std::map<art::Ptr<recob::SpacePoint>, art::Ptr<recob::Hit>> SpacePointsToHits;
  typedef std::map<art::Ptr<simb::MCTruth>, MCParticleVector> MCTruthToMCParticles;
  typedef std::map<art::Ptr<simb::MCTruth>, HitVector> MCTruthToHits;
  typedef std::map<art::Ptr<simb::MCTruth>, art::Ptr<recob::PFParticle>> MCTruthToPFParticles;
  typedef std::map<art::Ptr<simb::MCParticle>, art::Ptr<simb::MCTruth>> MCParticlesToMCTruth;
  typedef std::map<art::Ptr<simb::MCParticle>, HitVector> MCParticlesToHits;
  typedef std::map<art::Ptr<simb::MCParticle>, art::Ptr<recob::PFParticle>>
    MCParticlesToPFParticles;
  typedef std::map<art::Ptr<recob::Hit>, art::Ptr<recob::SpacePoint>> HitsToSpacePoints;
  typedef std::map<art::Ptr<recob::Hit>, art::Ptr<recob::PFParticle>> HitsToPFParticles;
  typedef std::map<art::Ptr<recob::Hit>, art::Ptr<simb::MCParticle>> HitsToMCParticles;
  typedef std::map<art::Ptr<recob::Hit>, art::Ptr<simb::MCTruth>> HitsToMCTruth;
  typedef std::map<art::Ptr<recob::Hit>, TrackIDEVector> HitsToTrackIDEs;
  typedef std::map<art::Ptr<recob::Track>, CosmicTagVector> TracksToCosmicTags;
  typedef std::map<art::Ptr<recob::PFParticle>, T0Vector> PFParticlesToT0s;
 
  typedef std::map<int, art::Ptr<recob::PFParticle>> PFParticleMap;
  typedef std::map<int, art::Ptr<recob::Cluster>> ClusterMap;
  typedef std::map<int, art::Ptr<recob::SpacePoint>> SpacePointMap;
  typedef std::map<int, art::Ptr<recob::Hit>> HitMap;
  typedef std::map<int, art::Ptr<simb::MCParticle>> MCParticleMap;
  typedef std::map<int, art::Ptr<sim::SimChannel>> SimChannelMap;
 
  typedef std::map<const pandora::ParticleFlowObject*, size_t> ThreeDParticleMap;
  typedef std::map<const pandora::Vertex*, unsigned int> ThreeDVertexMap;
  typedef std::map<int, HitVector> HitArray;
 
  class LArPandoraHelper {
  public:
    enum DaughterMode {
      kIgnoreDaughters = 0, // Only use parent particles
      kUseDaughters = 1,    // Use both parent and daughter partcles
      kAddDaughters = 2     // Absorb daughter particles into parent particles
    };
 
    static void CollectWires(const art::Event& evt,
                             const std::string& label,
                             WireVector& wireVector);
 
    static void CollectHits(const art::Event& evt, const std::string& label, HitVector& hitVector);
 
    static void CollectPFParticles(const art::Event& evt,
                                   const std::string& label,
                                   PFParticleVector& particleVector);
 
    static void CollectSpacePoints(const art::Event& evt,
                                   const std::string& label,
                                   SpacePointVector& spacePointVector,
                                   SpacePointsToHits& spacePointsToHits);
 
    static void CollectSpacePoints(const art::Event& evt,
                                   const std::string& label,
                                   SpacePointVector& spacePointVector,
                                   SpacePointsToHits& spacePointsToHits,
                                   HitsToSpacePoints& hitsToSpacePoints);
 
    static void CollectClusters(const art::Event& evt,
                                const std::string& label,
                                ClusterVector& clusterVector,
                                ClustersToHits& clustersToHits);
 
    static void CollectPFParticles(const art::Event& evt,
                                   const std::string& label,
                                   PFParticleVector& particleVector,
                                   PFParticlesToSpacePoints& particlesToSpacePoints);
 
    static void CollectPFParticles(const art::Event& evt,
                                   const std::string& label,
                                   PFParticleVector& particleVector,
                                   PFParticlesToClusters& particlesToClusters);
 
    static void CollectPFParticleMetadata(const art::Event& evt,
                                          const std::string& label,
                                          PFParticleVector& particleVector,
                                          PFParticlesToMetadata& particlesToMetadata);
 
    static void CollectShowers(const art::Event& evt,
                               const std::string& label,
                               ShowerVector& showerVector,
                               PFParticlesToShowers& particlesToShowers);
 
    static void CollectShowers(const art::Event& evt,
                               const std::string& label,
                               ShowerVector& showerVector,
                               ShowersToHits& showersToHits);
 
    static void CollectTracks(const art::Event& evt,
                              const std::string& label,
                              TrackVector& trackVector,
                              PFParticlesToTracks& particlesToTracks);
 
    static void CollectTracks(const art::Event& evt,
                              const std::string& label,
                              TrackVector& trackVector,
                              TracksToHits& tracksToHits);
 
    static void CollectSeeds(const art::Event& evt,
                             const std::string& label,
                             SeedVector& seedVector,
                             PFParticlesToSeeds& particlesToSeeds);
 
    static void CollectSeeds(const art::Event& evt,
                             const std::string& label,
                             SeedVector& seedVector,
                             SeedsToHits& seedsToHits);
 
    static void CollectVertices(const art::Event& evt,
                                const std::string& label,
                                VertexVector& vertexVector,
                                PFParticlesToVertices& particlesToVertices);
 
    static void BuildPFParticleHitMaps(const PFParticleVector& particleVector,
                                       const PFParticlesToSpacePoints& particlesToSpacePoints,
                                       const SpacePointsToHits& spacePointsToHits,
                                       PFParticlesToHits& particlesToHits,
                                       HitsToPFParticles& hitsToParticles,
                                       const DaughterMode daughterMode = kUseDaughters);
 
    static void BuildPFParticleHitMaps(const PFParticleVector& particleVector,
                                       const PFParticlesToClusters& particlesToClusters,
                                       const ClustersToHits& clustersToHits,
                                       PFParticlesToHits& particlesToHits,
                                       HitsToPFParticles& hitsToParticles,
                                       const DaughterMode daughterMode = kUseDaughters);
 
    static void BuildPFParticleHitMaps(const art::Event& evt,
                                       const std::string& label_pfpart,
                                       const std::string& label_mid,
                                       PFParticlesToHits& particlesToHits,
                                       HitsToPFParticles& hitsToParticles,
                                       const DaughterMode daughterMode = kUseDaughters,
                                       const bool useClusters = true);
 
    static void BuildPFParticleHitMaps(const art::Event& evt,
                                       const std::string& label,
                                       PFParticlesToHits& particlesToHits,
                                       HitsToPFParticles& hitsToParticles,
                                       const DaughterMode daughterMode = kUseDaughters,
                                       const bool useClusters = true);
 
    static void CollectCosmicTags(const art::Event& evt,
                                  const std::string& label,
                                  CosmicTagVector& cosmicTagVector,
                                  TracksToCosmicTags& tracksToCosmicTags);
 
    static void CollectT0s(const art::Event& evt,
                           const std::string& label,
                           T0Vector& t0Vector,
                           PFParticlesToT0s& particlesToT0s);
 
    static void CollectSimChannels(const art::Event& evt,
                                   const std::string& label,
                                   SimChannelVector& simChannelVector,
                                   bool& areSimChannelsValid);
 
    static void CollectMCParticles(const art::Event& evt,
                                   const std::string& label,
                                   MCParticleVector& particleVector);
 
    static void CollectGeneratorMCParticles(const art::Event& evt,
                                            const std::string& label,
                                            RawMCParticleVector& particleVector);
 
    static void CollectMCParticles(const art::Event& evt,
                                   const std::string& label,
                                   MCTruthToMCParticles& truthToParticles,
                                   MCParticlesToMCTruth& particlesToTruth);
 
    static void BuildMCParticleHitMaps(const art::Event& evt,
                                       const HitVector& hitVector,
                                       const SimChannelVector& simChannelVector,
                                       HitsToTrackIDEs& hitsToTrackIDEs);
 
    static void BuildMCParticleHitMaps(const HitsToTrackIDEs& hitsToTrackIDEs,
                                       const MCTruthToMCParticles& truthToParticles,
                                       MCParticlesToHits& particlesToHits,
                                       HitsToMCParticles& hitsToParticles,
                                       const DaughterMode daughterMode = kUseDaughters);
 
    static void BuildMCParticleHitMaps(const art::Event& evt,
                                       const std::string& label,
                                       const HitVector& hitVector,
                                       MCParticlesToHits& particlesToHits,
                                       HitsToMCParticles& hitsToParticles,
                                       const DaughterMode daughterMode = kUseDaughters);
 
    static void BuildMCParticleHitMaps(const art::Event& evt,
                                       const std::string& hitLabel,
                                       const std::string& backtrackLabel,
                                       HitsToTrackIDEs& hitsToTrackIDEs);
 
    static void BuildMCParticleHitMaps(const art::Event& evt,
                                       const std::string& truthLabel,
                                       const std::string& hitLabel,
                                       const std::string& backtrackLabel,
                                       MCParticlesToHits& particlesToHits,
                                       HitsToMCParticles& hitsToParticles,
                                       const DaughterMode daughterMode = kUseDaughters);
 
    template <typename T>
    static void GetAssociatedHits(const art::Event& evt,
                                  const std::string& label,
                                  const std::vector<art::Ptr<T>>& inputVector,
                                  HitVector& associatedHits,
                                  const pandora::IntVector* const indexVector = nullptr);
 
    static void SelectNeutrinoPFParticles(const PFParticleVector& inputParticles,
                                          PFParticleVector& outputParticles);
 
    static void SelectFinalStatePFParticles(const PFParticleVector& inputParticles,
                                            PFParticleVector& outputParticles);
 
    static void BuildMCParticleMap(const MCParticleVector& particleVector,
                                   MCParticleMap& particleMap);
 
    static void BuildPFParticleMap(const PFParticleVector& particleVector,
                                   PFParticleMap& particleMap);
 
    static art::Ptr<recob::PFParticle> GetParentPFParticle(
      const PFParticleMap& particleMap,
      const art::Ptr<recob::PFParticle> daughterParticle);
 
    static art::Ptr<recob::PFParticle> GetFinalStatePFParticle(
      const PFParticleMap& particleMap,
      const art::Ptr<recob::PFParticle> daughterParticle);
 
    static art::Ptr<simb::MCParticle> GetParentMCParticle(
      const MCParticleMap& particleMap,
      const art::Ptr<simb::MCParticle> daughterParticle);
 
    static art::Ptr<simb::MCParticle> GetFinalStateMCParticle(
      const MCParticleMap& particleMap,
      const art::Ptr<simb::MCParticle> daughterParticle);
 
    static art::Ptr<recob::Track> GetPrimaryTrack(const PFParticlesToTracks& particlesToTracks,
                                                  const art::Ptr<recob::PFParticle> particle);
 
    static int GetGeneration(const PFParticleMap& particleMap,
                             const art::Ptr<recob::PFParticle> daughterParticle);
 
    static int GetParentNeutrino(const PFParticleMap& particleMap,
                                 const art::Ptr<recob::PFParticle> daughterParticle);
 
    static bool IsFinalState(const PFParticleMap& particleMap,
                             const art::Ptr<recob::PFParticle> daughterParticle);
 
    static bool IsNeutrino(const art::Ptr<recob::PFParticle> particle);
 
    static bool IsTrack(const art::Ptr<recob::PFParticle> particle);
 
    static bool IsShower(const art::Ptr<recob::PFParticle> particle);
 
    static bool IsVisible(const art::Ptr<simb::MCParticle> particle);
 
    static larpandoraobj::PFParticleMetadata GetPFParticleMetadata(
      const pandora::ParticleFlowObject* const pPfo);
  };
 
} // namespace lar_pandora
 
#endif //  LAR_PANDORA_HELPER_H