LArPandoraHelper.h

Go to the documentation of this file.

#ifndef LAR_PANDORA_HELPER_H
#define LAR_PANDORA_HELPER_H

#include "art/Framework/Principal/Event.h"

#include "lardataobj/Simulation/SimChannel.h"

#include <map>
#include <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;}
namespace sim {class SimChannel; struct TrackIDE;}
namespace simb {class MCParticle; 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);

    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 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