#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 46 of file LArPandoraOutput.h.

Member Typedef Documentation

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

Definition at line 50 of file LArPandoraOutput.h.

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

Definition at line 54 of file LArPandoraOutput.h.

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

Definition at line 73 of file LArPandoraOutput.h.

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

Definition at line 49 of file LArPandoraOutput.h.

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

Definition at line 48 of file LArPandoraOutput.h.

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

Definition at line 52 of file LArPandoraOutput.h.

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

Definition at line 58 of file LArPandoraOutput.h.

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

Definition at line 66 of file LArPandoraOutput.h.

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

Definition at line 62 of file LArPandoraOutput.h.

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

Definition at line 71 of file LArPandoraOutput.h.

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

Definition at line 64 of file LArPandoraOutput.h.

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

Definition at line 69 of file LArPandoraOutput.h.

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

Definition at line 68 of file LArPandoraOutput.h.

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

Definition at line 59 of file LArPandoraOutput.h.

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

Definition at line 75 of file LArPandoraOutput.h.

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

Definition at line 55 of file LArPandoraOutput.h.

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

Definition at line 74 of file LArPandoraOutput.h.

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

Definition at line 56 of file LArPandoraOutput.h.

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

Definition at line 53 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 653 of file LArPandoraOutput.h.

Referenced by AssociateAdditionalVertices(), BuildClusters(), BuildParticleMetadata(), BuildPFParticles(), BuildSlice(), BuildSlices(), BuildSpacePoints(), BuildT0s(), and CopyAllHitsToSingleSlice().

   {
     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 671 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 695 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 713 of file LArPandoraOutput.cxx.

References AddAssociation().

Referenced by ProduceArtOutput().

   {
     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 1049 of file LArPandoraOutput.cxx.

References geo::kUnknown, cluster::ClusterCreator::move(), recob::Cluster::Sentry, and cluster::ClusterParamsAlgBase::SetHitsFromPointers().

Referenced by BuildClusters().

   {
     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.SetHitsFromPointers(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 612 of file LArPandoraOutput.cxx.

References AddAssociation().

Referenced by ProduceArtOutput().

   {
     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 990 of file LArPandoraOutput.cxx.

References BuildCluster(), GetHitsInCluster(), GetId(), and recob::Hit::WireID().

   {
     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 829 of file LArPandoraOutput.cxx.

Referenced by BuildSlice(), and CopyAllHitsToSingleSlice().

   {
     // 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 729 of file LArPandoraOutput.cxx.

References AddAssociation(), and lar_pandora::LArPandoraHelper::GetPFParticleMetadata().

Referenced by ProduceArtOutput().

   {
     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 934 of file LArPandoraOutput.cxx.

References GetId(), and recob::PFParticle::kPFParticlePrimary.

Referenced by BuildPFParticles().

   {
     // 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 679 of file LArPandoraOutput.cxx.

References AddAssociation(), and BuildPFParticle().

Referenced by ProduceArtOutput().

   {
     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 876 of file LArPandoraOutput.cxx.

References AddAssociation(), BuildDummySlice(), lar_content::LArPfoHelper::GetAllConnectedPfos(), lar_content::LArPfoHelper::GetCaloHits(), GetHit(), lar_content::LArPfoHelper::GetIsolatedCaloHits(), hits(), and lar_content::LArPfoHelper::SortByNHits().

Referenced by BuildSlices().

   {
     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 749 of file LArPandoraOutput.cxx.

References AddAssociation(), BuildSlice(), CopyAllHitsToSingleSlice(), GetPandoraSlices(), lar_content::LArPfoHelper::GetParentPfo(), GetSliceIndex(), IsFromSlice(), and lar_pandora::LArPandoraOutput::Settings::m_isNeutrinoRecoOnlyNoSlicing.

Referenced by ProduceArtOutput().

   {
     // 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 1132 of file LArPandoraOutput.cxx.

Referenced by BuildSpacePoints().

   {
     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 586 of file LArPandoraOutput.cxx.

References AddAssociation(), and BuildSpacePoint().

Referenced by ProduceArtOutput().

   {
     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 1151 of file LArPandoraOutput.cxx.

References GetId(), lar_content::LArPfoHelper::GetParentPfo(), and detinfo::sampling_rate().

Referenced by BuildT0s().

   {
     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 913 of file LArPandoraOutput.cxx.

References AddAssociation(), and BuildT0().

Referenced by ProduceArtOutput().

   {
     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 960 of file LArPandoraOutput.cxx.

Referenced by BuildVertices().

   {
     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 577 of file LArPandoraOutput.cxx.

References BuildVertex().

Referenced by ProduceArtOutput().

   {
     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 489 of file LArPandoraOutput.cxx.

References lar_content::LArPfoHelper::GetCaloHits(), and lar_content::LArClusterHelper::SortHitsByPosition().

Referenced by Collect3DHits(), and ProduceArtOutput().

   {
     // 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 457 of file LArPandoraOutput.cxx.

References Collect3DHits().

   {
     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 265 of file LArPandoraOutput.cxx.

References CollectPfos(), GetPandoraInstance(), GetPandoraSlices(), IsClearCosmic(), and util::to_string().

Referenced by ProduceArtOutput().

   {
     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 428 of file LArPandoraOutput.cxx.

References lar_content::LArPfoHelper::GetTwoDClusterList(), and lar_content::LArClusterHelper::SortByNHits().

Referenced by ProduceArtOutput().

   {
     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 360 of file LArPandoraOutput.cxx.

Referenced by CollectAllPfoOutcomes(), and ProduceArtOutput().

   {
     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 375 of file LArPandoraOutput.cxx.

References lar_content::LArPfoHelper::GetAllConnectedPfos(), and lar_content::LArPfoHelper::SortByNHits().

   {
     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 391 of file LArPandoraOutput.cxx.

Referenced by ProduceArtOutput().

   {
     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 845 of file LArPandoraOutput.cxx.

References AddAssociation(), BuildDummySlice(), lar_pandora::LArPandoraHelper::CollectHits(), hits(), and lar_pandora::LArPandoraOutput::Settings::m_hitfinderModuleLabel.

Referenced by BuildSlices().

   {
     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 545 of file LArPandoraOutput.cxx.

Referenced by BuildSlice(), and GetPandoraToArtHitMap().

   {
     //  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 970 of file LArPandoraOutput.cxx.

References lar_content::LArClusterHelper::SortHitsByPosition().

Referenced by BuildClusters(), and GetPandoraToArtHitMap().

   {
     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 624 of file LArPandoraOutput.h.

Referenced by BuildClusters(), BuildPFParticle(), and BuildT0().

   {
     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 213 of file LArPandoraOutput.cxx.

References MultiPandoraApi::GetDaughterPandoraInstanceList().

Referenced by CollectAllPfoOutcomes(), and GetPandoraSlices().

   {
     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 242 of file LArPandoraOutput.cxx.

References GetPandoraInstance().

Referenced by BuildSlices(), and CollectAllPfoOutcomes().

   {
     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 502 of file LArPandoraOutput.cxx.

References lar_content::LArClusterHelper::GetClusterHitType(), GetHit(), and GetHitsInCluster().

Referenced by ProduceArtOutput().

   {
     // 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 344 of file LArPandoraOutput.cxx.

References lar_content::LArPfoHelper::GetParentPfo().

Referenced by BuildSlices().

   {
     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 320 of file LArPandoraOutput.cxx.

References lar_content::LArPfoHelper::GetParentPfo().

Referenced by CollectAllPfoOutcomes().

   {
     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 334 of file LArPandoraOutput.cxx.

References lar_content::LArPfoHelper::GetParentPfo().

Referenced by BuildSlices().

   {
     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 41 of file LArPandoraOutput.cxx.

Referenced by lar_pandora::LArPandora::ProcessPandoraOutput().

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

larpandora/v09_22_05/source/larpandora/LArPandoraInterface/LArPandoraOutput.h
larpandora/v09_22_05/source/larpandora/LArPandoraInterface/LArPandoraOutput.cxx

Classes

Public Types

Static Public Member Functions

Detailed Description

Member Typedef Documentation

Member Function Documentation