LArPandoraEventDump_module.cc

Go to the documentation of this file.

#include "art/Framework/Core/EDAnalyzer.h"
#include "art/Framework/Core/ModuleMacros.h"
#include "art/Framework/Principal/Event.h"

#include "fhiclcpp/ParameterSet.h"

#include "lardata/Utilities/AssociationUtil.h"

#include "lardataobj/RecoBase/PFParticle.h"
#include "lardataobj/RecoBase/PFParticleMetadata.h"
#include "lardataobj/RecoBase/SpacePoint.h"
#include "lardataobj/RecoBase/Cluster.h"
#include "lardataobj/RecoBase/Vertex.h"
#include "lardataobj/RecoBase/Track.h"
#include "lardataobj/RecoBase/Shower.h"
#include "lardataobj/RecoBase/Seed.h"
#include "lardataobj/RecoBase/PCAxis.h"
#include "lardataobj/RecoBase/Hit.h"
#include "lardataobj/RecoBase/Slice.h"

#include "larpandora/LArPandoraInterface/LArPandoraHelper.h"

namespace lar_pandora
{

class LArPandoraEventDump : public art::EDAnalyzer
{
public:
    explicit LArPandoraEventDump(fhicl::ParameterSet const & pset);
    
    LArPandoraEventDump(LArPandoraEventDump const &) = delete;
    LArPandoraEventDump(LArPandoraEventDump &&) = delete;
    LArPandoraEventDump & operator = (LArPandoraEventDump const &) = delete;
    LArPandoraEventDump & operator = (LArPandoraEventDump &&) = delete;

    void analyze(art::Event const & evt) override;

private:
    template <class T>
        using Collection = art::Handle< std::vector<T> >;

    template <class T>
        using Association = art::FindManyP<T>;

    class PandoraData
    {
    public:
        PandoraData(const art::Event &evt, const std::string &pandoraLabel, const std::string &trackLabel = "", const std::string &showerLabel = "");

        ~PandoraData();

        // Collections 
        Collection<recob::PFParticle>           m_pfParticleCollection;                
        Collection<larpandoraobj::PFParticleMetadata>   m_pfParticleMetadataCollection;        
        Collection<recob::Cluster>              m_clusterCollection;                   
        Collection<recob::SpacePoint>           m_spacePointCollection;                
        Collection<recob::Vertex>               m_vertexCollection;                    
        Collection<recob::Track>                m_trackCollection;                     
        Collection<recob::Shower>               m_showerCollection;                    
        Collection<recob::PCAxis>               m_pcAxisCollection;                    
        Collection<recob::Slice>                m_sliceCollection;                     
        
        // Associations
        Association<larpandoraobj::PFParticleMetadata> *m_pPFParticleToMetadataAssociation;    
        Association<recob::Cluster>            *m_pPFParticleToClusterAssociation;     
        Association<recob::SpacePoint>         *m_pPFParticleToSpacePointAssociation;  
        Association<recob::Vertex>             *m_pPFParticleToVertexAssociation;      
        Association<recob::Track>              *m_pPFParticleToTrackAssociation;       
        Association<recob::Shower>             *m_pPFParticleToShowerAssociation;      
        Association<recob::Slice>              *m_pPFParticleToSliceAssociation;       
        
        Association<recob::Hit>                *m_pClusterToHitAssociation;            
        Association<recob::Hit>                *m_pSpacePointToHitAssociation;         
        Association<recob::Hit>                *m_pTrackToHitAssociation;              
        Association<recob::Hit>                *m_pShowerToHitAssociation;             
        Association<recob::Hit>                *m_pSliceToHitAssociation;              
        
        Association<recob::PCAxis>             *m_pShowerToPCAxisAssociation;          

    private:
        template <class T>
        void LoadCollection(const art::Event &evt, const std::string &label, Collection<T> &collection);
        
        template <class T, class U>
        void LoadAssociation(const art::Event &evt, const std::string &label, const Collection<T> &collection, Association<U> *&pAssociation);
    };

    // -------------------------------------------------------------------------------------------------------------------------------------

    void PrintEventMetadata(const art::Event &evt) const;

    void PrintEventSummary(const PandoraData &data) const;

    void PrintPFParticleHierarchy(const PandoraData &data) const;

    void BuildPFParticleMap(const PandoraData &data, PFParticleMap &pfParticleMap) const;

    void PrintParticle(const art::Ptr< recob::PFParticle > &particle, const PFParticleMap &pfParticleMap, const PandoraData &data, const unsigned int depth) const;
    
    void PrintHit(const art::Ptr<recob::Hit> &hit, const unsigned int depth) const;

    void PrintSlice(const art::Ptr<recob::Slice> &slice, const PandoraData &data, const unsigned int depth) const;

    void PrintCluster(const art::Ptr<recob::Cluster> &cluster, const PandoraData &data, const unsigned int depth) const;

    void PrintVertex(const art::Ptr<recob::Vertex> &vertex, const unsigned int depth) const;

    void PrintSpacePoint(const art::Ptr<recob::SpacePoint> &spacePoint, const PandoraData &data, const unsigned int depth) const;

    void PrintTrack(const art::Ptr<recob::Track> &track, const PandoraData &data, const unsigned int depth) const;
    
    void PrintShower(const art::Ptr<recob::Shower> &shower, const PandoraData &data, const unsigned int depth) const;

    void PrintRule(const unsigned int depth) const;

    void PrintTitle(const std::string &name, const unsigned int depth) const;

    template<class T>
    void PrintProperty(const std::string &name, const T &value, const unsigned int depth) const;

    std::string m_verbosityLevel;  
    std::string m_pandoraLabel;    
    std::string m_trackLabel;      
    std::string m_showerLabel;     
};

DEFINE_ART_MODULE(LArPandoraEventDump)

} // namespace lar_pandora

//------------------------------------------------------------------------------------------------------------------------------------------
// implementation follows

namespace lar_pandora
{

LArPandoraEventDump::LArPandoraEventDump(fhicl::ParameterSet const &pset) :
    EDAnalyzer(pset),
    m_pandoraLabel(pset.get<std::string>("PandoraLabel")),
    m_trackLabel(pset.get<std::string>("TrackLabel" , "")),
    m_showerLabel(pset.get<std::string>("ShowerLabel", ""))
{
    m_verbosityLevel = pset.get<std::string>("VerbosityLevel");
    std::transform(m_verbosityLevel.begin(), m_verbosityLevel.end(), m_verbosityLevel.begin(), ::tolower);

    if (m_verbosityLevel != "brief" &&
        m_verbosityLevel != "summary" &&
        m_verbosityLevel != "detailed" &&
        m_verbosityLevel != "extreme")
    {
        throw cet::exception("LArPandoraEventDump") << "Unknown verbosity level: " << m_verbosityLevel << std::endl;
    }
}

//------------------------------------------------------------------------------------------------------------------------------------------

void LArPandoraEventDump::analyze(art::Event const & evt)
{
    // Load the Pandora owned collections from the event
    PandoraData data(evt, m_pandoraLabel, m_trackLabel, m_showerLabel);
    
    this->PrintEventMetadata(evt);
    this->PrintEventSummary(data);

    if (m_verbosityLevel != "brief")
        this->PrintPFParticleHierarchy(data);
}

//------------------------------------------------------------------------------------------------------------------------------------------

void LArPandoraEventDump::PrintEventMetadata(const art::Event &evt) const
{
    std::cout << std::string(80, '=')        << std::endl;
    std::cout << "run    : " << evt.run()    << std::endl;
    std::cout << "subRun : " << evt.subRun() << std::endl;
    std::cout << "event  : " << evt.event()  << std::endl;
    std::cout << std::endl;
}

//------------------------------------------------------------------------------------------------------------------------------------------

void LArPandoraEventDump::PrintEventSummary(const PandoraData &data) const
{
    std::cout << std::string(80, '-') << std::endl;
    std::cout << "Collection sizes" << std::endl;
    std::cout << std::string(80, '-') << std::endl;

    std::cout << "PFParticle         : " << data.m_pfParticleCollection->size() << std::endl;
    std::cout << "PFParticleMetadata : " << data.m_pfParticleMetadataCollection->size() << std::endl;   
    std::cout << "Cluster            : " << data.m_clusterCollection->size() << std::endl;
    std::cout << "SpacePoint         : " << data.m_spacePointCollection->size() << std::endl;
    std::cout << "Vertex             : " << data.m_vertexCollection->size() << std::endl;
    std::cout << "Track              : " << data.m_trackCollection->size() << std::endl;
    std::cout << "Shower             : " << data.m_showerCollection->size() << std::endl;
    std::cout << "PCAxis             : " << data.m_pcAxisCollection->size() << std::endl;
    std::cout << "Slice              : " << data.m_sliceCollection->size() << std::endl;
    std::cout << std::endl;
    
    std::cout << std::string(80, '-') << std::endl;
    std::cout << "Association sizes" << std::endl;
    std::cout << std::string(80, '-') << std::endl;
 
    if (data.m_pPFParticleToMetadataAssociation)
        std::cout << "PFParticle -> Metadata   : " << data.m_pPFParticleToMetadataAssociation->size() << std::endl;

    if (data.m_pPFParticleToClusterAssociation)
        std::cout << "PFParticle -> Cluster    : " << data.m_pPFParticleToClusterAssociation->size() << std::endl;

    if (data.m_pPFParticleToSpacePointAssociation)
        std::cout << "PFParticle -> SpacePoint : " << data.m_pPFParticleToSpacePointAssociation->size() << std::endl;

    if (data.m_pPFParticleToVertexAssociation)
        std::cout << "PFParticle -> Vertex     : " << data.m_pPFParticleToVertexAssociation->size() << std::endl;

    if (data.m_pPFParticleToTrackAssociation)
        std::cout << "PFParticle -> Track      : " << data.m_pPFParticleToTrackAssociation->size() << std::endl;

    if (data.m_pPFParticleToShowerAssociation)
        std::cout << "PFParticle -> Shower     : " << data.m_pPFParticleToShowerAssociation->size() << std::endl;
    
    if (data.m_pPFParticleToSliceAssociation)
        std::cout << "PFParticle -> Slice      : " << data.m_pPFParticleToSliceAssociation->size() << std::endl;

    if (data.m_pClusterToHitAssociation)
        std::cout << "Cluster    -> Hit        : " << data.m_pClusterToHitAssociation->size() << std::endl;

    if (data.m_pSpacePointToHitAssociation)
        std::cout << "SpacePoint -> Hit        : " << data.m_pSpacePointToHitAssociation->size() << std::endl;

    if (data.m_pTrackToHitAssociation)
        std::cout << "Track      -> Hit        : " << data.m_pTrackToHitAssociation->size() << std::endl;

    if (data.m_pShowerToHitAssociation)
        std::cout << "Shower     -> Hit        : " << data.m_pShowerToHitAssociation->size() << std::endl;

    if (data.m_pShowerToPCAxisAssociation)
        std::cout << "Shower     -> PCAxis     : " << data.m_pShowerToPCAxisAssociation->size() << std::endl;
    
    if (data.m_pSliceToHitAssociation)
        std::cout << "Slice      -> Hit        : " << data.m_pSliceToHitAssociation->size() << std::endl;
    
    std::cout << std::endl;
}

//------------------------------------------------------------------------------------------------------------------------------------------

void LArPandoraEventDump::PrintPFParticleHierarchy(const PandoraData &data) const
{
    // Get the mapping from PFParticle ID to PFParticle
    PFParticleMap pfParticleMap;
    this->BuildPFParticleMap(data, pfParticleMap);

    // Print all primary PFParticles
    for (unsigned int i = 0; i < data.m_pfParticleCollection->size(); ++i)
    {
        const art::Ptr<recob::PFParticle> particle(data.m_pfParticleCollection, i);

        if (!particle->IsPrimary())
            continue;

        this->PrintParticle(particle, pfParticleMap, data, 0);
    }
}

//------------------------------------------------------------------------------------------------------------------------------------------

void LArPandoraEventDump::BuildPFParticleMap(const PandoraData &data, PFParticleMap &pfParticleMap) const
{
    for (unsigned int i = 0; i < data.m_pfParticleCollection->size(); ++i)
    {
        const art::Ptr<recob::PFParticle> particle(data.m_pfParticleCollection, i);
        pfParticleMap[particle->Self()] = particle;
    }
}

//------------------------------------------------------------------------------------------------------------------------------------------

void LArPandoraEventDump::PrintParticle(const art::Ptr< recob::PFParticle > &particle, const PFParticleMap &pfParticleMap,
    const PandoraData &data, const unsigned int depth) const
{
    this->PrintRule(depth);
    this->PrintTitle("PFParticle", depth);
    this->PrintRule(depth);

    // Print the PFParticle details
    this->PrintProperty("Key", particle.key(), depth);
    this->PrintProperty("Id", particle->Self(), depth);
    this->PrintProperty("PDG", particle->PdgCode(), depth);
    this->PrintProperty("IsPrimary", particle->IsPrimary(), depth);

    if (!particle->IsPrimary())
        this->PrintProperty("Parent", particle->Parent(), depth);

    // Print the metadata
    if (data.m_pPFParticleToMetadataAssociation)
    {
        const auto &metadata(data.m_pPFParticleToMetadataAssociation->at(particle.key()));
        this->PrintProperty("# Metadata", metadata.size(), depth);
        
        for (const auto &metadatum : metadata)
        {
            const auto &propertiesMap(metadatum->GetPropertiesMap());
            this->PrintProperty("# Properties", propertiesMap.size(), depth + 2);

            for (const auto &propertiesMapEntry : propertiesMap)
                this->PrintProperty(propertiesMapEntry.first, propertiesMapEntry.second, depth + 4);
        }
    }

    // Print the slices
    if (data.m_pPFParticleToSliceAssociation)
    {
        const auto &slices(data.m_pPFParticleToSliceAssociation->at(particle.key()));
        this->PrintProperty("# Slices", slices.size(), depth);
        
        if (m_verbosityLevel != "summary")
        {
            for (const auto &slice : slices)
                this->PrintSlice(slice, data, depth + 2);
        }
    
    }

    // Print the clusters
    if (data.m_pPFParticleToClusterAssociation)
    {
        const auto &clusters(data.m_pPFParticleToClusterAssociation->at(particle.key()));
        this->PrintProperty("# Clusters", clusters.size(), depth);
        
        if (m_verbosityLevel != "summary")
        {
            for (const auto &cluster : clusters)
                this->PrintCluster(cluster, data, depth + 2);
        }
    }

    // Print the space points
    if (data.m_pPFParticleToSpacePointAssociation)
    {
        const auto &spacePoints(data.m_pPFParticleToSpacePointAssociation->at(particle.key()));
        this->PrintProperty("# SpacePoints", spacePoints.size(), depth);

        if (m_verbosityLevel != "summary")
        {
            for (const auto &spacePoint : spacePoints)
                this->PrintSpacePoint(spacePoint, data, depth + 2);
        }
    }

    // Print the vertices
    if (data.m_pPFParticleToVertexAssociation)
    {
        const auto &vertices(data.m_pPFParticleToVertexAssociation->at(particle.key()));
        this->PrintProperty("# Vertices", vertices.size(), depth);

        if (m_verbosityLevel != "summary")
        {
            for (const auto &vertex : vertices)
                this->PrintVertex(vertex, depth + 2);
        }
    }

    // Print the tracks
    if (data.m_pPFParticleToTrackAssociation)
    {
        const auto &tracks(data.m_pPFParticleToTrackAssociation->at(particle.key()));
        this->PrintProperty("# Tracks", tracks.size(), depth);
        
        if (m_verbosityLevel != "summary")
        {
            for (const auto &track : tracks)
                this->PrintTrack(track, data, depth + 2);
        }
    }
    
    // Print the showers
    if (data.m_pPFParticleToShowerAssociation)
    {
        const auto &showers(data.m_pPFParticleToShowerAssociation->at(particle.key()));
        this->PrintProperty("# Showers", showers.size(), depth);
        
        if (m_verbosityLevel != "summary")
        {
            for (const auto &shower : showers)
                this->PrintShower(shower, data, depth + 2);
        }
    }

    // Print the daughters
    this->PrintProperty("# Daughters", particle->NumDaughters(), depth);
    this->PrintRule(depth);
   
    for (auto &daughterId : particle->Daughters())
    {
        const auto daughterIter(pfParticleMap.find(daughterId));

        if (daughterIter == pfParticleMap.end())
            throw cet::exception("LArPandoraEventDump") << "Couldn't find daughter of PFParticle in the PFParticle map";

        const auto &daughter(daughterIter->second);
        this->PrintParticle(daughter, pfParticleMap, data, depth + 4);
    }
}

//------------------------------------------------------------------------------------------------------------------------------------------

void LArPandoraEventDump::PrintHit(const art::Ptr<recob::Hit> &hit, const unsigned int depth) const
{
    this->PrintTitle("Hit", depth);
    this->PrintProperty("Key", hit.key(), depth + 2);
    this->PrintProperty("Channel", hit->Channel(), depth + 2);
    this->PrintProperty("View", hit->View(), depth + 2);
    this->PrintProperty("Peak time", hit->PeakTime(), depth + 2);
    this->PrintProperty("RMS", hit->RMS(), depth + 2);
}

//------------------------------------------------------------------------------------------------------------------------------------------

void LArPandoraEventDump::PrintSlice(const art::Ptr<recob::Slice> &slice, const PandoraData &data, const unsigned int depth) const
{
    this->PrintTitle("Slice", depth);
    this->PrintProperty("Key", slice.key(), depth + 2);
    this->PrintProperty("ID", slice->ID(), depth + 2);
    
    if (!data.m_pSliceToHitAssociation)
        return;

    const auto &hits(data.m_pSliceToHitAssociation->at(slice.key()));
    this->PrintProperty("# Hits", hits.size(), depth + 2);

    if (m_verbosityLevel != "extreme")
        return;

    // Print each associated hit
    for (const auto &hit : hits)
        this->PrintHit(hit, depth + 4);
}

//------------------------------------------------------------------------------------------------------------------------------------------

void LArPandoraEventDump::PrintCluster(const art::Ptr<recob::Cluster> &cluster, const PandoraData &data, const unsigned int depth) const
{
    this->PrintTitle("Cluster", depth);
    this->PrintProperty("Key", cluster.key(), depth + 2);
    this->PrintProperty("ID", cluster->ID(), depth + 2);
    this->PrintProperty("View", cluster->View(), depth + 2);

    if (!data.m_pClusterToHitAssociation)
        return;

    const auto &hits(data.m_pClusterToHitAssociation->at(cluster.key()));
    this->PrintProperty("# Hits", hits.size(), depth + 2);

    if (m_verbosityLevel == "detailed")
        return;

    // Print each associated hit
    for (const auto &hit : hits)
        this->PrintHit(hit, depth + 4);
}

//------------------------------------------------------------------------------------------------------------------------------------------

void LArPandoraEventDump::PrintSpacePoint(const art::Ptr<recob::SpacePoint> &spacePoint, const PandoraData &data, const unsigned int depth) const
{
    this->PrintTitle("SpacePoint", depth);
    this->PrintProperty("Key", spacePoint.key(), depth + 2);
    this->PrintProperty("ID", spacePoint->ID(), depth + 2);
    const auto &position(spacePoint->XYZ());
    this->PrintProperty("X", position[0], depth + 2);
    this->PrintProperty("Y", position[1], depth + 2);
    this->PrintProperty("Z", position[2], depth + 2);

    if (!data.m_pSpacePointToHitAssociation)
        return;

    const auto &hits(data.m_pSpacePointToHitAssociation->at(spacePoint.key()));
    this->PrintProperty("# Hits", hits.size(), depth + 2);

    if (m_verbosityLevel == "detailed")
        return;

    // Print each associated hit
    for (const auto &hit : hits)
        this->PrintHit(hit, depth + 4);
}

//------------------------------------------------------------------------------------------------------------------------------------------

void LArPandoraEventDump::PrintVertex(const art::Ptr<recob::Vertex> &vertex, const unsigned int depth) const
{
    this->PrintTitle("Vertex", depth);
    this->PrintProperty("Key", vertex.key(), depth + 2);
    this->PrintProperty("ID", vertex->ID(), depth + 2);
    const auto &position(vertex->position());
    this->PrintProperty("X", position.X(), depth + 2);
    this->PrintProperty("Y", position.Y(), depth + 2);
    this->PrintProperty("Z", position.Z(), depth + 2);
}

//------------------------------------------------------------------------------------------------------------------------------------------

void LArPandoraEventDump::PrintTrack(const art::Ptr<recob::Track> &track, const PandoraData &data, const unsigned int depth) const
{
    this->PrintTitle("Track", depth);
    this->PrintProperty("Key", track.key(), depth + 2);
    this->PrintProperty("# Trajectory points", track->NumberTrajectoryPoints(), depth + 2);
    this->PrintProperty("Length", track->Length(), depth + 2);

    if (!data.m_pTrackToHitAssociation)
        return;

    const auto &hits(data.m_pTrackToHitAssociation->at(track.key()));
    this->PrintProperty("# Hits", hits.size(), depth + 2);

    if (m_verbosityLevel == "detailed")
        return;

    // Print each associated hit
    for (const auto &hit : hits)
        this->PrintHit(hit, depth + 4);
}

//------------------------------------------------------------------------------------------------------------------------------------------

void LArPandoraEventDump::PrintShower(const art::Ptr<recob::Shower> &shower, const PandoraData &data, const unsigned int depth) const
{
    this->PrintTitle("Shower", depth);
    this->PrintProperty("Key", shower.key(), depth + 2);
    this->PrintProperty("ID", shower->ID(), depth + 2);
    this->PrintProperty("StartX", shower->ShowerStart().X(), depth + 2);
    this->PrintProperty("StartY", shower->ShowerStart().Y(), depth + 2);
    this->PrintProperty("StartZ", shower->ShowerStart().Z(), depth + 2);
    this->PrintProperty("Length", shower->Length(), depth + 2);
    this->PrintProperty("OpenAngle", shower->OpenAngle(), depth + 2);

    if (data.m_pShowerToPCAxisAssociation)
    {
        const auto &pcAxes(data.m_pShowerToPCAxisAssociation->at(shower.key()));
        this->PrintProperty("# PCAxes", pcAxes.size(), depth + 2);

        for (const auto &pcAxis : pcAxes)
        {
            this->PrintTitle("PCAxis", depth + 4);
            this->PrintProperty("Key", pcAxis.key(), depth + 6);
            this->PrintProperty("ID", pcAxis->getID(), depth + 6);
            this->PrintProperty("# Hits used", pcAxis->getNumHitsUsed(), depth + 6);
        }
    }

    if (!data.m_pShowerToHitAssociation)
        return;

    const auto &hits(data.m_pShowerToHitAssociation->at(shower.key()));
    this->PrintProperty("# Hits", hits.size(), depth + 2);

    if (m_verbosityLevel == "detailed")
        return;

    // Print each associated hit
    for (const auto &hit : hits)
        this->PrintHit(hit, depth + 4);
}

//------------------------------------------------------------------------------------------------------------------------------------------

void LArPandoraEventDump::PrintRule(const unsigned int depth) const
{
    const unsigned int nDashes(std::max(0, 120 - static_cast<int>(depth)));

    std::cout << std::string(depth, ' ') << std::string(nDashes, '-') << std::endl;
}

//------------------------------------------------------------------------------------------------------------------------------------------

void LArPandoraEventDump::PrintTitle(const std::string &name, const unsigned int depth) const
{
    std::cout << std::string(depth, ' ') << name << std::endl;
}


//------------------------------------------------------------------------------------------------------------------------------------------

template<class T>
void LArPandoraEventDump::PrintProperty(const std::string &name, const T &value, const unsigned int depth) const
{
    // The separation between the property name and property value
    const unsigned int separation(std::max(0, 32 - static_cast<int>(depth)));

    std::cout << std::string(depth, ' ') << std::setw(separation) << std::left << ("- " + name) << value << std::endl;
}

//------------------------------------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------------------------------------

LArPandoraEventDump::PandoraData::PandoraData(const art::Event &evt, const std::string &pandoraLabel, const std::string &trackLabel,
    const std::string &showerLabel) : 
    m_pPFParticleToMetadataAssociation(nullptr),
    m_pPFParticleToClusterAssociation(nullptr),
    m_pPFParticleToSpacePointAssociation(nullptr),
    m_pPFParticleToVertexAssociation(nullptr),
    m_pPFParticleToTrackAssociation(nullptr),
    m_pPFParticleToShowerAssociation(nullptr),
    m_pPFParticleToSliceAssociation(nullptr),
    m_pClusterToHitAssociation(nullptr),
    m_pSpacePointToHitAssociation(nullptr),
    m_pTrackToHitAssociation(nullptr),
    m_pShowerToHitAssociation(nullptr),
    m_pSliceToHitAssociation(nullptr),
    m_pShowerToPCAxisAssociation(nullptr)
{

    // Load the collections
    this->LoadCollection(evt, pandoraLabel, m_pfParticleCollection);
    this->LoadCollection(evt, pandoraLabel, m_pfParticleMetadataCollection);
    this->LoadCollection(evt, pandoraLabel, m_clusterCollection);
    this->LoadCollection(evt, pandoraLabel, m_spacePointCollection);
    this->LoadCollection(evt, pandoraLabel, m_vertexCollection);
    this->LoadCollection(evt, trackLabel  , m_trackCollection);
    this->LoadCollection(evt, showerLabel , m_showerCollection);
    this->LoadCollection(evt, showerLabel , m_pcAxisCollection);
    this->LoadCollection(evt, pandoraLabel, m_sliceCollection);

    // Load the associations
    this->LoadAssociation(evt, pandoraLabel, m_pfParticleCollection, m_pPFParticleToMetadataAssociation);
    this->LoadAssociation(evt, pandoraLabel, m_pfParticleCollection, m_pPFParticleToClusterAssociation);
    this->LoadAssociation(evt, pandoraLabel, m_pfParticleCollection, m_pPFParticleToSpacePointAssociation);
    this->LoadAssociation(evt, pandoraLabel, m_pfParticleCollection, m_pPFParticleToVertexAssociation);
    this->LoadAssociation(evt, pandoraLabel, m_pfParticleCollection, m_pPFParticleToSliceAssociation);
    this->LoadAssociation(evt, pandoraLabel, m_clusterCollection   , m_pClusterToHitAssociation);
    this->LoadAssociation(evt, pandoraLabel, m_spacePointCollection, m_pSpacePointToHitAssociation);
    this->LoadAssociation(evt, pandoraLabel, m_sliceCollection,      m_pSliceToHitAssociation);
    
    this->LoadAssociation(evt, trackLabel  , m_pfParticleCollection, m_pPFParticleToTrackAssociation);
    this->LoadAssociation(evt, trackLabel  , m_trackCollection     , m_pTrackToHitAssociation);
    
    this->LoadAssociation(evt, showerLabel , m_pfParticleCollection, m_pPFParticleToShowerAssociation);
    this->LoadAssociation(evt, showerLabel , m_showerCollection    , m_pShowerToHitAssociation);
    this->LoadAssociation(evt, showerLabel , m_showerCollection    , m_pShowerToPCAxisAssociation);
}

//------------------------------------------------------------------------------------------------------------------------------------------

LArPandoraEventDump::PandoraData::~PandoraData()
{
    // Clean up all heap memory
    delete m_pPFParticleToMetadataAssociation;
    delete m_pPFParticleToClusterAssociation;
    delete m_pPFParticleToSpacePointAssociation;
    delete m_pPFParticleToVertexAssociation;
    delete m_pPFParticleToTrackAssociation;
    delete m_pPFParticleToShowerAssociation;
    delete m_pPFParticleToSliceAssociation;
    delete m_pClusterToHitAssociation;
    delete m_pSpacePointToHitAssociation;
    delete m_pTrackToHitAssociation;
    delete m_pShowerToHitAssociation;
    delete m_pShowerToPCAxisAssociation;
    delete m_pSliceToHitAssociation;
}

//------------------------------------------------------------------------------------------------------------------------------------------
        
template <class T>
void LArPandoraEventDump::PandoraData::LoadCollection(const art::Event &evt, const std::string &label, Collection<T> &collection)
{
    if (label.empty())
        return;
    
    evt.getByLabel(label, collection); 
}

//------------------------------------------------------------------------------------------------------------------------------------------
        
template <class T, class U>
void LArPandoraEventDump::PandoraData::LoadAssociation(const art::Event &evt, const std::string &label, const Collection<T> &collection, Association<U> *&pAssociation)
{
    if (label.empty())
        return;
   
    if (pAssociation)
        throw cet::exception("LArPandoraEventDump") << "Association supplied type has already been loaded!";

    pAssociation = new Association<U>(collection, evt, label);
}

} // namespace lar_pandora