LArPandoraOutput.h

Go to the documentation of this file.

#ifndef LAR_PANDORA_OUTPUT_H
#define LAR_PANDORA_OUTPUT_H

#include "art/Persistency/Common/PtrMaker.h"
#include "lardata/Utilities/AssociationUtil.h"

#include "lardataobj/RecoBase/Cluster.h"
#include "lardataobj/RecoBase/PFParticleMetadata.h"

#include "larreco/RecoAlg/ClusterRecoUtil/ClusterParamsAlgBase.h"

#include "larpandora/LArPandoraInterface/ILArPandora.h"
#include "larpandora/LArPandoraInterface/LArPandoraHelper.h"

#include "Pandora/PandoraInternal.h"

namespace art {class EDProducer;}
namespace pandora {class Pandora;}

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

namespace lar_pandora
{

class LArPandoraOutput
{
public:
    typedef std::vector<size_t> IdVector;
    typedef std::map<size_t, IdVector> IdToIdVectorMap;
    typedef std::map<const pandora::CaloHit *, art::Ptr<recob::Hit> > CaloHitToArtHitMap;
  
    typedef std::unique_ptr< std::vector<recob::PFParticle> > PFParticleCollection;
    typedef std::unique_ptr< std::vector<recob::Vertex> > VertexCollection;
    typedef std::unique_ptr< std::vector<recob::Cluster> > ClusterCollection;
    typedef std::unique_ptr< std::vector<recob::SpacePoint> > SpacePointCollection;
    typedef std::unique_ptr< std::vector<anab::T0> > T0Collection;
    typedef std::unique_ptr< std::vector<larpandoraobj::PFParticleMetadata> > PFParticleMetadataCollection;
    typedef std::unique_ptr< std::vector<recob::Slice> > SliceCollection;

    typedef std::unique_ptr< art::Assns<recob::PFParticle, larpandoraobj::PFParticleMetadata> > PFParticleToMetadataCollection;
    typedef std::unique_ptr< art::Assns<recob::PFParticle, recob::SpacePoint> > PFParticleToSpacePointCollection;
    typedef std::unique_ptr< art::Assns<recob::PFParticle, recob::Cluster> > PFParticleToClusterCollection;
    typedef std::unique_ptr< art::Assns<recob::PFParticle, recob::Vertex> > PFParticleToVertexCollection;
    typedef std::unique_ptr< art::Assns<recob::PFParticle, anab::T0> > PFParticleToT0Collection;
    typedef std::unique_ptr< art::Assns<recob::PFParticle, recob::Slice> > PFParticleToSliceCollection;

    typedef std::unique_ptr< art::Assns<recob::Cluster, recob::Hit> > ClusterToHitCollection;
    typedef std::unique_ptr< art::Assns<recob::SpacePoint, recob::Hit> > SpacePointToHitCollection;
    typedef std::unique_ptr< art::Assns<recob::Slice, recob::Hit> > SliceToHitCollection;

    class Settings
    {
    public:
        Settings();

        void Validate() const;

        const pandora::Pandora *m_pPrimaryPandora;              
        art::EDProducer        *m_pProducer;                    
        bool                    m_shouldRunStitching;           
        bool                    m_shouldProduceAllOutcomes;     
        std::string             m_allOutcomesInstanceLabel;     
        bool                    m_isNeutrinoRecoOnlyNoSlicing;  
        std::string             m_hitfinderModuleLabel;         
    };

    static void ProduceArtOutput(const Settings &settings, const IdToHitMap &idToHitMap, art::Event &evt);

private:
    static bool GetPandoraInstance(const pandora::Pandora *const pPrimaryPandora, const std::string &name,
        const pandora::Pandora *&pPandoraInstance);

    static void GetPandoraSlices(const pandora::Pandora *const pPrimaryPandora, pandora::PfoVector &slicePfos);

    static bool IsClearCosmic(const pandora::ParticleFlowObject *const pPfo);

    static bool IsFromSlice(const pandora::ParticleFlowObject *const pPfo);

    static unsigned int GetSliceIndex(const pandora::ParticleFlowObject *const pPfo);

    static pandora::PfoVector CollectPfos(const pandora::Pandora *const pPrimaryPandora);
    
    static pandora::PfoVector CollectAllPfoOutcomes(const pandora::Pandora *const pPrimaryPandora);

    static void CollectPfos(const pandora::PfoList &parentPfoList, pandora::PfoVector &pfoVector);

    static pandora::VertexVector CollectVertices(const pandora::PfoVector &pfoVector, IdToIdVectorMap &pfoToVerticesMap);

    static pandora::ClusterList CollectClusters(const pandora::PfoVector &pfoVector, IdToIdVectorMap &pfoToClustersMap);
    
    static void Collect3DHits(const pandora::ParticleFlowObject *const pPfo, pandora::CaloHitVector &caloHits);

    static pandora::CaloHitList Collect3DHits(const pandora::PfoVector &pfoVector, IdToIdVectorMap &pfoToThreeDHitsMap);

    template <typename T>
    static size_t GetId(const T *const pT, const std::list<const T*> &tList);
    
    template <typename T>
    static size_t GetId(const T *const pT, const std::vector<const T*> &tVector);
    
    static void GetPandoraToArtHitMap(const pandora::ClusterList &clusterList, const pandora::CaloHitList &threeDHitList,
        const IdToHitMap &idToHitMap, CaloHitToArtHitMap &pandoraHitToArtHitMap);

    static art::Ptr<recob::Hit> GetHit(const IdToHitMap &idToHitMap, const pandora::CaloHit *const pCaloHit);

    static void BuildVertices(const pandora::VertexVector &vertexVector, VertexCollection &outputVertices);

    static void BuildSpacePoints(const art::Event &event, const art::EDProducer *const pProducer, const std::string &instanceLabel,
        const pandora::CaloHitList &threeDHitList, const CaloHitToArtHitMap &pandoraHitToArtHitMap, SpacePointCollection &outputSpacePoints,
        SpacePointToHitCollection &outputSpacePointsToHits);

    static void BuildClusters(const art::Event &event, const art::EDProducer *const pProducer, const std::string &instanceLabel,
        const pandora::ClusterList &clusterList, const CaloHitToArtHitMap &pandoraHitToArtHitMap, const IdToIdVectorMap &pfoToClustersMap,
        ClusterCollection &outputClusters, ClusterToHitCollection &outputClustersToHits, IdToIdVectorMap &pfoToArtClustersMap);

    static void BuildPFParticles(const art::Event &event, const art::EDProducer *const pProducer, const std::string &instanceLabel,
        const pandora::PfoVector &pfoVector, const IdToIdVectorMap &pfoToVerticesMap, const IdToIdVectorMap &pfoToThreeDHitsMap, 
        const IdToIdVectorMap &pfoToArtClustersMap, PFParticleCollection &outputParticles, 
        PFParticleToVertexCollection &outputParticlesToVertices, PFParticleToSpacePointCollection &outputParticlesToSpacePoints,
        PFParticleToClusterCollection &outputParticlesToClusters);

    static void BuildParticleMetadata(const art::Event &event, const art::EDProducer *const pProducer, const std::string &instanceLabel, 
        const pandora::PfoVector &pfoVector, PFParticleMetadataCollection &outputParticleMetadata,
        PFParticleToMetadataCollection &outputParticlesToMetadata);

    static void BuildSlices(const Settings &settings, const pandora::Pandora *const pPrimaryPandora, const art::Event &event,
    const art::EDProducer *const pProducer, const std::string &instanceLabel, const pandora::PfoVector &pfoVector, 
    const IdToHitMap &idToHitMap, SliceCollection &outputSlices, PFParticleToSliceCollection &outputParticlesToSlices,
    SliceToHitCollection &outputSlicesToHits);

    static unsigned int BuildDummySlice(SliceCollection &outputSlices);

    static void CopyAllHitsToSingleSlice(const Settings &settings, const art::Event &event, const art::EDProducer *const pProducer,
    const std::string &instanceLabel, const pandora::PfoVector &pfoVector, const IdToHitMap &idToHitMap, SliceCollection &outputSlices,
    PFParticleToSliceCollection &outputParticlesToSlices, SliceToHitCollection &outputSlicesToHits);

    static unsigned int BuildSlice(const pandora::ParticleFlowObject *const pParentPfo, const art::Event &event,
    const art::EDProducer *const pProducer, const std::string &instanceLabel, const IdToHitMap &idToHitMap, SliceCollection &outputSlices,
    SliceToHitCollection &outputSlicesToHits);

    static void BuildT0s(const art::Event &event, const art::EDProducer *const pProducer, const std::string &instanceLabel,
        const pandora::PfoVector &pfoVector, T0Collection &outputT0s, const CaloHitToArtHitMap &pandoraHitToArtHitMap,
        PFParticleToT0Collection &outputParticlesToT0s);

    static recob::Vertex BuildVertex(const pandora::Vertex *const pVertex, const size_t vertexId);
    
    static recob::SpacePoint BuildSpacePoint(const pandora::CaloHit *const pCaloHit, const size_t spacePointId);

    static void GetHitsInCluster(const pandora::Cluster *const pCluster, pandora::CaloHitVector &sortedHits);

    static std::vector<recob::Cluster> BuildClusters(const pandora::Cluster *const pCluster, const pandora::ClusterList &clusterList,
        const CaloHitToArtHitMap &pandoraHitToArtHitMap, IdToIdVectorMap &pandoraClusterToArtClustersMap, std::vector<HitVector> &hitVectors,
        size_t &nextId, cluster::ClusterParamsAlgBase &algo);

    static recob::Cluster BuildCluster(const size_t id, const HitVector &hitVector, const HitList &isolatedHits,
        cluster::ClusterParamsAlgBase &algo);
    
    static recob::PFParticle BuildPFParticle(const pandora::ParticleFlowObject *const pPfo, const size_t pfoId, const pandora::PfoVector &pfoVector);

    static bool BuildT0(const pandora::ParticleFlowObject *const pPfo, const pandora::PfoVector &pfoVector, size_t &nextId,
        const CaloHitToArtHitMap &pandoraHitToArtHitMap, anab::T0 &t0);
    
    static double CalculateT0(const art::Ptr<recob::Hit> hit, const pandora::CaloHit *const pCaloHit);

    template <typename A, typename B>
    static void AddAssociation(const art::Event &event, const art::EDProducer *const pProducer, const std::string &instanceLabel,
        const size_t idA, const size_t idB, std::unique_ptr< art::Assns<A, B> > &association);

    template <typename A, typename B>
    static void AddAssociation(const art::Event &event, const art::EDProducer *const pProducer, const std::string &instanceLabel,
        const size_t idA, const IdToIdVectorMap &aToBMap, std::unique_ptr< art::Assns<A, B> > &association);

    template <typename A, typename B>
    static void AddAssociation(const art::Event &event, const art::EDProducer *const pProducer, const std::string &instanceLabel,
        const size_t idA, const std::vector< art::Ptr<B> > &bVector, std::unique_ptr< art::Assns<A, B> > &association);
};

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

template <typename T>
inline size_t LArPandoraOutput::GetId(const T *const pT, const std::list<const T*> &tList)
{
    typename std::list<const T*>::const_iterator it(std::find(tList.begin(), tList.end(), pT));

    if (it == tList.end())
        throw cet::exception("LArPandora") << " LArPandoraOutput::GetId --- can't find the id of supplied object";

    return static_cast<size_t>(std::distance(tList.begin(), it));
}

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

template <typename T>
inline size_t LArPandoraOutput::GetId(const T *const pT, const std::vector<const T*> &tVector)
{
    typename std::vector<const T*>::const_iterator it(std::find(tVector.begin(), tVector.end(), pT));

    if (it == tVector.end())
        throw cet::exception("LArPandora") << " LArPandoraOutput::GetId --- can't find the id of supplied object";

    return static_cast<size_t>(std::distance(tVector.begin(), it));
}

//------------------------------------------------------------------------------------------------------------------------------------------
    
template <typename A, typename B>
inline void LArPandoraOutput::AddAssociation(const art::Event &event, const art::EDProducer *const pProducer,
    const std::string &instanceLabel, const size_t idA, const size_t idB, std::unique_ptr< art::Assns<A, B> > &association)
{
    const art::PtrMaker<A> makePtrA(event, *pProducer, instanceLabel);
    art::Ptr<A> pA(makePtrA(idA));

    const art::PtrMaker<B> makePtrB(event, *pProducer, instanceLabel);
    art::Ptr<B> pB(makePtrB(idB));
    
    association->addSingle(pA, pB);
}

//------------------------------------------------------------------------------------------------------------------------------------------
    
template <typename A, typename B>
inline void LArPandoraOutput::AddAssociation(const art::Event &event, const art::EDProducer *const pProducer,
    const std::string &instanceLabel, const size_t idA, const IdToIdVectorMap &aToBMap, std::unique_ptr< art::Assns<A, B> > &association)
{
    IdToIdVectorMap::const_iterator it(aToBMap.find(idA));
    if (it == aToBMap.end())
        throw cet::exception("LArPandora") << " LArPandoraOutput::AddAssociation --- id doesn't exists in the assocaition map";

    const art::PtrMaker<A> makePtrA(event, *pProducer, instanceLabel);
    art::Ptr<A> pA(makePtrA(idA));

    const art::PtrMaker<B> makePtrB(event, *pProducer, instanceLabel);
    for (const size_t idB : it->second)
    {
        art::Ptr<B> pB(makePtrB(idB));
        association->addSingle(pA, pB);
    }
}

//------------------------------------------------------------------------------------------------------------------------------------------
    
template <typename A, typename B>
inline void LArPandoraOutput::AddAssociation(const art::Event &event, const art::EDProducer *const pProducer,
    const std::string &instanceLabel, const size_t idA, const std::vector< art::Ptr<B> > &bVector,
    std::unique_ptr< art::Assns<A, B> > &association)
{
    const art::PtrMaker<A> makePtrA(event, *pProducer, instanceLabel);
    art::Ptr<A> pA(makePtrA(idA));
    
    for (const art::Ptr<B> &pB : bVector)
        association->addSingle(pA, pB);
}

} // namespace lar_pandora

#endif //  LAR_PANDORA_OUTPUT_H