LArPandoraEvent.h

Go to the documentation of this file.

#ifndef LAR_PANDORA_EVENT_H
#define LAR_PANDORA_EVENT_H 1

#include "larpandora/LArPandoraInterface/LArPandoraHelper.h"

#include "lardataobj/AnalysisBase/T0.h"

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

namespace art {
  class EDProducer;
}
#include "art/Framework/Principal/Event.h"
#include "art/Persistency/Common/PtrMaker.h"
#include "canvas/Persistency/Common/Assns.h"
#include "canvas/Persistency/Common/Ptr.h"

#include <algorithm>
#include <map>
#include <memory>
#include <string>
#include <utility> // std::pair<>

namespace lar_pandora {

  class LArPandoraEvent {
  public:
    template <typename T>
    using Collection = std::vector<art::Ptr<T>>;

    template <typename R, typename D>
    using PairVector = std::vector<std::pair<art::Ptr<R>, D>>;

    template <typename L, typename R, typename D>
    using Association = std::map<art::Ptr<L>, PairVector<R, D>>;

    // Collection typedef specializations
    typedef Collection<recob::Hit> HitCollection;
    typedef Collection<recob::PFParticle> PFParticleCollection;
    typedef Collection<recob::Cluster> ClusterCollection;
    typedef Collection<recob::SpacePoint> SpacePointCollection;
    typedef Collection<recob::Vertex> VertexCollection;
    typedef Collection<recob::Slice> SliceCollection;
    typedef Collection<recob::Track> TrackCollection;
    typedef Collection<recob::Shower> ShowerCollection;
    typedef Collection<recob::PCAxis> PCAxisCollection;
    typedef Collection<larpandoraobj::PFParticleMetadata> PFParticleMetadataCollection;
    typedef Collection<anab::T0> T0Collection;

    // Association typedef specializations
    typedef Association<recob::PFParticle, recob::Cluster, void*> PFParticleToClusterAssoc;
    typedef Association<recob::PFParticle, recob::SpacePoint, void*> PFParticleToSpacePointAssoc;
    typedef Association<recob::PFParticle, recob::Vertex, void*> PFParticleToVertexAssoc;
    typedef Association<recob::PFParticle, recob::Slice, void*> PFParticleToSliceAssoc;
    typedef Association<recob::PFParticle, recob::Track, void*> PFParticleToTrackAssoc;
    typedef Association<recob::PFParticle, recob::Shower, void*> PFParticleToShowerAssoc;
    typedef Association<recob::PFParticle, recob::PCAxis, void*> PFParticleToPCAxisAssoc;
    typedef Association<recob::PFParticle, larpandoraobj::PFParticleMetadata, void*>
      PFParticleToPFParticleMetadataAssoc;
    typedef Association<recob::PFParticle, anab::T0, void*> PFParticleToT0Assoc;

    typedef Association<recob::Cluster, recob::Hit, void*> ClusterToHitAssoc;
    typedef Association<recob::SpacePoint, recob::Hit, void*> SpacePointToHitAssoc;
    typedef Association<recob::Slice, recob::Hit, void*> SliceToHitAssoc;
    typedef Association<recob::Track, recob::Hit, recob::TrackHitMeta> TrackToHitAssoc;
    typedef Association<recob::Shower, recob::Hit, void*> ShowerToHitAssoc;
    typedef Association<recob::Shower, recob::PCAxis, void*> ShowerToPCAxisAssoc;

    class Labels {
    public:
      enum LabelType {
        PFParticleLabel,
        SpacePointLabel,
        ClusterLabel,
        VertexLabel,
        SliceLabel,
        TrackLabel,
        ShowerLabel,
        T0Label,
        PFParticleMetadataLabel,
        PCAxisLabel,
        HitLabel,
        PFParticleToSpacePointLabel,
        PFParticleToClusterLabel,
        PFParticleToVertexLabel,
        PFParticleToSliceLabel,
        PFParticleToTrackLabel,
        PFParticleToShowerLabel,
        PFParticleToT0Label,
        PFParticleToMetadataLabel,
        PFParticleToPCAxisLabel,
        SpacePointToHitLabel,
        ClusterToHitLabel,
        SliceToHitLabel,
        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 SetLabel(const LabelType type, 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);

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

    void WriteToEvent() const;

  private:
    void GetCollections();

    template <typename T>
    void GetCollection(const Labels::LabelType& inputLabel, Collection<T>& outputCollection) const;

    template <typename L, typename R, typename D>
    void GetAssociationMap(const Collection<L>& collectionL,
                           const Labels::LabelType& inputLabel,
                           Association<L, R, D>& outputAssociationMap) const;

    template <typename L, typename R>
    void GetAssociationMap(const Collection<L>& collectionL,
                           const Labels::LabelType& inputLabel,
                           Association<L, R, void*>& outputAssociationMap) const;

    template <typename L, typename R, typename D>
    void CollectAssociated(const art::Ptr<L>& anObject,
                           const Association<L, R, D>& associationLtoR,
                           Collection<R>& associatedR) const;

    template <typename L, typename R, typename D>
    void GetFilteredAssociationMap(const Collection<L>& collectionL,
                                   const Collection<R>& collectionR,
                                   const Association<L, R, D>& inputAssociationLtoR,
                                   Association<L, R, D>& outputAssociationLtoR) const;

    template <typename T>
    void WriteCollection(const Collection<T>& collection) const;

    template <typename L, typename R, typename D>
    void WriteAssociation(const Association<L, R, D>& associationMap,
                          const Collection<L>& collectionL,
                          const Collection<R>& collectionR,
                          const bool thisProducesR = true) const;

    template <typename L, typename R>
    void WriteAssociation(const Association<L, R, void*>& associationMap,
                          const Collection<L>& collectionL,
                          const Collection<R>& collectionR,
                          const bool thisProducesR = true) const;

    template <typename T>
    size_t GetIndex(const art::Ptr<T> object, const Collection<T>& collection) const;

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

    // Collections
    PFParticleCollection m_pfParticles;      
    SpacePointCollection m_spacePoints;      
    ClusterCollection m_clusters;            
    VertexCollection m_vertices;             
    SliceCollection m_slices;                
    TrackCollection m_tracks;                
    ShowerCollection m_showers;              
    T0Collection m_t0s;                      
    PFParticleMetadataCollection m_metadata; 
    PCAxisCollection m_pcAxes;               
    HitCollection m_hits;                    

    // Association maps
    PFParticleToSpacePointAssoc
      m_pfParticleSpacePointMap; 
    PFParticleToClusterAssoc
      m_pfParticleClusterMap; 
    PFParticleToVertexAssoc
      m_pfParticleVertexMap;                     
    PFParticleToSliceAssoc m_pfParticleSliceMap; 
    PFParticleToTrackAssoc m_pfParticleTrackMap; 
    PFParticleToShowerAssoc
      m_pfParticleShowerMap;               
    PFParticleToT0Assoc m_pfParticleT0Map; 
    PFParticleToPFParticleMetadataAssoc
      m_pfParticleMetadataMap; 
    PFParticleToPCAxisAssoc
      m_pfParticlePCAxisMap;                 
    SpacePointToHitAssoc m_spacePointHitMap; 
    ClusterToHitAssoc m_clusterHitMap;       
    SliceToHitAssoc m_sliceHitMap;           
    TrackToHitAssoc m_trackHitMap;           
    ShowerToHitAssoc m_showerHitMap;         
    ShowerToPCAxisAssoc m_showerPCAxisMap;   
  };

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

  template <typename T>
  inline void LArPandoraEvent::GetCollection(const Labels::LabelType& inputLabel,
                                             Collection<T>& outputCollection) const
  {
    const auto& handle(m_pEvent->getValidHandle<std::vector<T>>(m_labels.GetLabel(inputLabel)));

    for (unsigned int i = 0; i != handle->size(); i++)
      outputCollection.emplace_back(handle, i);
  }

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

  template <typename L, typename R, typename D>
  inline void LArPandoraEvent::GetAssociationMap(const Collection<L>& collectionL,
                                                 const Labels::LabelType& inputLabel,
                                                 Association<L, R, D>& outputAssociationMap) const
  {
    const auto& assocHandle(
      m_pEvent->getValidHandle<art::Assns<L, R, D>>(m_labels.GetLabel(inputLabel)));

    // Check that there are no associaions from objects not in collectionL
    for (const auto& entry : *assocHandle) {
      auto it(std::find(collectionL.begin(), collectionL.end(), entry.first));
      if (it == collectionL.end())
        throw cet::exception("LArPandora") << " LArPandoraEvent::GetAssociationMap -- Found object "
                                              "in association that isn't in the supplied collection"
                                           << std::endl;
    }

    // Ensure there is an entry for every object of type L
    for (const auto& objectL : collectionL)
      outputAssociationMap[objectL];

    // Fill the association map
    for (const auto& entry : *assocHandle)
      outputAssociationMap.at(entry.first).emplace_back(entry.second, *entry.data);
  }

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

  template <typename L, typename R>
  inline void LArPandoraEvent::GetAssociationMap(
    const Collection<L>& collectionL,
    const Labels::LabelType& inputLabel,
    Association<L, R, void*>& outputAssociationMap) const
  {
    const auto& assocHandle(
      m_pEvent->getValidHandle<art::Assns<L, R>>(m_labels.GetLabel(inputLabel)));

    // Check that there are no associaions from objects not in collectionL
    for (const auto& entry : *assocHandle) {
      auto it(std::find(collectionL.begin(), collectionL.end(), entry.first));
      if (it == collectionL.end())
        throw cet::exception("LArPandora") << " LArPandoraEvent::GetAssociationMap -- Found object "
                                              "in association that isn't in the supplied collection"
                                           << std::endl;
    }

    // Ensure there is an entry for every object of type L
    for (const auto& objectL : collectionL)
      outputAssociationMap[objectL];

    // Fill the association map
    for (const auto& entry : *assocHandle)
      outputAssociationMap.at(entry.first).emplace_back(entry.second, nullptr);
  }

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

  template <typename L, typename R, typename D>
  inline void LArPandoraEvent::CollectAssociated(const art::Ptr<L>& anObject,
                                                 const Association<L, R, D>& associationLtoR,
                                                 Collection<R>& associatedR) const
  {
    if (associationLtoR.find(anObject) == associationLtoR.end())
      throw cet::exception("LArPandora")
        << " LArPandoraEvent::CollectAssociated -- Can not find association for object supplied."
        << std::endl;

    for (const auto& entry : associationLtoR.at(anObject)) {
      // Ensure we don't repeat objects in the output collection
      if (std::find(associatedR.begin(), associatedR.end(), entry.first) == associatedR.end())
        associatedR.push_back(entry.first);
    }
  }

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

  template <typename L, typename R, typename D>
  inline void LArPandoraEvent::GetFilteredAssociationMap(
    const Collection<L>& collectionL,
    const Collection<R>& collectionR,
    const Association<L, R, D>& inputAssociationLtoR,
    Association<L, R, D>& outputAssociationLtoR) const
  {
    for (const auto& objectL : collectionL) {
      if (inputAssociationLtoR.find(objectL) == inputAssociationLtoR.end())
        throw cet::exception("LArPandora")
          << " LArPandoraEvent::GetFilteredAssociationMap -- Can not find association for object "
             "in supplied collection."
          << std::endl;

      if (outputAssociationLtoR.find(objectL) != outputAssociationLtoR.end())
        throw cet::exception("LArPandora")
          << " LArPandoraEvent::GetFilteredAssociationMap -- Repeated objects in input collectionL"
          << std::endl;

      for (const auto& entry : inputAssociationLtoR.at(objectL)) {
        if (std::find(collectionR.begin(), collectionR.end(), entry.first) == collectionR.end())
          continue;

        outputAssociationLtoR[objectL].push_back(entry);
      }
    }
  }

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

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

    for (const auto& object : collection)
      output->push_back(*object);

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

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

  template <typename L, typename R, typename D>
  inline void LArPandoraEvent::WriteAssociation(const Association<L, R, D>& associationMap,
                                                const Collection<L>& collectionL,
                                                const Collection<R>& collectionR,
                                                const bool thisProducesR) const
  {
    // The output assocation to populate
    std::unique_ptr<art::Assns<L, R, D>> outputAssn(new art::Assns<L, R, D>);

    // NB. The art::Ptrs in the stored collections refer to the producer that originally created the objects (e.g. Pandora pat-rec). To make
    // correct associations, we need to make new art::Ptrs to refer to the *copies* of the objects made by this producer. This is done using
    // the PtrMaker utility.
    const art::PtrMaker<L> makePtrL(*m_pEvent);

    for (auto it = associationMap.begin(); it != associationMap.end(); ++it) {
      const auto indexL(this->GetIndex(it->first, collectionL));
      const auto outputPtrL(makePtrL(indexL));

      for (const auto& entry : it->second) {
        const auto& objectR(entry.first);
        const auto& objectD(entry.second);

        if (thisProducesR) {
          const art::PtrMaker<R> makePtrR(*m_pEvent);
          const auto indexR(this->GetIndex(objectR, collectionR));
          outputAssn->addSingle(outputPtrL, makePtrR(indexR), objectD);
        }
        else {
          outputAssn->addSingle(outputPtrL, objectR, objectD);
        }
      }
    }

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

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

  template <typename L, typename R>
  inline void LArPandoraEvent::WriteAssociation(const Association<L, R, void*>& associationMap,
                                                const Collection<L>& collectionL,
                                                const Collection<R>& collectionR,
                                                const bool thisProducesR) const
  {
    // The output assocation to populate
    std::unique_ptr<art::Assns<L, R>> outputAssn(new art::Assns<L, R>);

    // NB. The art::Ptrs in the stored collections refer to the producer that originally created the objects (e.g. Pandora pat-rec). To make
    // correct associations, we need to make new art::Ptrs to refer to the *copies* of the objects made by this producer. This is done using
    // the PtrMaker utility.
    const art::PtrMaker<L> makePtrL(*m_pEvent);

    for (auto it = associationMap.begin(); it != associationMap.end(); ++it) {
      const auto indexL(this->GetIndex(it->first, collectionL));
      const auto outputPtrL(makePtrL(indexL));

      for (const auto& entry : it->second) {
        const auto& objectR(entry.first);

        if (thisProducesR) {
          const art::PtrMaker<R> makePtrR(*m_pEvent);
          const auto indexR(this->GetIndex(objectR, collectionR));
          outputAssn->addSingle(outputPtrL, makePtrR(indexR));
        }
        else {
          outputAssn->addSingle(outputPtrL, objectR);
        }
      }
    }

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

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

  template <typename T>
  inline size_t LArPandoraEvent::GetIndex(const art::Ptr<T> object,
                                          const Collection<T>& collection) const
  {
    const auto it(std::find(collection.begin(), collection.end(), object));
    if (it == collection.end())
      throw cet::exception("LArPandora")
        << " LArPandoraEvent::GetIndex -- Can't find input object in the supplied collection."
        << std::endl;

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

} // namespace lar_pandora

#endif // #ifndef LAR_PANDORA_EVENT_H