LArPandoraEvent.h

Go to the documentation of this file.

#ifndef LAR_PANDORA_EVENT_H
#define LAR_PANDORA_EVENT_H 1

#include "art/Persistency/Common/PtrMaker.h"

#include "lardata/Utilities/AssociationUtil.h"

#include "lardataobj/RecoBase/PFParticle.h"
#include "lardataobj/RecoBase/PFParticleMetadata.h"
#include "lardataobj/AnalysisBase/CosmicTag.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/PCAxis.h"
#include "lardataobj/RecoBase/Hit.h"

#include "lardataobj/AnalysisBase/T0.h"

#include "larpandora/LArPandoraInterface/LArPandoraHelper.h"

#include <memory>
#include <algorithm>
#include <map>

namespace lar_pandora
{

typedef std::vector< art::Ptr<larpandoraobj::PFParticleMetadata> >                                              MetadataVector;
typedef std::map< art::Ptr<recob::PFParticle>, std::vector< art::Ptr<larpandoraobj::PFParticleMetadata> > >     PFParticlesToMetadata;

typedef std::vector< art::Ptr<recob::PCAxis> >                                              PCAxisVector;
typedef std::map< art::Ptr<recob::PFParticle>, std::vector< art::Ptr<recob::PCAxis> > >     PFParticlesToPCAxes;
typedef std::map< art::Ptr<recob::PFParticle>, std::vector< art::Ptr<recob::PFParticle> > > PFParticlesToPFParticles;
typedef std::map< art::Ptr<recob::Shower>, std::vector< art::Ptr<recob::PCAxis> > >         ShowersToPCAxes;
typedef std::map< art::Ptr<recob::SpacePoint>, std::vector< art::Ptr<recob::Hit> > >        SpacePointsToHitVector;

class LArPandoraEvent
{
public:
    class Labels
    {
    public:
        enum LabelType
        {
            PFParticleLabel,
            SpacePointLabel,
            ClusterLabel,
            VertexLabel,
            TrackLabel,
            ShowerLabel,
            T0Label,
            PFParticleMetadataLabel,
            PCAxisLabel,
            HitLabel,
            PFParticleToSpacePointLabel,
            PFParticleToClusterLabel,
            PFParticleToVertexLabel,
            PFParticleToTrackLabel,
            PFParticleToShowerLabel,
            PFParticleToT0Label,
            PFParticleToMetadataLabel,
            PFParticleToPCAxisLabel,
            SpacePointToHitLabel,
            ClusterToHitLabel,
            TrackToHitLabel,
            ShowerToHitLabel,
            ShowerToPCAxisLabel
        };

        Labels(const std::string &pfParticleProducerLabel, const std::string &hitProducerLabel);

        Labels(const std::string &pfParticleProducerLabel, const std::string &trackProducerLabel, const std::string &showerProducerLabel,
            const std::string &hitProducerLabel);

        const std::string &GetLabel(const LabelType &type) const;

        void SetSpacePointProducerLabel(const std::string &label);
        void SetClusterProducerLabel(const std::string &label);
        void SetVertexProducerLabel(const std::string &label);
        void SetTrackProducerLabel(const std::string &label);
        void SetShowerProducerLabel(const std::string &label);
        void SetT0ProducerLabel(const std::string &label);
        void SetMetadataProducerLabel(const std::string &label);
        void SetPCAxisProducerLabel(const std::string &label);

        void SetPFParticleToSpacePointProducerLabel(const std::string &label);
        void SetPFParticleToClusterProducerLabel(const std::string &label);
        void SetPFParticleToVertexProducerLabel(const std::string &label);
        void SetPFParticleToTrackProducerLabel(const std::string &label);
        void SetPFParticleToShowerProducerLabel(const std::string &label);
        void SetPFParticleToT0ProducerLabel(const std::string &label);
        void SetPFParticleToMetadataProducerLabel(const std::string &label);
        void SetPFParticleToPCAxisProducerLabel(const std::string &label);
        void SetSpacePointToHitProducerLabel(const std::string &label);
        void SetClusterToHitProducerLabel(const std::string &label);
        void SetTrackToHitProducerLabel(const std::string &label);
        void SetShowerToHitProducerLabel(const std::string &label);
        void SetShowerToPCAxisProducerLabel(const std::string &label);

    private:
        std::map<LabelType, std::string>    m_labels;   
    };

    LArPandoraEvent(art::EDProducer *pProducer, art::Event *pEvent, const Labels &inputLabels, const bool shouldProduceT0s = false, const size_t shift = 100000);

    LArPandoraEvent(const LArPandoraEvent &event, const PFParticleVector &selectedPFParticles);

    LArPandoraEvent FilterByPdgCode(const bool shouldProduceNeutrinos) const;

    LArPandoraEvent FilterByCRTag(const bool shouldProduceNeutrinos, const std::string &tagProducerLabel) const;

    void WriteToEvent() const;

    LArPandoraEvent Merge(const LArPandoraEvent &other) const;

private:
    enum Pdg
    {
        nue   = 12,
        numu  = 14,
        nutau = 16
    };

    void GetCollections();

    template <typename T>
    void GetCollection(const Labels::LabelType &inputLabel, art::Handle<std::vector<T> > &outputHandle, std::vector<art::Ptr<T> > &outputCollection) const;

    template <typename T, typename U>
    void GetAssociationMap(const Labels::LabelType &inputLabel, art::Handle<std::vector<T> > &inputHandleT,
        std::map<art::Ptr<T>, std::vector<art::Ptr<U> > > &outputAssociationMap) const;

    void GetPFParticleHierarchy();

    void GetPrimaryPFParticles(PFParticleVector &primaryPFParticles) const;

    void GetFilteredParticlesByPdgCode(const bool shouldProduceNeutrinos, const PFParticleVector &inputPFParticles, PFParticleVector &outputPFParticles) const;

    void GetFilteredParticlesByCRTag(const bool shouldProduceNeutrinos, const std::string &tagProducerLabel, const PFParticleVector &inputPFParticles,
        PFParticleVector &outputPFParticles) const;

    void GetFilteredHierarchyMap(const PFParticleVector &filteredParticles, const PFParticlesToPFParticles &unfilteredPFParticleDaughterMap,
        PFParticlesToPFParticles &outputPFParticleDaughterMap) const;

    void GetIdToPFParticleMap(std::map< size_t, art::Ptr<recob::PFParticle> > &idToPFParticleMap) const;

    void GetDownstreamPFParticles(const PFParticleVector &inputPFParticles, PFParticleVector &downstreamPFParticles) const;

    void GetDownstreamPFParticles(const art::Ptr<recob::PFParticle> &part, PFParticleVector &downstreamPFParticles) const;

    void FillPFParticleToOriginIdMap(const std::map<art::Ptr<recob::PFParticle>, unsigned int> &existingMap);

    template <typename T, typename U>
    void CollectAssociated(const art::Ptr<T> &anObject, const std::map<art::Ptr<T>, std::vector<art::Ptr<U> > > &associationTtoU,
        std::vector<art::Ptr<U> > &associatedU) const;

    template <typename T, typename U>
    void GetFilteredAssociationMap(const std::vector<art::Ptr<T> > &collectionT, const std::vector<art::Ptr<U> > &collectionU,
        const std::map<art::Ptr<T>, std::vector<art::Ptr<U> > > &inputAssociationTtoU, std::map<art::Ptr<T>, std::vector<art::Ptr<U> > > &outputAssociationTtoU) const;

    template <typename T>
    void WriteCollection(const std::vector<art::Ptr<T> > &collection) const;

    template <typename T, typename U>
    void WriteAssociation(const std::map<art::Ptr<T>, std::vector<art::Ptr<U> > > &associationMap, const std::vector<art::Ptr<T> > &collectionT,
        const std::vector<art::Ptr<U> > &collectionU, const bool thisProducesU = true) const;

    void MergePFParticleToOriginIdMap(std::map<art::Ptr<recob::PFParticle>, unsigned int> &mapToMerge, const std::map<art::Ptr<recob::PFParticle>,
        unsigned int> &mapToAdd) const;

    template <typename T>
    void MergeCollection(std::vector<art::Ptr<T> > &collectionToMerge, const std::vector<art::Ptr<T> > &collection) const;

    template <typename T, typename U>
    void MergeAssociation(std::map<art::Ptr<T>, std::vector<art::Ptr<U> > > &associationToMerge, const std::map<art::Ptr<T>, std::vector<art::Ptr<U> > > &association) const;

    art::EDProducer            *m_pProducer;                    
    art::Event                 *m_pEvent;                       
    Labels                      m_labels;                       

    std::map<art::Ptr<recob::PFParticle>, unsigned int>  m_pfParticleToOriginIdMap;  

    bool                        m_shouldProduceT0s;             
    const size_t                m_shift;                        

    // Collections
    PFParticleVector            m_pfParticles;                  
    SpacePointVector            m_spacePoints;                  
    ClusterVector               m_clusters;                     
    VertexVector                m_vertices;                     
    TrackVector                 m_tracks;                       
    ShowerVector                m_showers;                      
    T0Vector                    m_t0s;                          
    MetadataVector              m_metadata;                     
    PCAxisVector                m_pcAxes;                       
    HitVector                   m_hits;                         

    // Association maps
    PFParticlesToSpacePoints    m_pfParticleSpacePointMap;      
    PFParticlesToClusters       m_pfParticleClusterMap;         
    PFParticlesToVertices       m_pfParticleVertexMap;          
    PFParticlesToTracks         m_pfParticleTrackMap;           
    PFParticlesToShowers        m_pfParticleShowerMap;          
    PFParticlesToT0s            m_pfParticleT0Map;              
    PFParticlesToMetadata       m_pfParticleMetadataMap;        
    PFParticlesToPCAxes         m_pfParticlePCAxisMap;          

    SpacePointsToHitVector      m_spacePointHitMap;             
    ClustersToHits              m_clusterHitMap;                
    TracksToHits                m_trackHitMap;                  
    ShowersToHits               m_showerHitMap;                 

    ShowersToPCAxes             m_showerPCAxisMap;              

    PFParticlesToPFParticles    m_pfParticleDaughterMap;        
};

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

template <typename T>
inline void LArPandoraEvent::GetCollection(const Labels::LabelType &inputLabel, art::Handle<std::vector<T> > &outputHandle, std::vector<art::Ptr<T> > &outputCollection) const
{
    m_pEvent->getByLabel(m_labels.GetLabel(inputLabel), outputHandle);   

    for (unsigned int i = 0; i != outputHandle->size(); i++)
    {
        art::Ptr< T > object(outputHandle, i);
        outputCollection.push_back(object);
    } 
}

//------------------------------------------------------------------------------------------------------------------------------------------
    
template <typename T, typename U>
inline void LArPandoraEvent::GetAssociationMap(const Labels::LabelType &inputLabel, art::Handle<std::vector<T> > &inputHandleT,
    std::map<art::Ptr<T>, std::vector<art::Ptr<U> > > &outputAssociationMap) const
{
    art::FindManyP< U > assoc(inputHandleT, (*m_pEvent), m_labels.GetLabel(inputLabel));

    for (unsigned int iT = 0; iT < inputHandleT->size(); iT++)
    {
        art::Ptr<T> objectT(inputHandleT, iT);

        if (outputAssociationMap.find(objectT) == outputAssociationMap.end())
        {
            std::vector< art::Ptr< U > > emptyVect;
            outputAssociationMap.insert(typename std::map< art::Ptr< T >, std::vector< art::Ptr< U > > >::value_type(objectT, emptyVect));
        }

        for (art::Ptr<U> objectU : assoc.at(objectT.key()))
            outputAssociationMap[objectT].push_back(objectU);
    } 
}

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

template <typename T, typename U>
inline void LArPandoraEvent::CollectAssociated(const art::Ptr<T> &anObject, const std::map<art::Ptr<T>, std::vector<art::Ptr<U> > > &associationTtoU,
    std::vector<art::Ptr<U> > &associatedU) const
{
    if (associationTtoU.find(anObject) == associationTtoU.end())
        throw cet::exception("LArPandora") << " LArPandoraEvent::CollectAssociated -- Can not find association for object supplied." << std::endl;

    std::vector<art::Ptr<U> > associatedObjects = associationTtoU.at(anObject);
    associatedU.insert(associatedU.end(), associatedObjects.begin(), associatedObjects.end());
}

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

template <typename T, typename U>
inline void LArPandoraEvent::GetFilteredAssociationMap(const std::vector<art::Ptr<T> > &collectionT, const std::vector<art::Ptr<U> > &collectionU,
    const std::map<art::Ptr<T>, std::vector<art::Ptr<U> > > &inputAssociationTtoU, std::map<art::Ptr<T>, std::vector<art::Ptr<U> > > &outputAssociationTtoU) const
{
    for (art::Ptr< T > objectT : collectionT) 
    {
        std::vector<art::Ptr<U> > emptyVector;
        if (!outputAssociationTtoU.insert(typename std::map<art::Ptr<T>, std::vector<art::Ptr<U> > >::value_type(objectT, emptyVector)).second)
            throw cet::exception("LArPandora") << " LArPandoraEvent::GetFilteredAssociationMap -- Can not have multiple association map entries for a single object." << std::endl;

        for (art::Ptr< U > objectU : inputAssociationTtoU.at(objectT)) 
        {
            typename std::vector<art::Ptr<U> >::const_iterator associatedObjectIter = std::find(collectionU.begin(), collectionU.end(), objectU);
            if (associatedObjectIter == collectionU.end())
                continue;
       
            outputAssociationTtoU[objectT].push_back(objectU);
        }
    }
}
        
//------------------------------------------------------------------------------------------------------------------------------------------

template <typename T>
inline void LArPandoraEvent::WriteCollection(const std::vector<art::Ptr<T> > &collection) const
{
    std::unique_ptr<std::vector<T> > output(new std::vector<T>);

    for (art::Ptr<T> object : collection)
        output->push_back(*object);

    m_pEvent->put(std::move(output));
}

template <>
inline void LArPandoraEvent::WriteCollection(const std::vector<art::Ptr<recob::PFParticle> > &collection) const
{
    std::unique_ptr<std::vector<recob::PFParticle> > output(new std::vector<recob::PFParticle>);

    for (art::Ptr<recob::PFParticle> part : collection)
    {

        if (part->Self() >= m_shift)
            throw cet::exception("LArPandora") << " LArPandoraEvent::WriteCollection -- PFParticle ID exceeds shift value of " << m_shift << ". Can't merge the collections!" << std::endl;

        if (m_pfParticleToOriginIdMap.find(part) == m_pfParticleToOriginIdMap.end())
            throw cet::exception("LArPandora") << " LArPandoraEvent::WriteCollection -- Can't find supplied PFParticle in the PFParticle to origin ID map." << std::endl;

        const size_t offset(m_shift * m_pfParticleToOriginIdMap.at(part));
        const size_t adjustedSelf(part->Self() + offset);

        size_t adjustedParent = part->Parent();
        if (part->Parent() != recob::PFParticle::kPFParticlePrimary)
            adjustedParent += offset;

        const std::vector<size_t> &daughters(part->Daughters());
        std::vector<size_t> adjustedDaughters;
        for (unsigned int d = 0; d < daughters.size(); d++) 
            adjustedDaughters.push_back(daughters[d] + offset);

        recob::PFParticle adjustedPart(part->PdgCode(), adjustedSelf, adjustedParent, adjustedDaughters);
        output->push_back(adjustedPart);
    }

    m_pEvent->put(std::move(output));
}

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

template <typename T, typename U>
inline void LArPandoraEvent::WriteAssociation(const std::map<art::Ptr<T>, std::vector<art::Ptr<U> > > &associationMap, const std::vector<art::Ptr<T> > &collectionT,
    const std::vector<art::Ptr<U> > &collectionU, const bool thisProducesU) const
{
    const art::PtrMaker<T> makePtrT(*m_pEvent, *m_pProducer);
    std::unique_ptr<art::Assns<T, U> > outputAssn(new art::Assns<T, U>);

    for (typename std::map<art::Ptr<T>, std::vector<art::Ptr<U> > >::const_iterator it = associationMap.begin(); it != associationMap.end(); ++it) 
    {
        typename std::vector<art::Ptr<T> >::const_iterator itT = std::find(collectionT.begin(), collectionT.end(), it-> first);
        if (itT == collectionT.end()) 
            throw cet::exception("LArPandora") << " LArPandoraEvent::WriteAssociation -- association map contains object not in collectionT." << std::endl;
        
        art::Ptr<T> newObjectT(makePtrT(std::distance(collectionT.begin(), itT)));
    
        for (const art::Ptr<U> &objectU : it->second)
        {
            if (thisProducesU)
            {
                const art::PtrMaker<U> makePtrU(*m_pEvent, *m_pProducer);

                typename std::vector<art::Ptr<U> >::const_iterator itU = std::find(collectionU.begin(), collectionU.end(), objectU);
                if (itU == collectionU.end()) 
                    throw cet::exception("LArPandora") << " LArPandoraEvent::WriteAssociation -- association map contains object not in collectionU." << std::endl;
                
                art::Ptr<U> newObjectU(makePtrU(std::distance(collectionU.begin(), itU)));
                util::CreateAssn(*m_pProducer, *m_pEvent, newObjectU, newObjectT, *outputAssn);  
            }
            else
            {
                util::CreateAssn(*m_pProducer, *m_pEvent, objectU, newObjectT, *outputAssn);  
            }
        }
    }

    m_pEvent->put(std::move(outputAssn));
}

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

template <typename T>
inline void LArPandoraEvent::MergeCollection(std::vector<art::Ptr<T> > &collectionToMerge, const std::vector<art::Ptr<T> > &collection) const
{
    collectionToMerge.insert(collectionToMerge.end(), collection.begin(), collection.end());
}

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

template <typename T, typename U>
inline void LArPandoraEvent::MergeAssociation(std::map<art::Ptr<T>, std::vector<art::Ptr<U> > > &associationToMerge,
    const std::map<art::Ptr<T>, std::vector<art::Ptr<U> > > &association) const
{
    associationToMerge.insert(association.begin(), association.end());
}

} // namespace lar_pandora

#endif // #ifndef LAR_PANDORA_EVENT_H