lar_pandora::LArPandoraOutput Class Reference

#include <LArPandoraOutput.h>

Classes
class	Settings
	Settings class. More...

Public Types
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

Static Public Member Functions
static void	ProduceArtOutput (const Settings &settings, const IdToHitMap &idToHitMap, art::Event &evt)
	Convert the Pandora PFOs into ART clusters and write into ART event. More...
static bool	GetPandoraInstance (const pandora::Pandora *const pPrimaryPandora, const std::string &name, const pandora::Pandora *&pPandoraInstance)
	Get the address of a pandora instance with a given name. More...
static void	GetPandoraSlices (const pandora::Pandora *const pPrimaryPandora, pandora::PfoVector &slicePfos)
	Get the slice pfos - one pfo per slice. More...
static bool	IsClearCosmic (const pandora::ParticleFlowObject *const pPfo)
	Check if the input pfo is an unambiguous cosmic ray. More...
static bool	IsFromSlice (const pandora::ParticleFlowObject *const pPfo)
	Check if the input pfo is from a slice. More...
static unsigned int	GetSliceIndex (const pandora::ParticleFlowObject *const pPfo)
	Get the index of the slice from which this pfo was produced. More...
static pandora::PfoVector	CollectPfos (const pandora::Pandora *const pPrimaryPandora)
	Collect the current pfos (including all downstream pfos) from the master pandora instance. More...
static pandora::PfoVector	CollectAllPfoOutcomes (const pandora::Pandora *const pPrimaryPandora)
	Collect the pfos (including all downstream pfos) from the master and daughter pandora instances. More...
static void	CollectPfos (const pandora::PfoList &parentPfoList, pandora::PfoVector &pfoVector)
	Collect a sorted list of all downstream pfos of an input list of parent. More...
static pandora::VertexVector	CollectVertices (const pandora::PfoVector &pfoVector, IdToIdVectorMap &pfoToVerticesMap, std::function< const pandora::Vertex *const (const pandora::ParticleFlowObject *const)> fCriteria)
	Collect all vertices contained in the input pfo list Order is guaranteed provided pfoVector is ordered. More...
static pandora::ClusterList	CollectClusters (const pandora::PfoVector &pfoVector, IdToIdVectorMap &pfoToClustersMap)
	Collect a sorted list of all 2D clusters contained in the input pfo list Order is guaranteed provided pfoVector is ordered. More...
static void	Collect3DHits (const pandora::ParticleFlowObject *const pPfo, pandora::CaloHitVector &caloHits)
	Collect a sorted vector of all 3D hits in the input pfo. More...
static pandora::CaloHitList	Collect3DHits (const pandora::PfoVector &pfoVector, IdToIdVectorMap &pfoToThreeDHitsMap)
	Collect a sorted list of all 3D hits contained in the input pfo list Order is guaranteed provided pfoVector is ordered. More...
template<typename T >
static size_t	GetId (const T *const pT, const std::list< const T * > &tList)
	Find the index of an input object in an input list. Throw an exception if it doesn't exist. More...
template<typename T >
static size_t	GetId (const T *const pT, const std::vector< const T * > &tVector)
	Find the index of an input object in an input vector. Throw an exception if it doesn't exist. More...
static void	GetPandoraToArtHitMap (const pandora::ClusterList &clusterList, const pandora::CaloHitList &threeDHitList, const IdToHitMap &idToHitMap, CaloHitToArtHitMap &pandoraHitToArtHitMap)
	Collect all 2D and 3D hits that were used / produced in the reconstruction and map them to their corresponding ART hit. More...
static art::Ptr< recob::Hit >	GetHit (const IdToHitMap &idToHitMap, const pandora::CaloHit *const pCaloHit)
	Look up ART hit from an input Pandora hit. More...
static void	BuildVertices (const pandora::VertexVector &vertexVector, VertexCollection &outputVertices)
	Convert pandora vertices to ART vertices and add them to the output vector. More...
static void	BuildSpacePoints (const art::Event &event, const std::string &instanceLabel, const pandora::CaloHitList &threeDHitList, const CaloHitToArtHitMap &pandoraHitToArtHitMap, SpacePointCollection &outputSpacePoints, SpacePointToHitCollection &outputSpacePointsToHits)
	Convert pandora 3D hits to ART spacepoints and add them to the output vector Create the associations between spacepoints and hits. More...
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)
	Convert pandora 2D clusters to ART clusters and add them to the output vector Create the associations between clusters and hits. For multiple drift volumes, each pandora cluster can correspond to multiple ART clusters. More...
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)
	Convert between pfos and PFParticles and add them to the output vector Create the associations between PFParticle and vertices, spacepoints and clusters. More...
static void	AssociateAdditionalVertices (const art::Event &event, const std::string &instanceLabel, const pandora::PfoVector &pfoVector, const IdToIdVectorMap &pfoToVerticesMap, PFParticleToVertexCollection &outputParticlesToVertices)
	Convert Create the associations between pre-existing PFParticle and additional vertices. More...
static void	BuildParticleMetadata (const art::Event &event, const std::string &instanceLabel, const pandora::PfoVector &pfoVector, PFParticleMetadataCollection &outputParticleMetadata, PFParticleToMetadataCollection &outputParticlesToMetadata)
	Build metadata objects from a list of input pfos. More...
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)
	Build slices - collections of hits which each describe a single particle hierarchy. More...
static unsigned int	BuildDummySlice (SliceCollection &outputSlices)
	Build a new slice object with dummy information. More...
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)
	Ouput a single slice containing all of the input hits. More...
static unsigned int	BuildSlice (const pandora::ParticleFlowObject *const pParentPfo, const art::Event &event, const std::string &instanceLabel, const IdToHitMap &idToHitMap, SliceCollection &outputSlices, SliceToHitCollection &outputSlicesToHits)
	Build a new slice object from a PFO, this can be a top-level parent in a hierarchy or a "slice PFO" from the slicing instance. More...
static void	BuildT0s (const art::Event &event, const std::string &instanceLabel, const pandora::PfoVector &pfoVector, T0Collection &outputT0s, PFParticleToT0Collection &outputParticlesToT0s)
	Calculate the T0 of each pfos and add them to the output vector Create the associations between PFParticle and T0s. More...
static recob::Vertex	BuildVertex (const pandora::Vertex *const pVertex, const size_t vertexId)
	Convert from a pandora vertex to an ART vertex. More...
static recob::SpacePoint	BuildSpacePoint (const pandora::CaloHit *const pCaloHit, const size_t spacePointId)
	Convert from a pandora 3D hit to an ART spacepoint. More...
static void	GetHitsInCluster (const pandora::Cluster *const pCluster, pandora::CaloHitVector &sortedHits)
	Collect a sorted list of all 2D hits in a cluster. More...
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)
	Convert from a pandora 2D cluster to a vector of ART clusters (produce multiple if the cluster is split over drift volumes) More...
static recob::Cluster	BuildCluster (util::GeometryUtilities const &gser, const size_t id, const HitVector &hitVector, const HitList &isolatedHits, cluster::ClusterParamsAlgBase &algo)
	Build an ART cluster from an input vector of ART hits. More...
static recob::PFParticle	BuildPFParticle (const pandora::ParticleFlowObject *const pPfo, const size_t pfoId, const pandora::PfoVector &pfoVector)
	Convert from a pfo to and ART PFParticle. More...
static bool	BuildT0 (const art::Event &event, const pandora::ParticleFlowObject *const pPfo, const pandora::PfoVector &pfoVector, size_t &nextId, anab::T0 &t0)
	If required, build a T0 for the input pfo. More...
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)
	Add an association between objects with two given ids. More...
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)
	Add associations between input objects. More...
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)
	Add associations between input objects. More...

Detailed Description

Definition at line 44 of file LArPandoraOutput.h.

Member Typedef Documentation

typedef std::map<const pandora::CaloHit*, art::Ptr<recob::Hit> > lar_pandora::LArPandoraOutput::CaloHitToArtHitMap

Definition at line 48 of file LArPandoraOutput.h.

typedef std::unique_ptr<std::vector<recob::Cluster> > lar_pandora::LArPandoraOutput::ClusterCollection

Definition at line 52 of file LArPandoraOutput.h.

typedef std::unique_ptr<art::Assns<recob::Cluster, recob::Hit> > lar_pandora::LArPandoraOutput::ClusterToHitCollection

Definition at line 71 of file LArPandoraOutput.h.

typedef std::map<size_t, IdVector> lar_pandora::LArPandoraOutput::IdToIdVectorMap

Definition at line 47 of file LArPandoraOutput.h.

typedef std::vector<size_t> lar_pandora::LArPandoraOutput::IdVector

Definition at line 46 of file LArPandoraOutput.h.

typedef std::unique_ptr<std::vector<recob::PFParticle> > lar_pandora::LArPandoraOutput::PFParticleCollection

Definition at line 50 of file LArPandoraOutput.h.

typedef std::unique_ptr<std::vector<larpandoraobj::PFParticleMetadata> > lar_pandora::LArPandoraOutput::PFParticleMetadataCollection

Definition at line 56 of file LArPandoraOutput.h.

typedef std::unique_ptr<art::Assns<recob::PFParticle, recob::Cluster> > lar_pandora::LArPandoraOutput::PFParticleToClusterCollection

Definition at line 64 of file LArPandoraOutput.h.

typedef std::unique_ptr<art::Assns<recob::PFParticle, larpandoraobj::PFParticleMetadata> > lar_pandora::LArPandoraOutput::PFParticleToMetadataCollection

Definition at line 60 of file LArPandoraOutput.h.

typedef std::unique_ptr<art::Assns<recob::PFParticle, recob::Slice> > lar_pandora::LArPandoraOutput::PFParticleToSliceCollection

Definition at line 69 of file LArPandoraOutput.h.

typedef std::unique_ptr<art::Assns<recob::PFParticle, recob::SpacePoint> > lar_pandora::LArPandoraOutput::PFParticleToSpacePointCollection

Definition at line 62 of file LArPandoraOutput.h.

typedef std::unique_ptr<art::Assns<recob::PFParticle, anab::T0> > lar_pandora::LArPandoraOutput::PFParticleToT0Collection

Definition at line 67 of file LArPandoraOutput.h.

typedef std::unique_ptr<art::Assns<recob::PFParticle, recob::Vertex> > lar_pandora::LArPandoraOutput::PFParticleToVertexCollection

Definition at line 66 of file LArPandoraOutput.h.

typedef std::unique_ptr<std::vector<recob::Slice> > lar_pandora::LArPandoraOutput::SliceCollection

Definition at line 57 of file LArPandoraOutput.h.

typedef std::unique_ptr<art::Assns<recob::Slice, recob::Hit> > lar_pandora::LArPandoraOutput::SliceToHitCollection

Definition at line 73 of file LArPandoraOutput.h.

typedef std::unique_ptr<std::vector<recob::SpacePoint> > lar_pandora::LArPandoraOutput::SpacePointCollection

Definition at line 53 of file LArPandoraOutput.h.

typedef std::unique_ptr<art::Assns<recob::SpacePoint, recob::Hit> > lar_pandora::LArPandoraOutput::SpacePointToHitCollection

Definition at line 72 of file LArPandoraOutput.h.

typedef std::unique_ptr<std::vector<anab::T0> > lar_pandora::LArPandoraOutput::T0Collection

Definition at line 54 of file LArPandoraOutput.h.

typedef std::unique_ptr<std::vector<recob::Vertex> > lar_pandora::LArPandoraOutput::VertexCollection

Definition at line 51 of file LArPandoraOutput.h.

Member Function Documentation

template<typename A , typename B >

void lar_pandora::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  )

inlinestatic

Add an association between objects with two given ids.

Parameters

event	the ART event
idA	the id of an object of type A
idB	the id of an object of type B to associate to the first object
association	the output association to update

Definition at line 654 of file LArPandoraOutput.h.

  {
    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 >

void lar_pandora::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  )

inlinestatic

Add associations between input objects.

Parameters

event	the ART event
idA	the id of an object of type A
aToBMap	the input mapping from IDs of objects of type A to IDs of objects of type B to associate
association	the output association to update

Definition at line 673 of file LArPandoraOutput.h.

  {
    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 >

void lar_pandora::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  )

inlinestatic

Add associations between input objects.

Parameters

event	the ART event
idA	the id of an object of type A
bVector	the input vector of IDs of objects of type B to associate
association	the output association to update

Definition at line 698 of file LArPandoraOutput.h.

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

    for (const art::Ptr<B>& pB : bVector)
      association->addSingle(pA, pB);
  }

void lar_pandora::LArPandoraOutput::AssociateAdditionalVertices ( const art::Event &  event, const std::string &  instanceLabel, const pandora::PfoVector &  pfoVector, const IdToIdVectorMap &  pfoToVerticesMap, PFParticleToVertexCollection &  outputParticlesToVertices  )

static

Convert Create the associations between pre-existing PFParticle and additional vertices.

Parameters

event	the art event
instanceLabel	instance label
pfoVector	the input list of pfos to convert
pfoToVerticesMap	the input mapping from pfo ID to vertex IDs
outputParticlesToVertices	the output associations between PFParticles and vertices

Definition at line 730 of file LArPandoraOutput.cxx.

  {
    for (unsigned int pfoId = 0; pfoId < pfoVector.size(); ++pfoId) {
      if (pfoToVerticesMap.find(pfoId) != pfoToVerticesMap.end())
        LArPandoraOutput::AddAssociation(
          event, instanceLabel, pfoId, pfoToVerticesMap, outputParticlesToVertices);
    }
  }

recob::Cluster lar_pandora::LArPandoraOutput::BuildCluster ( util::GeometryUtilities const &  gser, const size_t  id, const HitVector &  hitVector, const HitList &  isolatedHits, cluster::ClusterParamsAlgBase &  algo  )

static

Build an ART cluster from an input vector of ART hits.

Parameters

id	the id code for the cluster
hitVector	the input vector of hits
isolatedHits	the input list of isolated hits
algo	algorithm set to fill cluster members

Returns

the ART cluster

If you don't know which algorithm to pick, StandardClusterParamsAlg is a good default. The hits that are isolated (that is, present in isolatedHits) are not fed to the cluster parameter algorithms.

Definition at line 1076 of file LArPandoraOutput.cxx.

  {
    if (hitVector.empty())
      throw cet::exception("LArPandora")
        << " LArPandoraOutput::BuildCluster --- No input hits were provided ";

    // Fill list of cluster properties
    geo::View_t view(geo::kUnknown);
    geo::PlaneID planeID;

    double startWire(+std::numeric_limits<float>::max()), sigmaStartWire(0.0);
    double startTime(+std::numeric_limits<float>::max()), sigmaStartTime(0.0);
    double endWire(-std::numeric_limits<float>::max()), sigmaEndWire(0.0);
    double endTime(-std::numeric_limits<float>::max()), sigmaEndTime(0.0);

    std::vector<recob::Hit const*> hits_for_params;
    hits_for_params.reserve(hitVector.size());

    for (const art::Ptr<recob::Hit>& hit : hitVector) {
      const double thisWire(hit->WireID().Wire);
      const double thisWireSigma(0.5);
      const double thisTime(hit->PeakTime());
      const double thisTimeSigma(double(2. * hit->RMS()));
      const geo::View_t thisView(hit->View());
      const geo::PlaneID thisPlaneID(hit->WireID().planeID());

      if (geo::kUnknown == view) {
        view = thisView;
        planeID = thisPlaneID;
      }

      if (!(thisView == view && thisPlaneID == planeID)) {
        throw cet::exception("LArPandora")
          << " LArPandoraOutput::BuildCluster --- Input hits have inconsistent plane IDs ";
      }

      hits_for_params.push_back(&*hit);

      if (isolatedHits.count(hit)) continue;

      if (thisWire < startWire || (thisWire == startWire && thisTime < startTime)) {
        startWire = thisWire;
        sigmaStartWire = thisWireSigma;
        startTime = thisTime;
        sigmaStartTime = thisTimeSigma;
      }

      if (thisWire > endWire || (thisWire == endWire && thisTime > endTime)) {
        endWire = thisWire;
        sigmaEndWire = thisWireSigma;
        endTime = thisTime;
        sigmaEndTime = thisTimeSigma;
      }
    }

    // feed the algorithm with all the cluster hits
    algo.SetHits(gser, hits_for_params);

    // create the recob::Cluster directly in the vector
    return cluster::ClusterCreator(gser,
                                   algo,                  // algo
                                   startWire,             // start_wire
                                   sigmaStartWire,        // sigma_start_wire
                                   startTime,             // start_tick
                                   sigmaStartTime,        // sigma_start_tick
                                   endWire,               // end_wire
                                   sigmaEndWire,          // sigma_end_wire
                                   endTime,               // end_tick
                                   sigmaEndTime,          // sigma_end_tick
                                   id,                    // ID
                                   view,                  // view
                                   planeID,               // plane
                                   recob::Cluster::Sentry // sentry
                                   )
      .move();
  }

void lar_pandora::LArPandoraOutput::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

Convert pandora 2D clusters to ART clusters and add them to the output vector Create the associations between clusters and hits. For multiple drift volumes, each pandora cluster can correspond to multiple ART clusters.

Parameters

event	the art event
clusterList	the input list of 2D pandora clusters to convert
pandoraHitToArtHitMap	the input mapping from pandora hits to ART hits
pfoToClustersMap	the input mapping from pfo ID to cluster IDs
outputClusters	the output vector of clusters
outputClustersToHits	the output associations between clusters and hits
pfoToArtClustersMap	the output mapping from pfo ID to art cluster ID

Definition at line 628 of file LArPandoraOutput.cxx.

  {
    cluster::StandardClusterParamsAlg clusterParamAlgo;

    art::ServiceHandle<geo::Geometry const> geom{};
    auto const clock_data =
      art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(event);
    auto const det_prop =
      art::ServiceHandle<detinfo::DetectorPropertiesService const>()->DataFor(event, clock_data);
    util::GeometryUtilities const gser{*geom, clock_data, det_prop};

    // Produce the art clusters
    size_t nextClusterId(0);
    IdToIdVectorMap pandoraClusterToArtClustersMap;
    for (const pandora::Cluster* const pCluster : clusterList) {
      std::vector<HitVector> hitVectors;
      const std::vector<recob::Cluster> clusters(
        LArPandoraOutput::BuildClusters(gser,
                                        pCluster,
                                        clusterList,
                                        pandoraHitToArtHitMap,
                                        pandoraClusterToArtClustersMap,
                                        hitVectors,
                                        nextClusterId,
                                        clusterParamAlgo));

      if (hitVectors.size() != clusters.size())
        throw cet::exception("LArPandora")
          << " LArPandoraOutput::BuildClusters --- invalid hit vectors for clusters produced ";

      for (unsigned int i = 0; i < clusters.size(); ++i) {
        LArPandoraOutput::AddAssociation(
          event, instanceLabel, nextClusterId - 1, hitVectors.at(i), outputClustersToHits);
        outputClusters->push_back(clusters.at(i));
      }
    }

    // Get mapping from pfo id to art cluster id
    for (IdToIdVectorMap::const_iterator it = pfoToClustersMap.begin();
         it != pfoToClustersMap.end();
         ++it) {
      if (!pfoToArtClustersMap.insert(IdToIdVectorMap::value_type(it->first, {})).second)
        throw cet::exception("LArPandora")
          << " LArPandoraOutput::BuildClusters --- repeated pfo ids ";

      for (const size_t pandoraClusterId : it->second) {
        IdToIdVectorMap::const_iterator it2(pandoraClusterToArtClustersMap.find(pandoraClusterId));

        if (it2 == pandoraClusterToArtClustersMap.end())
          throw cet::exception("LArPandora") << " LArPandoraOutput::BuildClusters --- found a "
                                                "pandora cluster with no associated recob cluster ";

        for (const size_t recobClusterId : it2->second)
          pfoToArtClustersMap.at(it->first).push_back(recobClusterId);
      }
    }
  }

std::vector< recob::Cluster > lar_pandora::LArPandoraOutput::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

Convert from a pandora 2D cluster to a vector of ART clusters (produce multiple if the cluster is split over drift volumes)

Parameters

pCluster	the input cluster
clusterList	the input list of clusters
pandoraHitToArtHitMap	the input mapping from pandora hits to ART hits
pandoraClusterToArtClustersMap	output mapping from pandora cluster ID to art cluster IDs
hitVectors	the output vectors of hits for each cluster produced used to produce associations
algo	algorithm set to fill cluster members
the	vector of ART clusters

Definition at line 1017 of file LArPandoraOutput.cxx.

  {
    std::vector<recob::Cluster> clusters;

    // Get the cluster ID and set up the map entry
    const size_t clusterId(LArPandoraOutput::GetId(pCluster, clusterList));
    if (!pandoraClusterToArtClustersMap.insert(IdToIdVectorMap::value_type(clusterId, {})).second)
      throw cet::exception("LArPandora")
        << " LArPandoraOutput::BuildClusters --- repeated clusters in input list ";

    pandora::CaloHitVector sortedHits;
    LArPandoraOutput::GetHitsInCluster(pCluster, sortedHits);

    HitArray hitArray; // hits organised by drift volume
    HitList isolatedHits;

    for (const pandora::CaloHit* const pCaloHit2D : sortedHits) {
      CaloHitToArtHitMap::const_iterator it(pandoraHitToArtHitMap.find(pCaloHit2D));
      if (it == pandoraHitToArtHitMap.end())
        throw cet::exception("LArPandora")
          << " LArPandoraOutput::BuildClusters --- couldn't find art hit for input pandora hit ";

      const art::Ptr<recob::Hit> hit(it->second);

      const geo::WireID wireID(hit->WireID());
      const unsigned int volID(100000 * wireID.Cryostat + wireID.TPC);
      hitArray[volID].push_back(hit);

      if (pCaloHit2D->IsIsolated()) isolatedHits.insert(hit);
    }

    if (hitArray.empty())
      throw cet::exception("LArPandora")
        << " LArPandoraOutput::BuildClusters --- found a cluster with no hits ";

    for (const HitArray::value_type& hitArrayEntry : hitArray) {
      const HitVector& clusterHits(hitArrayEntry.second);

      clusters.push_back(
        LArPandoraOutput::BuildCluster(gser, nextId, clusterHits, isolatedHits, algo));
      hitVectors.push_back(clusterHits);
      pandoraClusterToArtClustersMap.at(clusterId).push_back(nextId);

      nextId++;
    }

    return clusters;
  }

unsigned int lar_pandora::LArPandoraOutput::BuildDummySlice ( SliceCollection &  outputSlices )

static

Build a new slice object with dummy information.

Parameters

outputSlices

the output collection of slices to populate

Definition at line 851 of file LArPandoraOutput.cxx.

  {
    // Make a slice with dummy properties
    const float bogusFloat(std::numeric_limits<float>::max());
    const recob::tracking::Point_t bogusPoint(bogusFloat, bogusFloat, bogusFloat);
    const recob::tracking::Vector_t bogusVector(bogusFloat, bogusFloat, bogusFloat);

    const unsigned int sliceIndex(outputSlices->size());
    outputSlices->emplace_back(
      sliceIndex, bogusPoint, bogusVector, bogusPoint, bogusPoint, bogusFloat, bogusFloat);

    return sliceIndex;
  }

void lar_pandora::LArPandoraOutput::BuildParticleMetadata ( const art::Event &  event, const std::string &  instanceLabel, const pandora::PfoVector &  pfoVector, PFParticleMetadataCollection &  outputParticleMetadata, PFParticleToMetadataCollection &  outputParticlesToMetadata  )

static

Build metadata objects from a list of input pfos.

Parameters

event	the art event
pfoVector	the input list of pfos
outputParticleMetadata	the output vector of PFParticleMetadata
outputParticlesToMetadata	the output associations between PFParticles and metadata

Definition at line 747 of file LArPandoraOutput.cxx.

  {
    for (unsigned int pfoId = 0; pfoId < pfoVector.size(); ++pfoId) {
      const pandora::ParticleFlowObject* const pPfo(pfoVector.at(pfoId));

      LArPandoraOutput::AddAssociation(event,
                                       instanceLabel,
                                       pfoId,
                                       outputParticleMetadata->size(),
                                       outputParticlesToMetadata);
      larpandoraobj::PFParticleMetadata pPFParticleMetadata(
        LArPandoraHelper::GetPFParticleMetadata(pPfo));
      outputParticleMetadata->push_back(pPFParticleMetadata);
    }
  }

recob::PFParticle lar_pandora::LArPandoraOutput::BuildPFParticle ( const pandora::ParticleFlowObject *const  pPfo, const size_t  pfoId, const pandora::PfoVector &  pfoVector  )

static

Convert from a pfo to and ART PFParticle.

Parameters

pPfo	the input pfo to convert
pfoId	the id of the pfo to produce
pfoVector	the input list of pfos
the	ART PFParticle

Definition at line 959 of file LArPandoraOutput.cxx.

  {
    // Get parent Pfo ID
    const pandora::PfoList& parentList(pPfo->GetParentPfoList());
    if (parentList.size() > 1)
      throw cet::exception("LArPandora")
        << " LArPandoraOutput::BuildPFParticle --- this pfo has multiple parent particles ";

    const size_t parentId(parentList.empty() ?
                            recob::PFParticle::kPFParticlePrimary :
                            LArPandoraOutput::GetId(parentList.front(), pfoVector));

    // Get daughters Pfo IDs
    std::vector<size_t> daughterIds;
    for (const pandora::ParticleFlowObject* const pDaughterPfo : pPfo->GetDaughterPfoList())
      daughterIds.push_back(LArPandoraOutput::GetId(pDaughterPfo, pfoVector));

    std::sort(daughterIds.begin(), daughterIds.end());

    return recob::PFParticle(pPfo->GetParticleId(), pfoId, parentId, daughterIds);
  }

void lar_pandora::LArPandoraOutput::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

Convert between pfos and PFParticles and add them to the output vector Create the associations between PFParticle and vertices, spacepoints and clusters.

Parameters

event	the art event
pfoVector	the input list of pfos to convert
pfoToVerticesMap	the input mapping from pfo ID to vertex IDs
pfoToThreeDHitsMap	the input mapping from pfo ID to 3D hit IDs
pfoToArtClustersMap	the input mapping from pfo ID to ART cluster IDs
outputParticle	the output vector of PFParticles
outputParticlesToVertices	the output associations between PFParticles and vertices
outputParticlesToSpacePoints	the output associations between PFParticles and spacepoints
outputParticlesToClusters	the output associations between PFParticles and clusters

Definition at line 696 of file LArPandoraOutput.cxx.

  {
    for (unsigned int pfoId = 0; pfoId < pfoVector.size(); ++pfoId) {
      const pandora::ParticleFlowObject* const pPfo(pfoVector.at(pfoId));

      outputParticles->push_back(LArPandoraOutput::BuildPFParticle(pPfo, pfoId, pfoVector));

      // Associations from PFParticle
      if (pfoToVerticesMap.find(pfoId) != pfoToVerticesMap.end())
        LArPandoraOutput::AddAssociation(
          event, instanceLabel, pfoId, pfoToVerticesMap, outputParticlesToVertices);

      if (pfoToThreeDHitsMap.find(pfoId) != pfoToThreeDHitsMap.end())
        LArPandoraOutput::AddAssociation(
          event, instanceLabel, pfoId, pfoToThreeDHitsMap, outputParticlesToSpacePoints);

      if (pfoToArtClustersMap.find(pfoId) != pfoToArtClustersMap.end())
        LArPandoraOutput::AddAssociation(
          event, instanceLabel, pfoId, pfoToArtClustersMap, outputParticlesToClusters);
    }
  }

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

static

Build a new slice object from a PFO, this can be a top-level parent in a hierarchy or a "slice PFO" from the slicing instance.

Parameters

pParentPfo	the parent pfo from which to build the slice
event	the art event
instanceLabel	the label for the collections to be produced
idToHitMap	input mapping from pandora hit ID to ART hit
outputSlices	the output collection of slices to populate
outputSlicesToHits	the output association from slices to hits

Definition at line 899 of file LArPandoraOutput.cxx.

  {
    const unsigned int sliceIndex(LArPandoraOutput::BuildDummySlice(outputSlices));

    // Collect the pfos connected to the input primary pfos
    pandora::PfoList pfosInSlice;
    lar_content::LArPfoHelper::GetAllConnectedPfos(pParentPfo, pfosInSlice);
    pfosInSlice.sort(lar_content::LArPfoHelper::SortByNHits);

    // Collect the hits from the pfos in all views
    pandora::CaloHitList hits;
    for (const pandora::ParticleFlowObject* const pPfo : pfosInSlice) {
      for (const pandora::HitType& hitType :
           {pandora::TPC_VIEW_U, pandora::TPC_VIEW_V, pandora::TPC_VIEW_W}) {
        lar_content::LArPfoHelper::GetCaloHits(pPfo, hitType, hits);
        lar_content::LArPfoHelper::GetIsolatedCaloHits(pPfo, hitType, hits);
      }
    }

    // Add the associations to the hits
    for (const pandora::CaloHit* const pCaloHit : hits)
      LArPandoraOutput::AddAssociation(event,
                                       instanceLabel,
                                       sliceIndex,
                                       {LArPandoraOutput::GetHit(idToHitMap, pCaloHit)},
                                       outputSlicesToHits);

    return sliceIndex;
  }

void lar_pandora::LArPandoraOutput::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

Build slices - collections of hits which each describe a single particle hierarchy.

Parameters

settings	the settings
pPrimaryPandora	the primary pandora instance
event	the art event
instanceLabel	the label for the collections to be produced
pfoVector	the input vector of all pfos to be output
idToHitMap	input mapping from pandora hit ID to ART hit
outputSlices	the output collection of slices to populate
outputParticlesToSlices	the output association from particles to slices
outputSlicesToHits	the output association from slices to hits

Definition at line 770 of file LArPandoraOutput.cxx.

  {
    // Check for the special case in which there are no slices, and only the neutrino reconstruction was used on all hits
    if (settings.m_isNeutrinoRecoOnlyNoSlicing) {
      LArPandoraOutput::CopyAllHitsToSingleSlice(settings,
                                                 event,
                                                 instanceLabel,
                                                 pfoVector,
                                                 idToHitMap,
                                                 outputSlices,
                                                 outputParticlesToSlices,
                                                 outputSlicesToHits);
      return;
    }

    // Collect the slice pfos - one per slice (if there is no slicing instance, this vector will be empty)
    pandora::PfoVector slicePfos;
    LArPandoraOutput::GetPandoraSlices(pPrimaryPandora, slicePfos);

    // Make one slice per Pandora Slice pfo
    for (const pandora::ParticleFlowObject* const pSlicePfo : slicePfos)
      LArPandoraOutput::BuildSlice(
        pSlicePfo, event, instanceLabel, idToHitMap, outputSlices, outputSlicesToHits);

    // Make a slice for every remaining pfo hierarchy that wasn't already in a slice
    std::unordered_map<const pandora::ParticleFlowObject*, unsigned int> parentPfoToSliceIndexMap;
    for (unsigned int pfoId = 0; pfoId < pfoVector.size(); ++pfoId) {
      const pandora::ParticleFlowObject* const pPfo(pfoVector.at(pfoId));

      // If this PFO is the parent of a hierarchy we have yet to use, then add a new slice
      if (LArPandoraOutput::IsFromSlice(pPfo)) continue;

      if (lar_content::LArPfoHelper::GetParentPfo(pPfo) != pPfo) continue;

      if (!parentPfoToSliceIndexMap
             .emplace(pPfo,
                      LArPandoraOutput::BuildSlice(
                        pPfo, event, instanceLabel, idToHitMap, outputSlices, outputSlicesToHits))
             .second)
        throw cet::exception("LArPandora")
          << " LArPandoraOutput::BuildSlices --- found repeated primary particles ";
    }

    // Add the associations from PFOs to slices
    for (unsigned int pfoId = 0; pfoId < pfoVector.size(); ++pfoId) {
      const pandora::ParticleFlowObject* const pPfo(pfoVector.at(pfoId));

      // For PFOs that are from a Pandora slice, add the association and move on to the next PFO
      if (LArPandoraOutput::IsFromSlice(pPfo)) {
        LArPandoraOutput::AddAssociation(event,
                                         instanceLabel,
                                         pfoId,
                                         LArPandoraOutput::GetSliceIndex(pPfo),
                                         outputParticlesToSlices);
        continue;
      }

      // Get the parent of the particle
      const pandora::ParticleFlowObject* const pParent(
        lar_content::LArPfoHelper::GetParentPfo(pPfo));
      if (parentPfoToSliceIndexMap.find(pParent) == parentPfoToSliceIndexMap.end())
        throw cet::exception("LArPandora")
          << " LArPandoraOutput::BuildSlices --- found pfo without a parent in the input list ";

      // Add the association from the PFO to the slice
      LArPandoraOutput::AddAssociation(
        event, instanceLabel, pfoId, parentPfoToSliceIndexMap.at(pParent), outputParticlesToSlices);
    }
  }

recob::SpacePoint lar_pandora::LArPandoraOutput::BuildSpacePoint ( const pandora::CaloHit *const  pCaloHit, const size_t  spacePointId  )

static

Convert from a pandora 3D hit to an ART spacepoint.

Parameters

pCaloHit	the input hit
spacePointId	the id of the space-point to produce
the	ART spacepoint

Definition at line 1160 of file LArPandoraOutput.cxx.

  {
    if (pandora::TPC_3D != pCaloHit->GetHitType())
      throw cet::exception("LArPandora")
        << " LArPandoraOutput::BuildSpacePoint --- trying to build a space point from a 2D hit";

    const pandora::CartesianVector point(pCaloHit->GetPositionVector());
    double xyz[3] = {point.GetX(), point.GetY(), point.GetZ()};

    // ATTN using dummy information
    double dxdydz[6] = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0}; // TODO: Fill in the error matrix
    double chi2(0.0);

    return recob::SpacePoint(xyz, dxdydz, chi2, spacePointId);
  }

void lar_pandora::LArPandoraOutput::BuildSpacePoints ( const art::Event &  event, const std::string &  instanceLabel, const pandora::CaloHitList &  threeDHitList, const CaloHitToArtHitMap &  pandoraHitToArtHitMap, SpacePointCollection &  outputSpacePoints, SpacePointToHitCollection &  outputSpacePointsToHits  )

static

Convert pandora 3D hits to ART spacepoints and add them to the output vector Create the associations between spacepoints and hits.

Parameters

event	the art event
threeDHitList	the input list of 3D hits to convert
pandoraHitToArtHitMap	the input mapping from pandora hits to ART hits
outputSpacePoints	the output vector of spacepoints
outputSpacePointsToHits	the output associations between spacepoints and hits

Definition at line 601 of file LArPandoraOutput.cxx.

  {
    pandora::CaloHitVector threeDHitVector;
    threeDHitVector.insert(threeDHitVector.end(), threeDHitList.begin(), threeDHitList.end());

    for (unsigned int hitId = 0; hitId < threeDHitVector.size(); hitId++) {
      const pandora::CaloHit* const pCaloHit(threeDHitVector.at(hitId));

      CaloHitToArtHitMap::const_iterator it(pandoraHitToArtHitMap.find(pCaloHit));
      if (it == pandoraHitToArtHitMap.end())
        throw cet::exception("LArPandora") << " LArPandoraOutput::BuildSpacePoints --- found a "
                                              "pandora hit without a corresponding art hit ";

      LArPandoraOutput::AddAssociation(
        event, instanceLabel, hitId, {it->second}, outputSpacePointsToHits);
      outputSpacePoints->push_back(LArPandoraOutput::BuildSpacePoint(pCaloHit, hitId));
    }
  }

bool lar_pandora::LArPandoraOutput::BuildT0 ( const art::Event &  event, const pandora::ParticleFlowObject *const  pPfo, const pandora::PfoVector &  pfoVector, size_t &  nextId, anab::T0 &  t0  )

static

If required, build a T0 for the input pfo.

Parameters

event	the ART event
pPfo	the input pfo
pfoVector	the input list of pfos
nextId	the ID of the T0 - will be incremented if the t0 was produced
t0	the output T0

Returns

if a T0 was produced (calculated from the stitching hit shift distance)

Definition at line 1180 of file LArPandoraOutput.cxx.

  {
    const pandora::ParticleFlowObject* const pParent(lar_content::LArPfoHelper::GetParentPfo(pPfo));
    const float x0(pParent->GetPropertiesMap().count("X0") ? pParent->GetPropertiesMap().at("X0") :
                                                             0.f);

    auto const clock_data = art::ServiceHandle<detinfo::DetectorClocksService const>()->DataFor(e);
    auto const det_prop =
      art::ServiceHandle<detinfo::DetectorPropertiesService const>()->DataFor(e, clock_data);
    const double cm_per_tick(det_prop.GetXTicksCoefficient());
    const double ns_per_tick(sampling_rate(clock_data));

    // ATTN: T0 values are currently calculated in nanoseconds relative to the trigger offset. Only non-zero values are outputted.
    const double T0(x0 * ns_per_tick / cm_per_tick);

    if (std::fabs(T0) <= std::numeric_limits<double>::epsilon()) return false;

    // Output T0 objects [arguments are:  time (nanoseconds);  trigger type (3 for TPC stitching!);  pfparticle SelfID code;  T0 ID code]
    t0 = anab::T0(T0, 3, LArPandoraOutput::GetId(pPfo, pfoVector), nextId++);

    return true;
  }

void lar_pandora::LArPandoraOutput::BuildT0s ( const art::Event &  event, const std::string &  instanceLabel, const pandora::PfoVector &  pfoVector, T0Collection &  outputT0s, PFParticleToT0Collection &  outputParticlesToT0s  )

static

Calculate the T0 of each pfos and add them to the output vector Create the associations between PFParticle and T0s.

Parameters

event	the art event
instanceLabel	the label for the collections to be produced
pfoVector	the input list of pfos
outputT0s	the output vector of T0s
outputParticlesToT0s	the output associations between PFParticles and T0s

Definition at line 937 of file LArPandoraOutput.cxx.

  {
    size_t nextT0Id(0);
    for (unsigned int pfoId = 0; pfoId < pfoVector.size(); ++pfoId) {
      const pandora::ParticleFlowObject* const pPfo(pfoVector.at(pfoId));

      anab::T0 t0;
      if (!LArPandoraOutput::BuildT0(event, pPfo, pfoVector, nextT0Id, t0)) continue;

      LArPandoraOutput::AddAssociation(
        event, instanceLabel, pfoId, nextT0Id - 1, outputParticlesToT0s);
      outputT0s->push_back(t0);
    }
  }

recob::Vertex lar_pandora::LArPandoraOutput::BuildVertex ( const pandora::Vertex *const  pVertex, const size_t  vertexId  )

static

Convert from a pandora vertex to an ART vertex.

Parameters

pVertex	the input vertex
vertexId	the id of the vertex to produce
the	ART vertex

Definition at line 986 of file LArPandoraOutput.cxx.

  {
    double pos[3] = {
      pVertex->GetPosition().GetX(), pVertex->GetPosition().GetY(), pVertex->GetPosition().GetZ()};
    return recob::Vertex(pos, vertexId);
  }

void lar_pandora::LArPandoraOutput::BuildVertices ( const pandora::VertexVector &  vertexVector, VertexCollection &  outputVertices  )

static

Convert pandora vertices to ART vertices and add them to the output vector.

Parameters

vertexVector	the input list of pandora vertices
outputVertices	the output vector of ART vertices

Definition at line 591 of file LArPandoraOutput.cxx.

  {
    for (size_t vertexId = 0; vertexId < vertexVector.size(); ++vertexId)
      outputVertices->push_back(LArPandoraOutput::BuildVertex(vertexVector.at(vertexId), vertexId));
  }

void lar_pandora::LArPandoraOutput::Collect3DHits ( const pandora::ParticleFlowObject *const  pPfo, pandora::CaloHitVector &  caloHits  )

static

Collect a sorted vector of all 3D hits in the input pfo.

Parameters

pPfo	the input pfo
caloHits	the sorted output vector of 3D hits

Definition at line 501 of file LArPandoraOutput.cxx.

  {
    // Get the sorted list of 3D hits associated with the pfo
    pandora::CaloHitList threeDHits;
    lar_content::LArPfoHelper::GetCaloHits(pPfo, pandora::TPC_3D, threeDHits);

    caloHits.insert(caloHits.end(), threeDHits.begin(), threeDHits.end());
    std::sort(caloHits.begin(), caloHits.end(), lar_content::LArClusterHelper::SortHitsByPosition);
  }

pandora::CaloHitList lar_pandora::LArPandoraOutput::Collect3DHits ( const pandora::PfoVector &  pfoVector, IdToIdVectorMap &  pfoToThreeDHitsMap  )

static

Collect a sorted list of all 3D hits contained in the input pfo list Order is guaranteed provided pfoVector is ordered.

Parameters

pfoVector	the input list of pfos
pfoToThreeDHitsMap	the output mapping from pfo ID to 3D hit IDs

Returns

the list of 3D hits collected

Definition at line 468 of file LArPandoraOutput.cxx.

  {
    pandora::CaloHitList caloHitList;

    for (unsigned int pfoId = 0; pfoId < pfoVector.size(); ++pfoId) {
      const pandora::ParticleFlowObject* const pPfo(pfoVector.at(pfoId));

      if (!pfoToThreeDHitsMap.insert(IdToIdVectorMap::value_type(pfoId, {})).second)
        throw cet::exception("LArPandora")
          << " LArPandoraOutput::Collect3DHits --- repeated pfos in input list ";

      pandora::CaloHitVector sorted3DHits;
      LArPandoraOutput::Collect3DHits(pPfo, sorted3DHits);

      for (const pandora::CaloHit* const pCaloHit3D : sorted3DHits) {
        if (pandora::TPC_3D !=
            pCaloHit3D
              ->GetHitType()) // TODO decide if this is required, or should I just insert them?
          throw cet::exception("LArPandora")
            << " LArPandoraOutput::Collect3DHits --- found a 2D hit in a 3D cluster";

        pfoToThreeDHitsMap.at(pfoId).push_back(caloHitList.size());
        caloHitList.push_back(pCaloHit3D);
      }
    }

    return caloHitList;
  }

pandora::PfoVector lar_pandora::LArPandoraOutput::CollectAllPfoOutcomes ( const pandora::Pandora *const  pPrimaryPandora )

static

Collect the pfos (including all downstream pfos) from the master and daughter pandora instances.

Parameters

pPrimaryPandora

address of master pandora instance

Returns

a sorted list of all pfos to convert to ART PFParticles

Definition at line 269 of file LArPandoraOutput.cxx.

  {
    pandora::PfoList collectedPfos;

    // Get the list of slice pfos - one per slice
    pandora::PfoVector slicePfos;
    LArPandoraOutput::GetPandoraSlices(pPrimaryPandora, slicePfos);

    // Identify the pandora worker instances by their name
    const pandora::Pandora* pSliceNuWorker(nullptr);
    if (!LArPandoraOutput::GetPandoraInstance(pPrimaryPandora, "SliceNuWorker", pSliceNuWorker))
      throw cet::exception("LArPandora")
        << " LArPandoraOutput::CollectAllPfoOutcomes--- Can't find slice nu worker instance. ";

    const pandora::Pandora* pSliceCRWorker(nullptr);
    if (!LArPandoraOutput::GetPandoraInstance(pPrimaryPandora, "SliceCRWorker", pSliceCRWorker))
      throw cet::exception("LArPandora")
        << " LArPandoraOutput::CollectAllPfoOutcomes--- Can't find slice CR worker instance. ";

    // Collect slices under both reconstruction hypotheses
    for (unsigned int sliceIndex = 0; sliceIndex < slicePfos.size(); ++sliceIndex) {
      const pandora::PfoList* pNuPfoList(nullptr);
      if (pandora::STATUS_CODE_SUCCESS ==
          PandoraApi::GetPfoList(
            *pSliceNuWorker, "NeutrinoParticles3D" + std::to_string(sliceIndex), pNuPfoList))
        collectedPfos.insert(collectedPfos.end(), pNuPfoList->begin(), pNuPfoList->end());

      const pandora::PfoList* pCRPfoList(nullptr);
      if (pandora::STATUS_CODE_SUCCESS ==
          PandoraApi::GetPfoList(
            *pSliceCRWorker, "MuonParticles3D" + std::to_string(sliceIndex), pCRPfoList))
        collectedPfos.insert(collectedPfos.end(), pCRPfoList->begin(), pCRPfoList->end());
    }

    // Get the list of the parent pfos from the primary pandora instance
    const pandora::PfoList* pParentPfoList(nullptr);
    PANDORA_THROW_RESULT_IF(pandora::STATUS_CODE_SUCCESS,
                            !=,
                            PandoraApi::GetCurrentPfoList(*pPrimaryPandora, pParentPfoList));

    // Collect clear cosmic-rays
    for (const pandora::ParticleFlowObject* const pPfo : *pParentPfoList) {
      if (LArPandoraOutput::IsClearCosmic(pPfo)) collectedPfos.push_back(pPfo);
    }

    // Collect all pfos that are downstream of the parents we have collected
    pandora::PfoVector pfoVector;
    LArPandoraOutput::CollectPfos(collectedPfos, pfoVector);

    return pfoVector;
  }

pandora::ClusterList lar_pandora::LArPandoraOutput::CollectClusters ( const pandora::PfoVector &  pfoVector, IdToIdVectorMap &  pfoToClustersMap  )

static

Collect a sorted list of all 2D clusters contained in the input pfo list Order is guaranteed provided pfoVector is ordered.

Parameters

pfoVector	the input list of pfos
pfoToClustersMap	the output mapping from pfo ID to cluster IDs

Returns

the list of clusters collected

Definition at line 438 of file LArPandoraOutput.cxx.

  {
    pandora::ClusterList clusterList;

    for (unsigned int pfoId = 0; pfoId < pfoVector.size(); ++pfoId) {
      const pandora::ParticleFlowObject* const pPfo(pfoVector.at(pfoId));

      // Get the sorted list of clusters from the pfo
      pandora::ClusterList clusters;
      lar_content::LArPfoHelper::GetTwoDClusterList(pPfo, clusters);
      clusters.sort(lar_content::LArClusterHelper::SortByNHits);

      // Get incrementing id's for each cluster
      IdVector clusterIds(clusters.size());
      std::iota(clusterIds.begin(), clusterIds.end(), clusterList.size());

      clusterList.insert(clusterList.end(), clusters.begin(), clusters.end());

      if (!pfoToClustersMap.insert(IdToIdVectorMap::value_type(pfoId, clusterIds)).second)
        throw cet::exception("LArPandora")
          << " LArPandoraOutput::CollectClusters --- repeated pfos in input list ";
    }

    return clusterList;
  }

pandora::PfoVector lar_pandora::LArPandoraOutput::CollectPfos ( const pandora::Pandora *const  pPrimaryPandora )

static

Collect the current pfos (including all downstream pfos) from the master pandora instance.

Parameters

pPrimaryPandora

address of master pandora instance

Returns

a sorted list of all pfos to convert to ART PFParticles

Definition at line 367 of file LArPandoraOutput.cxx.

  {
    const pandora::PfoList* pParentPfoList(nullptr);
    PANDORA_THROW_RESULT_IF(pandora::STATUS_CODE_SUCCESS,
                            !=,
                            PandoraApi::GetCurrentPfoList(*pPrimaryPandora, pParentPfoList));

    pandora::PfoVector pfoVector;
    LArPandoraOutput::CollectPfos(*pParentPfoList, pfoVector);

    return pfoVector;
  }

void lar_pandora::LArPandoraOutput::CollectPfos ( const pandora::PfoList &  parentPfoList, pandora::PfoVector &  pfoVector  )

static

Collect a sorted list of all downstream pfos of an input list of parent.

Parameters

parentPfoList	the input list of parent pfos
pfoVector	the sorted output list of all downstream pfos

Definition at line 383 of file LArPandoraOutput.cxx.

  {
    if (!pfoVector.empty())
      throw cet::exception("LArPandora")
        << " LArPandoraOutput::CollectPfos--- trying to collect pfos into a non-empty list ";

    pandora::PfoList pfoList;
    lar_content::LArPfoHelper::GetAllConnectedPfos(parentPfoList, pfoList);

    pfoVector.insert(pfoVector.end(), pfoList.begin(), pfoList.end());
    std::sort(pfoVector.begin(), pfoVector.end(), lar_content::LArPfoHelper::SortByNHits);
  }

pandora::VertexVector lar_pandora::LArPandoraOutput::CollectVertices ( const pandora::PfoVector &  pfoVector, IdToIdVectorMap &  pfoToVerticesMap, std::function< const pandora::Vertex *const (const pandora::ParticleFlowObject *const)>  fCriteria  )

static

Collect all vertices contained in the input pfo list Order is guaranteed provided pfoVector is ordered.

Parameters

pfoVector	the input list of pfos
pfoToVerticesMap	the output mapping from pfo ID to vertex IDs (zero or one)
fCriteria	function to extract vertex from pfo

Returns

the list of vertices collected

Definition at line 400 of file LArPandoraOutput.cxx.

  {
    pandora::VertexVector vertexVector;

    for (unsigned int pfoId = 0; pfoId < pfoVector.size(); ++pfoId) {
      const pandora::ParticleFlowObject* const pPfo(pfoVector.at(pfoId));

      if (pPfo->GetVertexList().empty()) continue;

      try {
        const pandora::Vertex* const pVertex(fCriteria(pPfo));

        // Get the vertex ID and add it to the vertex list if required
        const auto it(std::find(vertexVector.begin(), vertexVector.end(), pVertex));
        const bool isInList(it != vertexVector.end());
        const size_t vertexId(isInList ? std::distance(vertexVector.begin(), it) :
                                         vertexVector.size());

        if (!isInList) vertexVector.push_back(pVertex);

        if (!pfoToVerticesMap.insert(IdToIdVectorMap::value_type(pfoId, {vertexId})).second)
          throw cet::exception("LArPandora")
            << " LArPandoraOutput::CollectVertices --- repeated pfos in input list ";
      }
      catch (const pandora::StatusCodeException&) {
        continue;
      }
    }

    return vertexVector;
  }

void lar_pandora::LArPandoraOutput::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

Ouput a single slice containing all of the input hits.

Parameters

settings	the settings
event	the art event
instanceLabel	the label for the collections to be produced
pfoVector	the input vector of all pfos to be output
idToHitMap	input mapping from pandora hit ID to ART hit
outputSlices	the output collection of slices to populate
outputParticlesToSlices	the output association from particles to slices
outputSlicesToHits	the output association from slices to hits

Definition at line 868 of file LArPandoraOutput.cxx.

  {
    const unsigned int sliceIndex(LArPandoraOutput::BuildDummySlice(outputSlices));

    // Add all of the hits in the events to the slice
    HitVector hits;
    LArPandoraHelper::CollectHits(event, settings.m_hitfinderModuleLabel, hits);
    LArPandoraOutput::AddAssociation(event, instanceLabel, sliceIndex, hits, outputSlicesToHits);

    mf::LogDebug("LArPandora") << "Finding hits with label: " << settings.m_hitfinderModuleLabel
                               << std::endl;
    mf::LogDebug("LArPandora") << " - Found " << hits.size() << std::endl;
    mf::LogDebug("LArPandora") << " - Making associations " << outputSlicesToHits->size()
                               << std::endl;

    // Add all of the PFOs to the slice
    for (unsigned int pfoId = 0; pfoId < pfoVector.size(); ++pfoId)
      LArPandoraOutput::AddAssociation(
        event, instanceLabel, pfoId, sliceIndex, outputParticlesToSlices);
  }

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

static

Look up ART hit from an input Pandora hit.

Parameters

idToHitMap	the mapping between Pandora and ART hits
pCaloHit	the input Pandora hit (2D)

Definition at line 559 of file LArPandoraOutput.cxx.

  {
    //  TODO make this less evil

    // ATTN The CaloHit can come from the primary pandora instance (depth = 0) or one of its daughers (depth = 1).
    //      Here we keep trying to access the ART hit increasing the depth step-by-step
    for (unsigned int depth = 0, maxDepth = 2; depth < maxDepth; ++depth) {
      // Navigate to the hit address in the pandora master instance (assuming the depth is correct)
      const pandora::CaloHit* pParentCaloHit = pCaloHit;
      for (unsigned int i = 0; i < depth; ++i)
        pParentCaloHit = static_cast<const pandora::CaloHit*>(pCaloHit->GetParentAddress());

      // Attempt to find the mapping from the "parent" calo hit to the ART hit
      const void* const pHitAddress(pParentCaloHit->GetParentAddress());
      const intptr_t hitID_temp((intptr_t)(pHitAddress));
      const int hitID((int)(hitID_temp));

      IdToHitMap::const_iterator artIter = idToHitMap.find(hitID);

      // If there is no such mapping from "parent" calo hit to the ART hit, then increase the depth and try again!
      if (idToHitMap.end() == artIter) continue;

      return artIter->second;
    }

    throw cet::exception("LArPandora")
      << " LArPandoraOutput::GetHit --- found a Pandora hit without a parent ART hit ";
  }

void lar_pandora::LArPandoraOutput::GetHitsInCluster ( const pandora::Cluster *const  pCluster, pandora::CaloHitVector &  sortedHits  )

static

Collect a sorted list of all 2D hits in a cluster.

Parameters

pCluster	the input cluster
sortedHits	the output vector of sorted 2D hits

Definition at line 996 of file LArPandoraOutput.cxx.

  {
    if (!sortedHits.empty())
      throw cet::exception("LArPandora")
        << " LArPandoraOutput::GetHitsInCluster --- vector to hold hits is not empty ";

    pandora::CaloHitList hitList;
    pCluster->GetOrderedCaloHitList().FillCaloHitList(hitList);
    hitList.insert(hitList.end(),
                   pCluster->GetIsolatedCaloHitList().begin(),
                   pCluster->GetIsolatedCaloHitList().end());

    sortedHits.insert(sortedHits.end(), hitList.begin(), hitList.end());
    std::sort(
      sortedHits.begin(), sortedHits.end(), lar_content::LArClusterHelper::SortHitsByPosition);
  }

template<typename T >

size_t lar_pandora::LArPandoraOutput::GetId ( const T *const  pT, const std::list< const T * > &  tList  )

inlinestatic

Find the index of an input object in an input list. Throw an exception if it doesn't exist.

Parameters

pT	the input object for which the ID should be found
tList	a list of objects of type pT to query

Returns

the ID of the input object

Definition at line 623 of file LArPandoraOutput.h.

  {
    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 >

size_t lar_pandora::LArPandoraOutput::GetId ( const T *const  pT, const std::vector< const T * > &  tVector  )

inlinestatic

Find the index of an input object in an input vector. Throw an exception if it doesn't exist.

Parameters

pT	the input object for which the ID should be found
tVector	a list of objects of type pT to query

Returns

the ID of the input object

Definition at line 638 of file LArPandoraOutput.h.

  {
    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));
  }

bool lar_pandora::LArPandoraOutput::GetPandoraInstance ( const pandora::Pandora *const  pPrimaryPandora, const std::string &  name, const pandora::Pandora *&  pPandoraInstance  )

static

Get the address of a pandora instance with a given name.

Parameters

pPrimaryPandora	the primary pandora instance
name	the name of the instance to collect
pPandoraInstance	the output address of the pandora instance requested

Returns

if the pandora instance could be found

Definition at line 215 of file LArPandoraOutput.cxx.

  {
    if (!pPrimaryPandora)
      throw cet::exception("LArPandora") << " LArPandoraOutput::GetPandoraInstance--- input "
                                            "primary pandora instance address is invalid ";

    if (pPandoraInstance)
      throw cet::exception("LArPandora") << " LArPandoraOutput::GetPandoraInstance--- the input "
                                            "pandora instance address is non-null ";

    for (const pandora::Pandora* const pPandora :
         MultiPandoraApi::GetDaughterPandoraInstanceList(pPrimaryPandora)) {
      if (pPandora->GetName() != name) continue;

      if (pPandoraInstance)
        throw cet::exception("LArPandora")
          << " LArPandoraOutput::GetPandoraInstance--- found multiple pandora instances with name: "
          << name;

      pPandoraInstance = pPandora;
    }

    return static_cast<bool>(pPandoraInstance);
  }

void lar_pandora::LArPandoraOutput::GetPandoraSlices ( const pandora::Pandora *const  pPrimaryPandora, pandora::PfoVector &  slicePfos  )

static

Get the slice pfos - one pfo per slice.

Parameters

pPrimaryPandora	the primary pandora instance
slicePfos	the output vector of slice pfos

Definition at line 245 of file LArPandoraOutput.cxx.

  {
    if (!slicePfos.empty())
      throw cet::exception("LArPandora")
        << " LArPandoraOutput::GetPandoraSlices--- Input slicePfo vector is not empty ";

    // Get the pandora slicing worker - if it exists
    const pandora::Pandora* pSlicingWorker(nullptr);
    if (!LArPandoraOutput::GetPandoraInstance(pPrimaryPandora, "SlicingWorker", pSlicingWorker))
      return;

    // Get the slice PFOs - one PFO per slice
    const pandora::PfoList* pSlicePfoList(nullptr);
    PANDORA_THROW_RESULT_IF(pandora::STATUS_CODE_SUCCESS,
                            !=,
                            PandoraApi::GetCurrentPfoList(*pSlicingWorker, pSlicePfoList));

    slicePfos.insert(slicePfos.end(), pSlicePfoList->begin(), pSlicePfoList->end());
  }

void lar_pandora::LArPandoraOutput::GetPandoraToArtHitMap ( const pandora::ClusterList &  clusterList, const pandora::CaloHitList &  threeDHitList, const IdToHitMap &  idToHitMap, CaloHitToArtHitMap &  pandoraHitToArtHitMap  )

static

Collect all 2D and 3D hits that were used / produced in the reconstruction and map them to their corresponding ART hit.

Parameters

clusterList	input list of all 2D clusters to be output
threeDHitList	input list of all 3D hits to be output (as spacepoints)
idToHitMap	input mapping from pandora hit ID to ART hit
pandoraHitToArtHitMap	output mapping from pandora hit to ART hit

Definition at line 515 of file LArPandoraOutput.cxx.

  {
    // Collect 2D hits from clusters
    for (const pandora::Cluster* const pCluster : clusterList) {
      if (pandora::TPC_3D == lar_content::LArClusterHelper::GetClusterHitType(pCluster))
        throw cet::exception("LArPandora")
          << " LArPandoraOutput::GetPandoraToArtHitMap --- found a 3D input cluster ";

      pandora::CaloHitVector sortedHits;
      LArPandoraOutput::GetHitsInCluster(pCluster, sortedHits);

      for (const pandora::CaloHit* const pCaloHit : sortedHits) {
        if (!pandoraHitToArtHitMap
               .insert(CaloHitToArtHitMap::value_type(
                 pCaloHit, LArPandoraOutput::GetHit(idToHitMap, pCaloHit)))
               .second)
          throw cet::exception("LArPandora")
            << " LArPandoraOutput::GetPandoraToArtHitMap --- found repeated input hits ";
      }
    }

    for (const pandora::CaloHit* const pCaloHit : threeDHitList) {
      if (pCaloHit->GetHitType() != pandora::TPC_3D)
        throw cet::exception("LArPandora")
          << " LArPandoraOutput::GetPandoraToArtHitMap --- found a non-3D hit in the input list ";

      // ATTN get the 2D calo hit from the 3D calo hit then find the art hit!
      if (!pandoraHitToArtHitMap
             .insert(CaloHitToArtHitMap::value_type(
               pCaloHit,
               LArPandoraOutput::GetHit(
                 idToHitMap, static_cast<const pandora::CaloHit*>(pCaloHit->GetParentAddress()))))
             .second)
        throw cet::exception("LArPandora")
          << " LArPandoraOutput::GetPandoraToArtHitMap --- found repeated input hits ";
    }
  }

unsigned int lar_pandora::LArPandoraOutput::GetSliceIndex ( const pandora::ParticleFlowObject *const  pPfo )

static

Get the index of the slice from which this pfo was produced.

Parameters

pPfo	the input pfo

Returns

the slice index

Definition at line 350 of file LArPandoraOutput.cxx.

  {
    const pandora::ParticleFlowObject* const pParent(lar_content::LArPfoHelper::GetParentPfo(pPfo));

    const auto& properties(pParent->GetPropertiesMap());
    const auto it(properties.find("SliceIndex"));

    if (it == properties.end())
      throw cet::exception("LArPandora")
        << " LArPandoraOutput::GetSliceIndex--- Input PFO was not from a slice ";

    return static_cast<unsigned int>(std::round(it->second));
  }

bool lar_pandora::LArPandoraOutput::IsClearCosmic ( const pandora::ParticleFlowObject *const  pPfo )

static

Check if the input pfo is an unambiguous cosmic ray.

Parameters

pPfo	the input pfo

Returns

if the input pfo is a clear cosmic ray

Definition at line 324 of file LArPandoraOutput.cxx.

  {
    const pandora::ParticleFlowObject* const pParent(lar_content::LArPfoHelper::GetParentPfo(pPfo));

    const auto& properties(pParent->GetPropertiesMap());
    const auto it(properties.find("IsClearCosmic"));

    if (it == properties.end()) return false;

    return static_cast<bool>(std::round(it->second));
  }

bool lar_pandora::LArPandoraOutput::IsFromSlice ( const pandora::ParticleFlowObject *const  pPfo )

static

Check if the input pfo is from a slice.

Parameters

pPfo	the input pfo

Returns

if the input pfo is from a slice

Definition at line 339 of file LArPandoraOutput.cxx.

  {
    const pandora::ParticleFlowObject* const pParent(lar_content::LArPfoHelper::GetParentPfo(pPfo));

    const auto& properties(pParent->GetPropertiesMap());
    return (properties.find("SliceIndex") != properties.end());
  }

void lar_pandora::LArPandoraOutput::ProduceArtOutput ( const Settings &  settings, const IdToHitMap &  idToHitMap, art::Event &  evt  )

static

Convert the Pandora PFOs into ART clusters and write into ART event.

Parameters

settings	the settings
idToHitMap	the mapping from Pandora hit ID to ART hit
evt	the ART event

Definition at line 42 of file LArPandoraOutput.cxx.

  {
    settings.Validate();
    const std::string instanceLabel(
      settings.m_shouldProduceAllOutcomes ? settings.m_allOutcomesInstanceLabel : "");
    const std::string testBeamInteractionVertexInstanceLabel(
      instanceLabel + settings.m_testBeamInteractionVerticesInstanceLabel);

    // Set up mandatory output collections
    PFParticleCollection outputParticles(new std::vector<recob::PFParticle>);
    VertexCollection outputVertices(new std::vector<recob::Vertex>);
    ClusterCollection outputClusters(new std::vector<recob::Cluster>);
    SpacePointCollection outputSpacePoints(new std::vector<recob::SpacePoint>);
    PFParticleMetadataCollection outputParticleMetadata(
      new std::vector<larpandoraobj::PFParticleMetadata>);

    // Set up optional output collections
    VertexCollection outputTestBeamInteractionVertices(
      settings.m_shouldProduceTestBeamInteractionVertices ? new std::vector<recob::Vertex> :
                                                            nullptr);
    T0Collection outputT0s(settings.m_shouldRunStitching ? new std::vector<anab::T0> : nullptr);
    SliceCollection outputSlices(settings.m_shouldProduceSlices ? new std::vector<recob::Slice> :
                                                                  nullptr);

    // Set up mandatory output associations
    PFParticleToMetadataCollection outputParticlesToMetadata(
      new art::Assns<recob::PFParticle, larpandoraobj::PFParticleMetadata>);
    PFParticleToSpacePointCollection outputParticlesToSpacePoints(
      new art::Assns<recob::PFParticle, recob::SpacePoint>);
    PFParticleToClusterCollection outputParticlesToClusters(
      new art::Assns<recob::PFParticle, recob::Cluster>);
    PFParticleToVertexCollection outputParticlesToVertices(
      new art::Assns<recob::PFParticle, recob::Vertex>);
    ClusterToHitCollection outputClustersToHits(new art::Assns<recob::Cluster, recob::Hit>);
    SpacePointToHitCollection outputSpacePointsToHits(
      new art::Assns<recob::SpacePoint, recob::Hit>);
    SliceToHitCollection outputSlicesToHits(new art::Assns<recob::Slice, recob::Hit>);

    // Set up optional output associations
    PFParticleToVertexCollection outputParticlesToTestBeamInteractionVertices(
      settings.m_shouldProduceTestBeamInteractionVertices ?
        new art::Assns<recob::PFParticle, recob::Vertex> :
        nullptr);
    PFParticleToT0Collection outputParticlesToT0s(
      settings.m_shouldRunStitching ? new art::Assns<recob::PFParticle, anab::T0> : nullptr);
    PFParticleToSliceCollection outputParticlesToSlices(
      settings.m_shouldProduceSlices ? new art::Assns<recob::PFParticle, recob::Slice> : nullptr);

    // Collect immutable lists of pandora collections that we should convert to ART format
    const pandora::PfoVector pfoVector(
      settings.m_shouldProduceAllOutcomes ?
        LArPandoraOutput::CollectAllPfoOutcomes(settings.m_pPrimaryPandora) :
        LArPandoraOutput::CollectPfos(settings.m_pPrimaryPandora));

    IdToIdVectorMap pfoToVerticesMap, pfoToTestBeamInteractionVerticesMap;
    const pandora::VertexVector vertexVector(LArPandoraOutput::CollectVertices(
      pfoVector, pfoToVerticesMap, lar_content::LArPfoHelper::GetVertex));
    const pandora::VertexVector testBeamInteractionVertexVector(
      settings.m_shouldProduceTestBeamInteractionVertices ?
        LArPandoraOutput::CollectVertices(pfoVector,
                                          pfoToTestBeamInteractionVerticesMap,
                                          lar_content::LArPfoHelper::GetTestBeamInteractionVertex) :
        pandora::VertexVector());

    IdToIdVectorMap pfoToClustersMap;
    const pandora::ClusterList clusterList(
      LArPandoraOutput::CollectClusters(pfoVector, pfoToClustersMap));

    IdToIdVectorMap pfoToThreeDHitsMap;
    const pandora::CaloHitList threeDHitList(
      LArPandoraOutput::Collect3DHits(pfoVector, pfoToThreeDHitsMap));

    // Get mapping from pandora hits to art hits
    CaloHitToArtHitMap pandoraHitToArtHitMap;
    LArPandoraOutput::GetPandoraToArtHitMap(
      clusterList, threeDHitList, idToHitMap, pandoraHitToArtHitMap);

    // Build the ART outputs from the pandora objects
    LArPandoraOutput::BuildVertices(vertexVector, outputVertices);

    if (settings.m_shouldProduceTestBeamInteractionVertices)
      LArPandoraOutput::BuildVertices(testBeamInteractionVertexVector,
                                      outputTestBeamInteractionVertices);

    LArPandoraOutput::BuildSpacePoints(evt,
                                       instanceLabel,
                                       threeDHitList,
                                       pandoraHitToArtHitMap,
                                       outputSpacePoints,
                                       outputSpacePointsToHits);

    IdToIdVectorMap pfoToArtClustersMap;
    LArPandoraOutput::BuildClusters(evt,
                                    instanceLabel,
                                    clusterList,
                                    pandoraHitToArtHitMap,
                                    pfoToClustersMap,
                                    outputClusters,
                                    outputClustersToHits,
                                    pfoToArtClustersMap);

    LArPandoraOutput::BuildPFParticles(evt,
                                       instanceLabel,
                                       pfoVector,
                                       pfoToVerticesMap,
                                       pfoToThreeDHitsMap,
                                       pfoToArtClustersMap,
                                       outputParticles,
                                       outputParticlesToVertices,
                                       outputParticlesToSpacePoints,
                                       outputParticlesToClusters);

    LArPandoraOutput::BuildParticleMetadata(
      evt, instanceLabel, pfoVector, outputParticleMetadata, outputParticlesToMetadata);

    if (settings.m_shouldProduceSlices)
      LArPandoraOutput::BuildSlices(settings,
                                    settings.m_pPrimaryPandora,
                                    evt,
                                    instanceLabel,
                                    pfoVector,
                                    idToHitMap,
                                    outputSlices,
                                    outputParticlesToSlices,
                                    outputSlicesToHits);

    if (settings.m_shouldRunStitching)
      LArPandoraOutput::BuildT0s(evt, instanceLabel, pfoVector, outputT0s, outputParticlesToT0s);

    if (settings.m_shouldProduceTestBeamInteractionVertices)
      LArPandoraOutput::AssociateAdditionalVertices(evt,
                                                    instanceLabel,
                                                    pfoVector,
                                                    pfoToTestBeamInteractionVerticesMap,
                                                    outputParticlesToTestBeamInteractionVertices);

    // Add the outputs to the event
    evt.put(std::move(outputParticles), instanceLabel);
    evt.put(std::move(outputSpacePoints), instanceLabel);
    evt.put(std::move(outputClusters), instanceLabel);
    evt.put(std::move(outputVertices), instanceLabel);
    evt.put(std::move(outputParticleMetadata), instanceLabel);

    evt.put(std::move(outputParticlesToMetadata), instanceLabel);
    evt.put(std::move(outputParticlesToSpacePoints), instanceLabel);
    evt.put(std::move(outputParticlesToClusters), instanceLabel);
    evt.put(std::move(outputParticlesToVertices), instanceLabel);
    evt.put(std::move(outputParticlesToSlices), instanceLabel);
    evt.put(std::move(outputSpacePointsToHits), instanceLabel);
    evt.put(std::move(outputClustersToHits), instanceLabel);

    if (settings.m_shouldProduceTestBeamInteractionVertices) {
      evt.put(std::move(outputTestBeamInteractionVertices), testBeamInteractionVertexInstanceLabel);
      evt.put(std::move(outputParticlesToTestBeamInteractionVertices),
              testBeamInteractionVertexInstanceLabel);
    }

    if (settings.m_shouldRunStitching) {
      evt.put(std::move(outputT0s), instanceLabel);
      evt.put(std::move(outputParticlesToT0s), instanceLabel);
    }

    if (settings.m_shouldProduceSlices) {
      evt.put(std::move(outputSlices), instanceLabel);
      evt.put(std::move(outputSlicesToHits), instanceLabel);
    }
  }

---

The documentation for this class was generated from the following files:

• LArPandoraOutput.h
• LArPandoraOutput.cxx