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"
 
namespace recob {
  class Cluster;
  class PFParticleMetadata;
}
 
namespace cluster {
  class ClusterParamsAlgBase;
}
 
#include "larpandora/LArPandoraInterface/ILArPandora.h"
#include "larpandora/LArPandoraInterface/LArPandoraHelper.h"
 
#include "lardataobj/AnalysisBase/T0.h"
#include "lardataobj/RecoBase/Cluster.h"
#include "lardataobj/RecoBase/PFParticle.h"
#include "lardataobj/RecoBase/PFParticleMetadata.h"
#include "lardataobj/RecoBase/Slice.h"
#include "lardataobj/RecoBase/SpacePoint.h"
#include "lardataobj/RecoBase/Vertex.h"
 
#include "Api/PandoraApi.h"
 
namespace util {
  class GeometryUtilities;
}
 
#include <map>
#include <vector>
 
//------------------------------------------------------------------------------------------------------------------------------------------
 
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; 
      bool m_shouldRunStitching;                 
      bool
        m_shouldProduceSlices; 
      bool
        m_shouldProduceAllOutcomes; 
      std::string m_allOutcomesInstanceLabel; 
      bool
        m_shouldProduceTestBeamInteractionVertices; 
      std::string
        m_testBeamInteractionVerticesInstanceLabel; 
      bool
        m_isNeutrinoRecoOnlyNoSlicing; 
      std::string m_hitfinderModuleLabel; 
    };
 
    static void ProduceArtOutput(const Settings& settings,
                                 const IdToHitMap& idToHitMap,
                                 art::Event& evt);
 
    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,
      std::function<const pandora::Vertex* const(const pandora::ParticleFlowObject* const)>
        fCriteria);
 
    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 std::string& instanceLabel,
                                 const pandora::CaloHitList& threeDHitList,
                                 const CaloHitToArtHitMap& pandoraHitToArtHitMap,
                                 SpacePointCollection& outputSpacePoints,
                                 SpacePointToHitCollection& outputSpacePointsToHits);
 
    static void BuildClusters(const art::Event& event,
                              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 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 AssociateAdditionalVertices(
      const art::Event& event,
      const std::string& instanceLabel,
      const pandora::PfoVector& pfoVector,
      const IdToIdVectorMap& pfoToVerticesMap,
      PFParticleToVertexCollection& outputParticlesToVertices);
 
    static void BuildParticleMetadata(const art::Event& event,
                                      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 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 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 std::string& instanceLabel,
                                   const IdToHitMap& idToHitMap,
                                   SliceCollection& outputSlices,
                                   SliceToHitCollection& outputSlicesToHits);
 
    static void BuildT0s(const art::Event& event,
                         const std::string& instanceLabel,
                         const pandora::PfoVector& pfoVector,
                         T0Collection& outputT0s,
                         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(
      util::GeometryUtilities const& gser,
      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(util::GeometryUtilities const& gser,
                                       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 art::Event& event,
                        const pandora::ParticleFlowObject* const pPfo,
                        const pandora::PfoVector& pfoVector,
                        size_t& nextId,
                        anab::T0& t0);
 
    template <typename A, typename B>
    static void AddAssociation(const art::Event& event,
                               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 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 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 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, instanceLabel);
    art::Ptr<A> pA(makePtrA(idA));
 
    const art::PtrMaker<B> makePtrB(event, 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 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, instanceLabel);
    art::Ptr<A> pA(makePtrA(idA));
 
    const art::PtrMaker<B> makePtrB(event, 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 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, 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