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 Private Member Functions
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)
	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 art::EDProducer *const pProducer, 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 art::EDProducer *const pProducer, 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 art::EDProducer *const pProducer, 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	BuildParticleMetadata (const art::Event &event, const art::EDProducer *const pProducer, 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 art::EDProducer *const pProducer, 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 art::EDProducer *const pProducer, 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 art::EDProducer *const pProducer, 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 art::EDProducer *const pProducer, const std::string &instanceLabel, const pandora::PfoVector &pfoVector, T0Collection &outputT0s, const CaloHitToArtHitMap &pandoraHitToArtHitMap, 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 (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 (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 pandora::ParticleFlowObject *const pPfo, const pandora::PfoVector &pfoVector, size_t &nextId, const CaloHitToArtHitMap &pandoraHitToArtHitMap, anab::T0 &t0)
	If required, build a T0 for the input pfo. More...
static double	CalculateT0 (const art::Ptr< recob::Hit > hit, const pandora::CaloHit *const pCaloHit)
	Convert X0 correction into T0 correction. More...
template<typename A , typename B >
static void	AddAssociation (const art::Event &event, const art::EDProducer *const pProducer, 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 art::EDProducer *const pProducer, 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 art::EDProducer *const pProducer, 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 31 of file LArPandoraOutput.h.

Member Typedef Documentation

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

Definition at line 36 of file LArPandoraOutput.h.

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

Definition at line 40 of file LArPandoraOutput.h.

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

Definition at line 53 of file LArPandoraOutput.h.

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

Definition at line 35 of file LArPandoraOutput.h.

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

Definition at line 34 of file LArPandoraOutput.h.

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

Definition at line 38 of file LArPandoraOutput.h.

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

Definition at line 43 of file LArPandoraOutput.h.

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

Definition at line 48 of file LArPandoraOutput.h.

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

Definition at line 46 of file LArPandoraOutput.h.

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

Definition at line 51 of file LArPandoraOutput.h.

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

Definition at line 47 of file LArPandoraOutput.h.

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

Definition at line 50 of file LArPandoraOutput.h.

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

Definition at line 49 of file LArPandoraOutput.h.

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

Definition at line 44 of file LArPandoraOutput.h.

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

Definition at line 55 of file LArPandoraOutput.h.

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

Definition at line 41 of file LArPandoraOutput.h.

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

Definition at line 54 of file LArPandoraOutput.h.

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

Definition at line 42 of file LArPandoraOutput.h.

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

Definition at line 39 of file LArPandoraOutput.h.

Member Function Documentation

template<typename A , typename B >

void lar_pandora::LArPandoraOutput::AddAssociation ( const art::Event &  event, const art::EDProducer *const  pProducer, const std::string &  instanceLabel, const size_t  idA, const size_t  idB, std::unique_ptr< art::Assns< A, B > > &  association  )

inlinestaticprivate

Add an association between objects with two given ids.

Parameters

event	the ART event
pProducer	the address of the producer module
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 559 of file LArPandoraOutput.h.

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

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

    const art::PtrMaker<B> makePtrB(event, *pProducer, 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 art::EDProducer *const  pProducer, const std::string &  instanceLabel, const size_t  idA, const IdToIdVectorMap &  aToBMap, std::unique_ptr< art::Assns< A, B > > &  association  )

inlinestaticprivate

Add associations between input objects.

Parameters

event	the ART event
pProducer	the address of the producer module
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 574 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, *pProducer, instanceLabel);
    art::Ptr<A> pA(makePtrA(idA));

    const art::PtrMaker<B> makePtrB(event, *pProducer, 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 art::EDProducer *const  pProducer, const std::string &  instanceLabel, const size_t  idA, const std::vector< art::Ptr< B > > &  bVector, std::unique_ptr< art::Assns< A, B > > &  association  )

inlinestaticprivate

Add associations between input objects.

Parameters

event	the ART event
pProducer	the address of the producer module
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 595 of file LArPandoraOutput.h.

{
    const art::PtrMaker<A> makePtrA(event, *pProducer, instanceLabel);
    art::Ptr<A> pA(makePtrA(idA));
    
    for (const art::Ptr<B> &pB : bVector)
        association->addSingle(pA, pB);
}

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

staticprivate

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

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

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.SetHits(hits_for_params);

    // create the recob::Cluster directly in the vector
    return cluster::ClusterCreator(
      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 art::EDProducer *const  pProducer, const std::string &  instanceLabel, const pandora::ClusterList &  clusterList, const CaloHitToArtHitMap &  pandoraHitToArtHitMap, const IdToIdVectorMap &  pfoToClustersMap, ClusterCollection &  outputClusters, ClusterToHitCollection &  outputClustersToHits, IdToIdVectorMap &  pfoToArtClustersMap  )

staticprivate

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
pProducer	the address of the producer module
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 487 of file LArPandoraOutput.cxx.

References AddAssociation().

Referenced by ProduceArtOutput().

{
    cluster::StandardClusterParamsAlg clusterParamAlgo;
    
    // 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(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, pProducer, 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 ( const pandora::Cluster *const  pCluster, const pandora::ClusterList &  clusterList, const CaloHitToArtHitMap &  pandoraHitToArtHitMap, IdToIdVectorMap &  pandoraClusterToArtClustersMap, std::vector< HitVector > &  hitVectors, size_t &  nextId, cluster::ClusterParamsAlgBase &  algo  )

staticprivate

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 765 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(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 )

staticprivate

Build a new slice object with dummy information.

Parameters

outputSlices

the output collection of slices to populate

Definition at line 634 of file LArPandoraOutput.cxx.

References max.

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 art::EDProducer *const  pProducer, const std::string &  instanceLabel, const pandora::PfoVector &  pfoVector, PFParticleMetadataCollection &  outputParticleMetadata, PFParticleToMetadataCollection &  outputParticlesToMetadata  )

staticprivate

Build metadata objects from a list of input pfos.

Parameters

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

Definition at line 557 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, pProducer, 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  )

staticprivate

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 721 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 art::EDProducer *const  pProducer, 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  )

staticprivate

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
pProducer	the address of the producer module
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 532 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, pProducer, instanceLabel, pfoId, pfoToVerticesMap, outputParticlesToVertices);

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

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

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

staticprivate

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
pProducer	the address of the pandora producer
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 671 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, pProducer, 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 art::EDProducer *const  pProducer, const std::string &  instanceLabel, const pandora::PfoVector &  pfoVector, const IdToHitMap &  idToHitMap, SliceCollection &  outputSlices, PFParticleToSliceCollection &  outputParticlesToSlices, SliceToHitCollection &  outputSlicesToHits  )

staticprivate

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
pProducer	the address of the pandora producer
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 573 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, pProducer, 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, pProducer, 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, pProducer, 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, pProducer, 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, pProducer, instanceLabel, pfoId, parentPfoToSliceIndexMap.at(pParent), outputParticlesToSlices);
    }
}

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

staticprivate

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 900 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 art::EDProducer *const  pProducer, const std::string &  instanceLabel, const pandora::CaloHitList &  threeDHitList, const CaloHitToArtHitMap &  pandoraHitToArtHitMap, SpacePointCollection &  outputSpacePoints, SpacePointToHitCollection &  outputSpacePointsToHits  )

staticprivate

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
pProducer	the address of the producer module
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 465 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, pProducer, instanceLabel, hitId, {it->second}, outputSpacePointsToHits);
        outputSpacePoints->push_back(LArPandoraOutput::BuildSpacePoint(pCaloHit, hitId));
    }
}

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

staticprivate

If required, build a T0 for the input pfo.

Parameters

pPfo	the input pfo
pfoVector	the input list of pfos
nextId	the ID of the T0 - will be incremented if the t0 was produced
pandoraHitToArtHitMap	the input mapping from pandora hits to ART hits
t0	the output T0

Returns

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

Definition at line 917 of file LArPandoraOutput.cxx.

References CalculateT0(), Collect3DHits(), and GetId().

Referenced by BuildT0s().

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

    double sumT(0.), sumN(0.);

    for (const pandora::CaloHit *const pCaloHit3D : sorted3DHits)
    {
        if (pandora::TPC_3D != pCaloHit3D->GetHitType())
            throw cet::exception("LArPandora") << " LArPandoraOutput::BuildT0 --- found a 2D hit in a 3D cluster";

        const pandora::CaloHit *const pCaloHit2D = static_cast<const pandora::CaloHit*>(pCaloHit3D->GetParentAddress());

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

        HitVector spacePointHits;
        spacePointHits.push_back(hit);

        // ATTN: We assume that the 2D Pandora hits have been shifted
        sumT += LArPandoraOutput::CalculateT0(hit, pCaloHit2D);
        sumN += 1.;
    }

    // ATTN: T0 values are currently calculated in nanoseconds relative to the trigger offset. Only non-zero values are outputted.
    const double T0((sumN > 0. && std::fabs(sumT) > sumN) ? (sumT / sumN) : 0.);

    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 art::EDProducer *const  pProducer, const std::string &  instanceLabel, const pandora::PfoVector &  pfoVector, T0Collection &  outputT0s, const CaloHitToArtHitMap &  pandoraHitToArtHitMap, PFParticleToT0Collection &  outputParticlesToT0s  )

staticprivate

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
pProducer	the address of the producer module
pfoVector	the input list of pfos
outputT0s	the output vector of T0s
pandoraHitToArtHitMap	the input mapping from pandora hits to ART hits
outputParticlesToT0s	the output associations between PFParticles and T0s

Definition at line 702 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(pPfo, pfoVector, nextT0Id, pandoraHitToArtHitMap, t0)) continue;
        
        LArPandoraOutput::AddAssociation(event, pProducer, instanceLabel, pfoId, nextT0Id - 1, outputParticlesToT0s);
        outputT0s->push_back(t0);
    }
}

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

staticprivate

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 742 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  )

staticprivate

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

double lar_pandora::LArPandoraOutput::CalculateT0 ( const art::Ptr< recob::Hit >  hit, const pandora::CaloHit *const  pCaloHit  )

staticprivate

Convert X0 correction into T0 correction.

Parameters

hit	the input ART hit
pCaloHit	the output Pandora hit

Returns

T0 relative to input hit in nanoseconds

Definition at line 959 of file LArPandoraOutput.cxx.

References geo::GeometryCore::Cryostat(), dir, geo::kNegX, recob::Hit::PeakTime(), geo::CryostatGeo::TPC(), and recob::Hit::WireID().

Referenced by BuildT0().

{
    art::ServiceHandle<geo::Geometry> theGeometry;
    auto const* theDetector = lar::providerFrom<detinfo::DetectorPropertiesService>();

    const geo::WireID hit_WireID(hit->WireID());
    const geo::TPCGeo &theTpc = theGeometry->Cryostat(hit_WireID.Cryostat).TPC(hit_WireID.TPC);

    // Calculate shift in x position between input and output hits
    const double input_xpos_cm(theDetector->ConvertTicksToX(hit->PeakTime(), hit_WireID.Plane, hit_WireID.TPC, hit_WireID.Cryostat));
    const double output_xpos_dm(pCaloHit->GetPositionVector().GetX());
    const double x0_cm(output_xpos_dm - input_xpos_cm);

    // The ingredients for the T0 calculation all come from the detector properties service
    const double dir((theTpc.DriftDirection() == geo::kNegX) ? 1.0 : -1.0);
    const double cm_per_tick(theDetector->GetXTicksCoefficient());
    const double ns_per_tick(theDetector->SamplingRate());

    // This calculation should give the T0 in nanoseconds relative to the initial 2D hit
    return (- dir * x0_cm * ns_per_tick / cm_per_tick);
}

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

staticprivate

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

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

Referenced by BuildT0(), 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  )

staticprivate

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 352 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 )

staticprivate

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

References CollectPfos(), GetPandoraInstance(), GetPandoraSlices(), IsClearCosmic(), and util::flags::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  )

staticprivate

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 324 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 )

staticprivate

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 267 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  )

staticprivate

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 280 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  )

staticprivate

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)

Returns

the list of vertices collected

Definition at line 294 of file LArPandoraOutput.cxx.

References lar_content::LArPfoHelper::GetVertex().

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;

        const pandora::Vertex *const pVertex(lar_content::LArPfoHelper::GetVertex(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 ";
    }

    return vertexVector;
}

void lar_pandora::LArPandoraOutput::CopyAllHitsToSingleSlice ( const Settings &  settings, const art::Event &  event, const art::EDProducer *const  pProducer, const std::string &  instanceLabel, const pandora::PfoVector &  pfoVector, const IdToHitMap &  idToHitMap, SliceCollection &  outputSlices, PFParticleToSliceCollection &  outputParticlesToSlices, SliceToHitCollection &  outputSlicesToHits  )

staticprivate

Ouput a single slice containing all of the input hits.

Parameters

settings	the settings
event	the art event
pProducer	the address of the pandora producer
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 649 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, pProducer, 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, pProducer, instanceLabel, pfoId, sliceIndex, outputParticlesToSlices);
}

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

staticprivate

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 425 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  )

staticprivate

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 750 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  )

inlinestaticprivate

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 533 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  )

inlinestaticprivate

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 546 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  )

staticprivate

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 134 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  )

staticprivate

Get the slice pfos - one pfo per slice.

Parameters

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

Definition at line 159 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  )

staticprivate

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 393 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 )

staticprivate

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

Parameters

pPfo	the input pfo

Returns

the slice index

Definition at line 252 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 )

staticprivate

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 227 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 )

staticprivate

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

References BuildClusters(), BuildParticleMetadata(), BuildPFParticles(), BuildSlices(), BuildSpacePoints(), BuildT0s(), BuildVertices(), Collect3DHits(), CollectAllPfoOutcomes(), CollectClusters(), CollectPfos(), CollectVertices(), GetPandoraToArtHitMap(), lar_pandora::LArPandoraOutput::Settings::m_allOutcomesInstanceLabel, lar_pandora::LArPandoraOutput::Settings::m_pPrimaryPandora, lar_pandora::LArPandoraOutput::Settings::m_pProducer, lar_pandora::LArPandoraOutput::Settings::m_shouldProduceAllOutcomes, lar_pandora::LArPandoraOutput::Settings::m_shouldRunStitching, art::Event::put(), and lar_pandora::LArPandoraOutput::Settings::Validate().

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

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

    // Set up the 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> );
    T0Collection                    outputT0s( new std::vector<anab::T0> );
    PFParticleMetadataCollection    outputParticleMetadata( new std::vector<larpandoraobj::PFParticleMetadata> );
    SliceCollection                 outputSlices( new std::vector<recob::Slice> );

    // Set up the 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> );
    PFParticleToT0Collection          outputParticlesToT0s( new art::Assns<recob::PFParticle, anab::T0> );
    PFParticleToSliceCollection       outputParticlesToSlices( new art::Assns<recob::PFParticle, recob::Slice> );
    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> );

    // 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;
    const pandora::VertexVector vertexVector(LArPandoraOutput::CollectVertices(pfoVector, pfoToVerticesMap));

    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);
    LArPandoraOutput::BuildSpacePoints(evt, settings.m_pProducer, instanceLabel, threeDHitList, pandoraHitToArtHitMap, outputSpacePoints, outputSpacePointsToHits);

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

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

    LArPandoraOutput::BuildParticleMetadata(evt, settings.m_pProducer, instanceLabel, pfoVector, outputParticleMetadata, outputParticlesToMetadata);
    LArPandoraOutput::BuildSlices(settings, settings.m_pPrimaryPandora, evt, settings.m_pProducer, instanceLabel, pfoVector, idToHitMap, outputSlices, outputParticlesToSlices, outputSlicesToHits);

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

    // 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(outputSlices), 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);
    evt.put(std::move(outputSlicesToHits), instanceLabel);

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

---

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

• /cvmfs/larsoft.opensciencegrid.org/products/larpandora/v07_06_01/source/larpandora/LArPandoraInterface/LArPandoraOutput.h
• /cvmfs/larsoft.opensciencegrid.org/products/larpandora/v07_06_01/source/larpandora/LArPandoraInterface/LArPandoraOutput.cxx