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