LArPandoraEvent.cxx

Go to the documentation of this file.

 
#include "larpandora/LArPandoraEventBuilding/LArPandoraEvent.h"
 
namespace lar_pandora {
 
  LArPandoraEvent::LArPandoraEvent(art::EDProducer* pProducer,
                                   art::Event* pEvent,
                                   const Labels& inputLabels,
                                   const bool shouldProduceT0s)
    : m_pProducer(pProducer)
    , m_pEvent(pEvent)
    , m_labels(inputLabels)
    , m_shouldProduceT0s(shouldProduceT0s)
  {
    this->GetCollections();
  }
 
  //------------------------------------------------------------------------------------------------------------------------------------------
 
  LArPandoraEvent::LArPandoraEvent(const LArPandoraEvent& event,
                                   const PFParticleVector& selectedPFParticles)
    : m_pProducer(event.m_pProducer)
    , m_pEvent(event.m_pEvent)
    , m_labels(event.m_labels)
    , m_shouldProduceT0s(event.m_shouldProduceT0s)
    , m_hits(event.m_hits)
  {
    m_pfParticles = selectedPFParticles;
 
    // Only collect objects associated to a selected particles
    for (const auto& part : selectedPFParticles) {
      this->CollectAssociated(part, event.m_pfParticleSpacePointMap, m_spacePoints);
      this->CollectAssociated(part, event.m_pfParticleClusterMap, m_clusters);
      this->CollectAssociated(part, event.m_pfParticleVertexMap, m_vertices);
      this->CollectAssociated(part, event.m_pfParticleSliceMap, m_slices);
      this->CollectAssociated(part, event.m_pfParticleTrackMap, m_tracks);
      this->CollectAssociated(part, event.m_pfParticleShowerMap, m_showers);
      this->CollectAssociated(part, event.m_pfParticlePCAxisMap, m_pcAxes);
      this->CollectAssociated(part, event.m_pfParticleMetadataMap, m_metadata);
 
      if (m_shouldProduceT0s) this->CollectAssociated(part, event.m_pfParticleT0Map, m_t0s);
    }
 
    // Filter the association maps from the input event to only include objects associated to the selected particles
    this->GetFilteredAssociationMap(
      m_pfParticles, m_spacePoints, event.m_pfParticleSpacePointMap, m_pfParticleSpacePointMap);
    this->GetFilteredAssociationMap(
      m_pfParticles, m_clusters, event.m_pfParticleClusterMap, m_pfParticleClusterMap);
    this->GetFilteredAssociationMap(
      m_pfParticles, m_vertices, event.m_pfParticleVertexMap, m_pfParticleVertexMap);
    this->GetFilteredAssociationMap(
      m_pfParticles, m_slices, event.m_pfParticleSliceMap, m_pfParticleSliceMap);
    this->GetFilteredAssociationMap(
      m_pfParticles, m_tracks, event.m_pfParticleTrackMap, m_pfParticleTrackMap);
    this->GetFilteredAssociationMap(
      m_pfParticles, m_showers, event.m_pfParticleShowerMap, m_pfParticleShowerMap);
    this->GetFilteredAssociationMap(
      m_pfParticles, m_pcAxes, event.m_pfParticlePCAxisMap, m_pfParticlePCAxisMap);
    this->GetFilteredAssociationMap(
      m_pfParticles, m_metadata, event.m_pfParticleMetadataMap, m_pfParticleMetadataMap);
    this->GetFilteredAssociationMap(
      m_spacePoints, event.m_hits, event.m_spacePointHitMap, m_spacePointHitMap);
    this->GetFilteredAssociationMap(
      m_clusters, event.m_hits, event.m_clusterHitMap, m_clusterHitMap);
    this->GetFilteredAssociationMap(m_slices, event.m_hits, event.m_sliceHitMap, m_sliceHitMap);
    this->GetFilteredAssociationMap(m_tracks, event.m_hits, event.m_trackHitMap, m_trackHitMap);
    this->GetFilteredAssociationMap(m_showers, event.m_hits, event.m_showerHitMap, m_showerHitMap);
    this->GetFilteredAssociationMap(
      m_showers, m_pcAxes, event.m_showerPCAxisMap, m_showerPCAxisMap);
 
    if (m_shouldProduceT0s)
      this->GetFilteredAssociationMap(
        m_pfParticles, m_t0s, event.m_pfParticleT0Map, m_pfParticleT0Map);
  }
 
  //------------------------------------------------------------------------------------------------------------------------------------------
 
  void LArPandoraEvent::WriteToEvent() const
  {
    this->WriteCollection(m_pfParticles);
    this->WriteCollection(m_spacePoints);
    this->WriteCollection(m_clusters);
    this->WriteCollection(m_vertices);
    this->WriteCollection(m_slices);
    this->WriteCollection(m_tracks);
    this->WriteCollection(m_showers);
    this->WriteCollection(m_pcAxes);
    this->WriteCollection(m_metadata);
 
    this->WriteAssociation(m_pfParticleSpacePointMap, m_pfParticles, m_spacePoints);
    this->WriteAssociation(m_pfParticleClusterMap, m_pfParticles, m_clusters);
    this->WriteAssociation(m_pfParticleVertexMap, m_pfParticles, m_vertices);
    this->WriteAssociation(m_pfParticleSliceMap, m_pfParticles, m_slices);
    this->WriteAssociation(m_pfParticleTrackMap, m_pfParticles, m_tracks);
    this->WriteAssociation(m_pfParticleShowerMap, m_pfParticles, m_showers);
    this->WriteAssociation(m_pfParticlePCAxisMap, m_pfParticles, m_pcAxes);
    this->WriteAssociation(m_pfParticleMetadataMap, m_pfParticles, m_metadata);
    this->WriteAssociation(m_spacePointHitMap, m_spacePoints, m_hits, false);
    this->WriteAssociation(m_clusterHitMap, m_clusters, m_hits, false);
    this->WriteAssociation(m_sliceHitMap, m_slices, m_hits, false);
    this->WriteAssociation(m_trackHitMap, m_tracks, m_hits, false);
    this->WriteAssociation(m_showerHitMap, m_showers, m_hits, false);
    this->WriteAssociation(m_showerPCAxisMap, m_showers, m_pcAxes);
 
    if (m_shouldProduceT0s) {
      this->WriteCollection(m_t0s);
      this->WriteAssociation(m_pfParticleT0Map, m_pfParticles, m_t0s);
    }
  }
 
  //------------------------------------------------------------------------------------------------------------------------------------------
 
  void LArPandoraEvent::GetCollections()
  {
    this->GetCollection(Labels::PFParticleLabel, m_pfParticles);
    this->GetCollection(Labels::SpacePointLabel, m_spacePoints);
    this->GetCollection(Labels::ClusterLabel, m_clusters);
    this->GetCollection(Labels::VertexLabel, m_vertices);
    this->GetCollection(Labels::SliceLabel, m_slices);
    this->GetCollection(Labels::TrackLabel, m_tracks);
    this->GetCollection(Labels::ShowerLabel, m_showers);
    this->GetCollection(Labels::PCAxisLabel, m_pcAxes);
    this->GetCollection(Labels::PFParticleMetadataLabel, m_metadata);
    this->GetCollection(Labels::HitLabel, m_hits);
 
    this->GetAssociationMap(
      m_pfParticles, Labels::PFParticleToSpacePointLabel, m_pfParticleSpacePointMap);
    this->GetAssociationMap(
      m_pfParticles, Labels::PFParticleToClusterLabel, m_pfParticleClusterMap);
    this->GetAssociationMap(m_pfParticles, Labels::PFParticleToVertexLabel, m_pfParticleVertexMap);
    this->GetAssociationMap(m_pfParticles, Labels::PFParticleToSliceLabel, m_pfParticleSliceMap);
    this->GetAssociationMap(m_pfParticles, Labels::PFParticleToTrackLabel, m_pfParticleTrackMap);
    this->GetAssociationMap(m_pfParticles, Labels::PFParticleToShowerLabel, m_pfParticleShowerMap);
    this->GetAssociationMap(m_pfParticles, Labels::PFParticleToPCAxisLabel, m_pfParticlePCAxisMap);
    this->GetAssociationMap(
      m_pfParticles, Labels::PFParticleToMetadataLabel, m_pfParticleMetadataMap);
    this->GetAssociationMap(m_spacePoints, Labels::SpacePointToHitLabel, m_spacePointHitMap);
    this->GetAssociationMap(m_clusters, Labels::ClusterToHitLabel, m_clusterHitMap);
    this->GetAssociationMap(m_slices, Labels::SliceToHitLabel, m_sliceHitMap);
    this->GetAssociationMap(m_tracks, Labels::TrackToHitLabel, m_trackHitMap);
    this->GetAssociationMap(m_showers, Labels::ShowerToHitLabel, m_showerHitMap);
    this->GetAssociationMap(m_showers, Labels::ShowerToPCAxisLabel, m_showerPCAxisMap);
 
    if (m_shouldProduceT0s) {
      this->GetCollection(Labels::T0Label, m_t0s);
      this->GetAssociationMap(m_pfParticles, Labels::PFParticleToT0Label, m_pfParticleT0Map);
    }
  }
 
  //------------------------------------------------------------------------------------------------------------------------------------------
  //------------------------------------------------------------------------------------------------------------------------------------------
 
  LArPandoraEvent::Labels::Labels(const std::string& pfParticleProducerLabel,
                                  const std::string& hitProducerLabel)
  {
    m_labels.emplace(PFParticleLabel, pfParticleProducerLabel);
    m_labels.emplace(SpacePointLabel, pfParticleProducerLabel);
    m_labels.emplace(ClusterLabel, pfParticleProducerLabel);
    m_labels.emplace(VertexLabel, pfParticleProducerLabel);
    m_labels.emplace(SliceLabel, pfParticleProducerLabel);
    m_labels.emplace(TrackLabel, pfParticleProducerLabel);
    m_labels.emplace(ShowerLabel, pfParticleProducerLabel);
    m_labels.emplace(T0Label, pfParticleProducerLabel);
    m_labels.emplace(PFParticleMetadataLabel, pfParticleProducerLabel);
    m_labels.emplace(PCAxisLabel, pfParticleProducerLabel);
    m_labels.emplace(HitLabel, hitProducerLabel);
 
    m_labels.emplace(PFParticleToSpacePointLabel, pfParticleProducerLabel);
    m_labels.emplace(PFParticleToClusterLabel, pfParticleProducerLabel);
    m_labels.emplace(PFParticleToVertexLabel, pfParticleProducerLabel);
    m_labels.emplace(PFParticleToSliceLabel, pfParticleProducerLabel);
    m_labels.emplace(PFParticleToTrackLabel, pfParticleProducerLabel);
    m_labels.emplace(PFParticleToShowerLabel, pfParticleProducerLabel);
    m_labels.emplace(PFParticleToT0Label, pfParticleProducerLabel);
    m_labels.emplace(PFParticleToMetadataLabel, pfParticleProducerLabel);
    m_labels.emplace(PFParticleToPCAxisLabel, pfParticleProducerLabel);
    m_labels.emplace(SpacePointToHitLabel, pfParticleProducerLabel);
    m_labels.emplace(ClusterToHitLabel, pfParticleProducerLabel);
    m_labels.emplace(SliceToHitLabel, pfParticleProducerLabel);
    m_labels.emplace(TrackToHitLabel, pfParticleProducerLabel);
    m_labels.emplace(ShowerToHitLabel, pfParticleProducerLabel);
    m_labels.emplace(ShowerToPCAxisLabel, pfParticleProducerLabel);
  }
 
  //------------------------------------------------------------------------------------------------------------------------------------------
 
  LArPandoraEvent::Labels::Labels(const std::string& pfParticleProducerLabel,
                                  const std::string& trackProducerLabel,
                                  const std::string& showerProducerLabel,
                                  const std::string& hitProducerLabel)
  {
    m_labels.emplace(PFParticleLabel, pfParticleProducerLabel);
    m_labels.emplace(SpacePointLabel, pfParticleProducerLabel);
    m_labels.emplace(ClusterLabel, pfParticleProducerLabel);
    m_labels.emplace(VertexLabel, pfParticleProducerLabel);
    m_labels.emplace(SliceLabel, pfParticleProducerLabel);
    m_labels.emplace(TrackLabel, trackProducerLabel);
    m_labels.emplace(ShowerLabel, showerProducerLabel);
    m_labels.emplace(T0Label, pfParticleProducerLabel);
    m_labels.emplace(PFParticleMetadataLabel, pfParticleProducerLabel);
    m_labels.emplace(PCAxisLabel, showerProducerLabel);
    m_labels.emplace(HitLabel, hitProducerLabel);
 
    m_labels.emplace(PFParticleToSpacePointLabel, pfParticleProducerLabel);
    m_labels.emplace(PFParticleToClusterLabel, pfParticleProducerLabel);
    m_labels.emplace(PFParticleToVertexLabel, pfParticleProducerLabel);
    m_labels.emplace(PFParticleToSliceLabel, pfParticleProducerLabel);
    m_labels.emplace(PFParticleToTrackLabel, trackProducerLabel);
    m_labels.emplace(PFParticleToShowerLabel, showerProducerLabel);
    m_labels.emplace(PFParticleToT0Label, pfParticleProducerLabel);
    m_labels.emplace(PFParticleToMetadataLabel, pfParticleProducerLabel);
    m_labels.emplace(PFParticleToPCAxisLabel, showerProducerLabel);
    m_labels.emplace(SpacePointToHitLabel, pfParticleProducerLabel);
    m_labels.emplace(ClusterToHitLabel, pfParticleProducerLabel);
    m_labels.emplace(SliceToHitLabel, pfParticleProducerLabel);
    m_labels.emplace(TrackToHitLabel, trackProducerLabel);
    m_labels.emplace(ShowerToHitLabel, showerProducerLabel);
    m_labels.emplace(ShowerToPCAxisLabel, showerProducerLabel);
  }
 
  //------------------------------------------------------------------------------------------------------------------------------------------
 
  const std::string& LArPandoraEvent::Labels::GetLabel(const LabelType type) const
  {
    if (m_labels.find(type) == m_labels.end())
      throw cet::exception("LArPandora")
        << " LArPandoraEvent::GetLabel -- Label map doesn't contain label of requested type"
        << std::endl;
 
    return m_labels.at(type);
  }
 
  //------------------------------------------------------------------------------------------------------------------------------------------
 
  void LArPandoraEvent::Labels::SetLabel(const LabelType type, const std::string& label)
  {
    m_labels[type] = label;
  }
 
} // namespace lar_pandora