#include <EventSlicingTool.h>

Inheritance diagram for lar_content::EventSlicingTool:

Public Member Functions
	EventSlicingTool ()
	Default constructor. More...

void	RunSlicing (const pandora::Algorithm *const pAlgorithm, const SlicingAlgorithm::HitTypeToNameMap &caloHitListNames, const SlicingAlgorithm::HitTypeToNameMap &clusterListNames, SlicingAlgorithm::SliceList &sliceList)
	Run the slicing tool. More...

Private Types
typedef std::unordered_map< const pandora::Cluster , const pandora::ParticleFlowObject >	ClusterToPfoMap

typedef std::vector< pandora::ClusterVector >	ClusterSliceList

typedef std::unordered_map< const pandora::Cluster *, unsigned int >	ClusterToSliceIndexMap

typedef KDTreeLinkerAlgo< const pandora::CartesianVector *, 2 >	PointKDTree2D

typedef KDTreeNodeInfoT< const pandora::CartesianVector *, 2 >	PointKDNode2D

typedef std::vector< PointKDNode2D >	PointKDNode2DList

typedef std::list< const pandora::CartesianVector * >	PointList

typedef std::unordered_map< const pandora::CartesianVector *, unsigned int >	PointToSliceIndexMap

Private Member Functions
void	CopyAllHitsToSingleSlice (const pandora::Algorithm *const pAlgorithm, const SlicingAlgorithm::HitTypeToNameMap &caloHitListNames, SlicingAlgorithm::SliceList &sliceList) const
	Copy all the input hits in an event into a single slice. More...

void	GetThreeDClusters (const pandora::Algorithm *const pAlgorithm, const std::string &pfoListName, pandora::ClusterList &clusters3D, ClusterToPfoMap &clusterToPfoMap) const
	Get the 3D clusters from a specified list of pfos, storing the 3D clusters in the provided list and populating a map from 3D cluster to parent pfo. More...

void	GetClusterSliceList (const pandora::ClusterList &trackClusters3D, const pandora::ClusterList &showerClusters3D, ClusterSliceList &clusterSliceList) const
	Divide the provided lists of 3D track and shower clusters into slices. More...

void	CollectAssociatedClusters (const pandora::Cluster *const pClusterInSlice, const pandora::ClusterVector &candidateClusters, const ThreeDSlidingFitResultMap &trackFitResults, const ThreeDSlidingConeFitResultMap &showerConeFitResults, pandora::ClusterVector &clusterSlice, pandora::ClusterSet &usedClusters) const
	Collect all clusters associated with a provided cluster. More...

bool	PassPointing (const pandora::Cluster const pClusterInSlice, const pandora::Cluster const pCandidateCluster, const ThreeDSlidingFitResultMap &trackFitResults) const
	Compare the provided clusters to assess whether they are associated via pointing (checks association "both ways") More...

bool	PassProximity (const pandora::Cluster const pClusterInSlice, const pandora::Cluster const pCandidateCluster) const
	Compare the provided clusters to assess whether they are associated via pointing. More...

bool	PassShowerCone (const pandora::Cluster const pConeCluster, const pandora::Cluster const pNearbyCluster, const ThreeDSlidingConeFitResultMap &showerConeFitResults) const
	Compare the provided clusters to assess whether they are associated via cone fits to the shower cluster (single "direction" check) More...

bool	CheckClosestApproach (const LArPointingCluster &cluster1, const LArPointingCluster &cluster2) const
	Check closest approach metrics for a pair of pointing clusters. More...

bool	CheckClosestApproach (const LArPointingCluster::Vertex &vertex1, const LArPointingCluster::Vertex &vertex2) const
	Check closest approach metrics for a pair of pointing cluster vertices. More...

bool	IsNode (const LArPointingCluster &cluster1, const LArPointingCluster &cluster2) const
	Check whether a pair of pointing clusters are nodally associated. More...

bool	IsEmission (const LArPointingCluster &cluster1, const LArPointingCluster &cluster2) const
	Check whether a pair of pointing clusters are consistent with an emission. More...

void	CreateSlices (const ClusterSliceList &clusterSliceList, SlicingAlgorithm::SliceList &sliceList, ClusterToSliceIndexMap &clusterToSliceIndexMap) const
	Create new slices for each of the groupings of 3D clusters in the provided cluster slice list. More...

void	CopyPfoHitsToSlices (const ClusterToSliceIndexMap &clusterToSliceIndexMap, const ClusterToPfoMap &clusterToPfoMap, SlicingAlgorithm::SliceList &sliceList, pandora::ClusterSet &assignedClusters) const
	Use 3D clusters in the cluster slice list, find their parent pfos and assign all hits in all 2D clusters in the pfos to the relevant slice in the output slice list. More...

void	GetRemainingClusters (const pandora::Algorithm *const pAlgorithm, const SlicingAlgorithm::HitTypeToNameMap &clusterListNames, const pandora::ClusterSet &assignedClusters, pandora::ClusterList &remainingClusters) const
	Get the list of 2D clusters with hits yets to be assigned to slices. More...

void	GetRemainingClusters (const pandora::Algorithm *const pAlgorithm, const std::string &clusterListName, const pandora::ClusterSet &assignedClusters, pandora::ClusterList &remainingClusters) const
	Get the list of 2D clusters (from a named 2D cluster list) with hits yets to be assigned to slices. More...

void	AssignRemainingHitsToSlices (const pandora::ClusterList &remainingClusters, const ClusterToSliceIndexMap &clusterToSliceIndexMap, SlicingAlgorithm::SliceList &sliceList) const
	Use the list of remaining 2D clusters to assign all remaining 2D hits to existing slices in the slice list. More...

void	GetKDTreeEntries2D (const SlicingAlgorithm::SliceList &sliceList, PointList &pointsU, PointList &pointsV, PointList &pointsW, PointToSliceIndexMap &pointToSliceIndexMap) const
	Use projections of 3D hits already assigned to slices to populate kd trees to aid assignment of remaining clusters. More...

void	GetKDTreeEntries3D (const ClusterToSliceIndexMap &clusterToSliceIndexMap, PointList &pointsU, PointList &pointsV, PointList &pointsW, PointToSliceIndexMap &pointToSliceIndexMap) const
	Use 2D hits already assigned to slices to populate kd trees to aid assignment of remaining clusters. More...

const PointKDNode2D *	MatchClusterToSlice (const pandora::Cluster *const pCluster2D, PointKDTree2D &kdTree) const
	Use the provided kd tree to efficiently identify the most appropriate slice for the provided 2D cluster. More...

pandora::StatusCode	ReadSettings (const pandora::TiXmlHandle xmlHandle)

Static Private Member Functions
static bool	SortPoints (const pandora::CartesianVector const pLhs, const pandora::CartesianVector const pRhs)
	Sort points (use Z, followed by X, followed by Y) More...

Private Attributes
std::string	m_trackPfoListName
	The name of the input track pfo list. More...

std::string	m_showerPfoListName
	The name of the input shower pfo list. More...

unsigned int	m_minHitsPer3DCluster
	The minimum number of hits in a 3D cluster to warrant consideration in slicing. More...

unsigned int	m_min3DHitsToSeedNewSlice
	The minimum number of hits in a 3D cluster to seed a new slice. More...

unsigned int	m_halfWindowLayers
	The number of layers to use for half-window of sliding fit. More...

bool	m_usePointingAssociation
	Whether to use pointing association. More...

float	m_minVertexLongitudinalDistance
	Pointing association check: min longitudinal distance cut. More...

float	m_maxVertexLongitudinalDistance
	Pointing association check: max longitudinal distance cut. More...

float	m_maxVertexTransverseDistance
	Pointing association check: max transverse distance cut. More...

float	m_vertexAngularAllowance
	Pointing association check: pointing angular allowance in degrees. More...

float	m_maxClosestApproach
	Pointing association: max distance of closest approach between straight line fits. More...

float	m_maxInterceptDistance
	Pointing association: max distance from cluster vertex to point of closest approach. More...

bool	m_useProximityAssociation
	Whether to use proximity association. More...

float	m_maxHitSeparationSquared
	Proximity association: max distance allowed between the closest pair of hits. More...

bool	m_useShowerConeAssociation
	Whether to use shower cone association. More...

unsigned int	m_nConeFitLayers
	The number of layers over which to sum fitted direction to obtain cone fit. More...

unsigned int	m_nConeFits
	The number of cone fits to perform, spread roughly uniformly along the shower length. More...

float	m_coneLengthMultiplier
	The cone length multiplier to use when calculating bounded cluster fractions. More...

float	m_maxConeLength
	The maximum allowed cone length to use when calculating bounded cluster fractions. More...

float	m_coneTanHalfAngle1
	The cone tan half angle to use when calculating bounded cluster fractions 1. More...

float	m_coneBoundedFraction1
	The minimum cluster bounded fraction for association 1. More...

float	m_coneTanHalfAngle2
	The cone tan half angle to use when calculating bounded cluster fractions 2. More...

float	m_coneBoundedFraction2
	The minimum cluster bounded fraction for association 2. More...

bool	m_use3DProjectionsInHitPickUp
	Whether to include 3D cluster projections when assigning remaining clusters to slices. More...

Detailed Description

EventSlicingTool class.

Definition at line 32 of file EventSlicingTool.h.

Member Typedef Documentation

typedef std::vector<pandora::ClusterVector> lar_content::EventSlicingTool::ClusterSliceList

private

Definition at line 68 of file EventSlicingTool.h.

typedef std::unordered_map<const pandora::Cluster *, const pandora::ParticleFlowObject *> lar_content::EventSlicingTool::ClusterToPfoMap

private

Definition at line 54 of file EventSlicingTool.h.

typedef std::unordered_map<const pandora::Cluster *, unsigned int> lar_content::EventSlicingTool::ClusterToSliceIndexMap

private

Definition at line 168 of file EventSlicingTool.h.

typedef KDTreeNodeInfoT<const pandora::CartesianVector *, 2> lar_content::EventSlicingTool::PointKDNode2D

private

Definition at line 224 of file EventSlicingTool.h.

typedef std::vector<PointKDNode2D> lar_content::EventSlicingTool::PointKDNode2DList

private

Definition at line 225 of file EventSlicingTool.h.

typedef KDTreeLinkerAlgo<const pandora::CartesianVector *, 2> lar_content::EventSlicingTool::PointKDTree2D

private

Definition at line 223 of file EventSlicingTool.h.

typedef std::list<const pandora::CartesianVector *> lar_content::EventSlicingTool::PointList

private

Definition at line 227 of file EventSlicingTool.h.

typedef std::unordered_map<const pandora::CartesianVector *, unsigned int> lar_content::EventSlicingTool::PointToSliceIndexMap

private

Definition at line 228 of file EventSlicingTool.h.

Constructor & Destructor Documentation

lar_content::EventSlicingTool::EventSlicingTool ( )

Default constructor.

Definition at line 34 of file EventSlicingTool.cc.

                                    :
     m_minHitsPer3DCluster(20),
     m_min3DHitsToSeedNewSlice(50),
     m_halfWindowLayers(20),
     m_usePointingAssociation(true),
     m_minVertexLongitudinalDistance(-7.5f),
     m_maxVertexLongitudinalDistance(60.f),
     m_maxVertexTransverseDistance(10.5f),
     m_vertexAngularAllowance(9.f),
     m_maxClosestApproach(15.f),
     m_maxInterceptDistance(60.f),
     m_useProximityAssociation(true),
     m_maxHitSeparationSquared(25.f * 25.f),
     m_useShowerConeAssociation(true),
     m_nConeFitLayers(20),
     m_nConeFits(5),
     m_coneLengthMultiplier(7.f),
     m_maxConeLength(126.f),
     m_coneTanHalfAngle1(0.5f),
     m_coneBoundedFraction1(0.5f),
     m_coneTanHalfAngle2(0.75f),
     m_coneBoundedFraction2(0.75f),
     m_use3DProjectionsInHitPickUp(true)
 {
 }

Member Function Documentation

void lar_content::EventSlicingTool::AssignRemainingHitsToSlices	(	const pandora::ClusterList &	remainingClusters,
		const ClusterToSliceIndexMap &	clusterToSliceIndexMap,
		SlicingAlgorithm::SliceList &	sliceList
	)		const

private

Use the list of remaining 2D clusters to assign all remaining 2D hits to existing slices in the slice list.

Parameters

remainingClusters	the list of 2D clusters with hits yet to be assigned to slices
clusterToSliceIndexMap	the mapping from 3D clusters to index in the slice list
sliceList	the list containing slices to be populated with 2D hits

Definition at line 527 of file EventSlicingTool.cc.

 {
     PointToSliceIndexMap pointToSliceIndexMap;
 
     try
     {
         PointList pointsU, pointsV, pointsW;
         this->GetKDTreeEntries2D(sliceList, pointsU, pointsV, pointsW, pointToSliceIndexMap);
 
         if (m_use3DProjectionsInHitPickUp)
             this->GetKDTreeEntries3D(clusterToSliceIndexMap, pointsU, pointsV, pointsW, pointToSliceIndexMap);
 
         pointsU.sort(EventSlicingTool::SortPoints);
         pointsV.sort(EventSlicingTool::SortPoints);
         pointsW.sort(EventSlicingTool::SortPoints);
 
         PointKDNode2DList kDNode2DListU, kDNode2DListV, kDNode2DListW;
         KDTreeBox boundingRegionU = fill_and_bound_2d_kd_tree(pointsU, kDNode2DListU);
         KDTreeBox boundingRegionV = fill_and_bound_2d_kd_tree(pointsV, kDNode2DListV);
         KDTreeBox boundingRegionW = fill_and_bound_2d_kd_tree(pointsW, kDNode2DListW);
 
         PointKDTree2D kdTreeU, kdTreeV, kdTreeW;
         kdTreeU.build(kDNode2DListU, boundingRegionU);
         kdTreeV.build(kDNode2DListV, boundingRegionV);
         kdTreeW.build(kDNode2DListW, boundingRegionW);
 
         ClusterVector sortedRemainingClusters(remainingClusters.begin(), remainingClusters.end());
         std::sort(sortedRemainingClusters.begin(), sortedRemainingClusters.end(), LArClusterHelper::SortByNHits);
 
         for (const Cluster *const pCluster2D : sortedRemainingClusters)
         {
             const HitType hitType(LArClusterHelper::GetClusterHitType(pCluster2D));
 
             if ((TPC_VIEW_U != hitType) && (TPC_VIEW_V != hitType) && (TPC_VIEW_W != hitType))
                 throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
 
             PointKDTree2D &kdTree((TPC_VIEW_U == hitType) ? kdTreeU : (TPC_VIEW_V == hitType) ? kdTreeV : kdTreeW);
             const PointKDNode2D *pBestResultPoint(this->MatchClusterToSlice(pCluster2D, kdTree));
 
             if (!pBestResultPoint)
                 continue;
 
             Slice &slice(sliceList.at(pointToSliceIndexMap.at(pBestResultPoint->data)));
             CaloHitList &targetList((TPC_VIEW_U == hitType) ? slice.m_caloHitListU : (TPC_VIEW_V == hitType) ? slice.m_caloHitListV : slice.m_caloHitListW);
 
             pCluster2D->GetOrderedCaloHitList().FillCaloHitList(targetList);
             targetList.insert(targetList.end(), pCluster2D->GetIsolatedCaloHitList().begin(), pCluster2D->GetIsolatedCaloHitList().end());
         }
     }
     catch (...)
     {
         std::cout << "EventSlicingTool::AssignRemainingHitsToSlices - exception " << std::endl;
         for (const auto &pointMap : pointToSliceIndexMap)
             delete pointMap.first;
         throw;
     }
 
     for (const auto &pointMap : pointToSliceIndexMap)
         delete pointMap.first;
 }

bool lar_content::EventSlicingTool::CheckClosestApproach	(	const LArPointingCluster &	cluster1,
		const LArPointingCluster &	cluster2
	)		const

private

Check closest approach metrics for a pair of pointing clusters.

Parameters

cluster1	the first pointing cluster
cluster2	the second pointing cluster

Returns: whether the pointing clusters are declared to be in the same slice

Definition at line 345 of file EventSlicingTool.cc.

 {
     return (this->CheckClosestApproach(cluster1.GetInnerVertex(), cluster2.GetInnerVertex()) ||
             this->CheckClosestApproach(cluster1.GetOuterVertex(), cluster2.GetInnerVertex()) ||
             this->CheckClosestApproach(cluster1.GetInnerVertex(), cluster2.GetOuterVertex()) ||
             this->CheckClosestApproach(cluster1.GetOuterVertex(), cluster2.GetOuterVertex()));
 }

bool lar_content::EventSlicingTool::CheckClosestApproach	(	const LArPointingCluster::Vertex &	vertex1,
		const LArPointingCluster::Vertex &	vertex2
	)		const

private

Check closest approach metrics for a pair of pointing cluster vertices.

Parameters

vertex1	the first pointing cluster vertex
vertex2	the second pointing cluster vertex

Returns: whether the pointing clusters are declared to be in the same slice

Definition at line 355 of file EventSlicingTool.cc.

 {
     CartesianVector intersectionPoint(0.f, 0.f, 0.f);
     float displacement1(std::numeric_limits<float>::max()), displacement2(std::numeric_limits<float>::max());
 
     try
     {
         LArPointingClusterHelper::GetIntersection(vertex1, vertex2, intersectionPoint, displacement1, displacement2);
     }
     catch (const StatusCodeException &)
     {
         return false;
     }
 
     const CartesianVector approach1(vertex1.GetPosition() + vertex1.GetDirection() * displacement1);
     const CartesianVector approach2(vertex2.GetPosition() + vertex2.GetDirection() * displacement2);
     const float closestApproach((approach1 - approach2).GetMagnitude());
 
     return ((closestApproach < m_maxClosestApproach) && (std::fabs(displacement1) < m_maxInterceptDistance) &&
             (std::fabs(displacement2) < m_maxInterceptDistance));
 }

void lar_content::EventSlicingTool::CollectAssociatedClusters	(	const pandora::Cluster *const	pClusterInSlice,
		const pandora::ClusterVector &	candidateClusters,
		const ThreeDSlidingFitResultMap &	trackFitResults,
		const ThreeDSlidingConeFitResultMap &	showerConeFitResults,
		pandora::ClusterVector &	clusterSlice,
		pandora::ClusterSet &	usedClusters
	)		const

private

Collect all clusters associated with a provided cluster.

Parameters

pClusterInSlice	the address of the cluster already in a slice
candidateClusters	the list of candidate clusters
trackFitResults	the map of sliding fit results for track candidate clusters
showerConeFitResults	the map of sliding const fit results for shower candidate clusters
clusterSlice	the cluster slice
usedClusters	the list of clusters already added to slices

Definition at line 228 of file EventSlicingTool.cc.

 {
     ClusterVector addedClusters;
 
     for (const Cluster *const pCandidateCluster : candidateClusters)
     {
         if (usedClusters.count(pCandidateCluster) || (pClusterInSlice == pCandidateCluster))
             continue;
 
         if ((m_usePointingAssociation && this->PassPointing(pClusterInSlice, pCandidateCluster, trackFitResults)) ||
             (m_useProximityAssociation && this->PassProximity(pClusterInSlice, pCandidateCluster)) ||
             (m_useShowerConeAssociation && (this->PassShowerCone(pClusterInSlice, pCandidateCluster, showerConeFitResults) ||
                                                this->PassShowerCone(pCandidateCluster, pClusterInSlice, showerConeFitResults))))
         {
             addedClusters.push_back(pCandidateCluster);
             (void)usedClusters.insert(pCandidateCluster);
         }
     }
 
     clusterSlice.insert(clusterSlice.end(), addedClusters.begin(), addedClusters.end());
 
     for (const Cluster *const pAddedCluster : addedClusters)
         this->CollectAssociatedClusters(pAddedCluster, candidateClusters, trackFitResults, showerConeFitResults, clusterSlice, usedClusters);
 }

void lar_content::EventSlicingTool::CopyAllHitsToSingleSlice	(	const pandora::Algorithm *const	pAlgorithm,
		const SlicingAlgorithm::HitTypeToNameMap &	caloHitListNames,
		SlicingAlgorithm::SliceList &	sliceList
	)		const

private

Copy all the input hits in an event into a single slice.

Parameters

pAlgorithm	the address of the calling algorithm
caloHitListNames	the hit type to calo hit list name map
sliceList	the slice list to receive the single new slice

Definition at line 100 of file EventSlicingTool.cc.

 {
     if (!sliceList.empty())
         throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
 
     const CaloHitList *pCaloHitListU(nullptr);
     PANDORA_THROW_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_INITIALIZED, !=,
         PandoraContentApi::GetList(*pAlgorithm, caloHitListNames.at(TPC_VIEW_U), pCaloHitListU));
 
     const CaloHitList *pCaloHitListV(nullptr);
     PANDORA_THROW_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_INITIALIZED, !=,
         PandoraContentApi::GetList(*pAlgorithm, caloHitListNames.at(TPC_VIEW_V), pCaloHitListV));
 
     const CaloHitList *pCaloHitListW(nullptr);
     PANDORA_THROW_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_INITIALIZED, !=,
         PandoraContentApi::GetList(*pAlgorithm, caloHitListNames.at(TPC_VIEW_W), pCaloHitListW));
 
     if (pCaloHitListU || pCaloHitListV || pCaloHitListW)
     {
         sliceList.push_back(Slice());
         Slice &slice(sliceList.at(0));
 
         if (pCaloHitListU)
             slice.m_caloHitListU = *pCaloHitListU;
         if (pCaloHitListV)
             slice.m_caloHitListV = *pCaloHitListV;
         if (pCaloHitListW)
             slice.m_caloHitListW = *pCaloHitListW;
     }
 }

void lar_content::EventSlicingTool::CopyPfoHitsToSlices	(	const ClusterToSliceIndexMap &	clusterToSliceIndexMap,
		const ClusterToPfoMap &	clusterToPfoMap,
		SlicingAlgorithm::SliceList &	sliceList,
		pandora::ClusterSet &	assignedClusters
	)		const

private

Use 3D clusters in the cluster slice list, find their parent pfos and assign all hits in all 2D clusters in the pfos to the relevant slice in the output slice list.

Parameters

clusterToSliceIndexMap	the mapping from 3D clusters to index in the slice list
clusterToPfoMap	the mapping from 3D clusters to parent pfos
sliceList	the list containing slices to be populated with 2D hits
assignedClusters	to receive the list of 2D clusters with hits assigned to slices

Definition at line 445 of file EventSlicingTool.cc.

 {
     ClusterList clusterList;
     for (const auto &mapEntry : clusterToSliceIndexMap)
         clusterList.push_back(mapEntry.first);
     clusterList.sort(LArClusterHelper::SortByNHits);
 
     for (const Cluster *const pCluster3D : clusterList)
     {
         const unsigned int index(clusterToSliceIndexMap.at(pCluster3D));
 
         const Pfo *const pPfo(clusterToPfoMap.at(pCluster3D));
         Slice &slice(sliceList.at(index));
 
         ClusterList clusters2D;
         LArPfoHelper::GetTwoDClusterList(pPfo, clusters2D);
 
         for (const Cluster *const pCluster2D : clusters2D)
         {
             const HitType hitType(LArClusterHelper::GetClusterHitType(pCluster2D));
 
             if ((TPC_VIEW_U != hitType) && (TPC_VIEW_V != hitType) && (TPC_VIEW_W != hitType))
                 throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
 
             CaloHitList &targetList((TPC_VIEW_U == hitType) ? slice.m_caloHitListU : (TPC_VIEW_V == hitType) ? slice.m_caloHitListV : slice.m_caloHitListW);
 
             pCluster2D->GetOrderedCaloHitList().FillCaloHitList(targetList);
             targetList.insert(targetList.end(), pCluster2D->GetIsolatedCaloHitList().begin(), pCluster2D->GetIsolatedCaloHitList().end());
 
             if (!assignedClusters.insert(pCluster2D).second)
                 throw StatusCodeException(STATUS_CODE_ALREADY_PRESENT);
         }
     }
 }

void lar_content::EventSlicingTool::CreateSlices	(	const ClusterSliceList &	clusterSliceList,
		SlicingAlgorithm::SliceList &	sliceList,
		ClusterToSliceIndexMap &	clusterToSliceIndexMap
	)		const

private

Create new slices for each of the groupings of 3D clusters in the provided cluster slice list.

Parameters

clusterSliceList	the list of 3D clusters, divided into slices (one 3D cluster list per slice)
sliceList	the slice list to receive the new slices
clusterToSliceIndexMap	to receive the mapping from 3D clusters to index in the slice list

Definition at line 423 of file EventSlicingTool.cc.

 {
     unsigned int index(0);
 
     for (const ClusterVector &clusterList : clusterSliceList)
     {
         for (const Cluster *const pCluster3D : clusterList)
         {
             if (TPC_3D != LArClusterHelper::GetClusterHitType(pCluster3D))
                 throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
 
             if (!clusterToSliceIndexMap.insert(ClusterToSliceIndexMap::value_type(pCluster3D, index)).second)
                 throw StatusCodeException(STATUS_CODE_ALREADY_PRESENT);
         }
 
         sliceList.push_back(Slice());
         ++index;
     }
 }

void lar_content::EventSlicingTool::GetClusterSliceList	(	const pandora::ClusterList &	trackClusters3D,
		const pandora::ClusterList &	showerClusters3D,
		ClusterSliceList &	clusterSliceList
	)		const

private

Divide the provided lists of 3D track and shower clusters into slices.

Parameters

trackClusters3D	the list of 3D track clusters
showerClusters3D	the list of 3D shower clusters
clusterSliceList	to receive the list of 3D clusters, divided into slices (one 3D cluster list per slice)

Definition at line 170 of file EventSlicingTool.cc.

 {
     const float layerPitch(LArGeometryHelper::GetWireZPitch(this->GetPandora()));
 
     ThreeDSlidingFitResultMap trackFitResults;
 
     for (const Cluster *const pCluster3D : trackClusters3D)
     {
         try
         {
             trackFitResults.insert(
                 ThreeDSlidingFitResultMap::value_type(pCluster3D, ThreeDSlidingFitResult(pCluster3D, m_halfWindowLayers, layerPitch)));
         }
         catch (StatusCodeException &)
         {
             std::cout << "EventSlicingTool: ThreeDSlidingFitResult failure for track cluster." << std::endl;
         }
     }
 
     ThreeDSlidingConeFitResultMap showerConeFitResults;
 
     for (const Cluster *const pCluster3D : showerClusters3D)
     {
         try
         {
             showerConeFitResults.insert(
                 ThreeDSlidingConeFitResultMap::value_type(pCluster3D, ThreeDSlidingConeFitResult(pCluster3D, m_halfWindowLayers, layerPitch)));
         }
         catch (StatusCodeException &)
         {
             std::cout << "EventSlicingTool: ThreeDSlidingConeFitResult failure for shower cluster." << std::endl;
         }
     }
 
     ClusterVector sortedClusters3D(trackClusters3D.begin(), trackClusters3D.end());
     sortedClusters3D.insert(sortedClusters3D.end(), showerClusters3D.begin(), showerClusters3D.end());
     std::sort(sortedClusters3D.begin(), sortedClusters3D.end(), LArClusterHelper::SortByNHits);
 
     ClusterSet usedClusters;
 
     for (const Cluster *const pCluster3D : sortedClusters3D)
     {
         if (usedClusters.count(pCluster3D))
             continue;
 
         if (pCluster3D->GetNCaloHits() < m_min3DHitsToSeedNewSlice)
             continue;
 
         clusterSliceList.push_back(ClusterVector(1, pCluster3D));
         usedClusters.insert(pCluster3D);
 
         ClusterVector &clusterSlice(clusterSliceList.back());
         this->CollectAssociatedClusters(pCluster3D, sortedClusters3D, trackFitResults, showerConeFitResults, clusterSlice, usedClusters);
     }
 }

void lar_content::EventSlicingTool::GetKDTreeEntries2D	(	const SlicingAlgorithm::SliceList &	sliceList,
		PointList &	pointsU,
		PointList &	pointsV,
		PointList &	pointsW,
		PointToSliceIndexMap &	pointToSliceIndexMap
	)		const

private

Use projections of 3D hits already assigned to slices to populate kd trees to aid assignment of remaining clusters.

Parameters

sliceList	the slice list
pointsU	to receive the points in the u view
pointsV	to receive the points in the v view
pointsW	to receive the points in the w view
pointToSliceIndexMap	to receive the mapping from points to slice index

Definition at line 591 of file EventSlicingTool.cc.

 {
     unsigned int sliceIndex(0);
 
     for (const Slice &slice : sliceList)
     {
         for (const CaloHit *const pCaloHit : slice.m_caloHitListU)
         {
             const CartesianVector *const pPoint(new CartesianVector(pCaloHit->GetPositionVector()));
             pointToSliceIndexMap.insert(PointToSliceIndexMap::value_type(pPoint, sliceIndex));
             pointsU.push_back(pPoint);
         }
 
         for (const CaloHit *const pCaloHit : slice.m_caloHitListV)
         {
             const CartesianVector *const pPoint(new CartesianVector(pCaloHit->GetPositionVector()));
             pointToSliceIndexMap.insert(PointToSliceIndexMap::value_type(pPoint, sliceIndex));
             pointsV.push_back(pPoint);
         }
 
         for (const CaloHit *const pCaloHit : slice.m_caloHitListW)
         {
             const CartesianVector *const pPoint(new CartesianVector(pCaloHit->GetPositionVector()));
             pointToSliceIndexMap.insert(PointToSliceIndexMap::value_type(pPoint, sliceIndex));
             pointsW.push_back(pPoint);
         }
 
         ++sliceIndex;
     }
 }

void lar_content::EventSlicingTool::GetKDTreeEntries3D	(	const ClusterToSliceIndexMap &	clusterToSliceIndexMap,
		PointList &	pointsU,
		PointList &	pointsV,
		PointList &	pointsW,
		PointToSliceIndexMap &	pointToSliceIndexMap
	)		const

private

Use 2D hits already assigned to slices to populate kd trees to aid assignment of remaining clusters.

Parameters

clusterToSliceIndexMap	the 3D cluster to slice index map
pointsU	to receive the points in the u view
pointsV	to receive the points in the v view
pointsW	to receive the points in the w view
pointToSliceIndexMap	to receive the mapping from points to slice index

Definition at line 625 of file EventSlicingTool.cc.

 {
     ClusterList clusterList;
     for (const auto &mapEntry : clusterToSliceIndexMap)
         clusterList.push_back(mapEntry.first);
     clusterList.sort(LArClusterHelper::SortByNHits);
 
     for (const Cluster *const pCluster3D : clusterList)
     {
         const unsigned int sliceIndex(clusterToSliceIndexMap.at(pCluster3D));
 
         CaloHitList caloHitList;
         pCluster3D->GetOrderedCaloHitList().FillCaloHitList(caloHitList);
 
         for (const CaloHit *const pCaloHit3D : caloHitList)
         {
             if (TPC_3D != pCaloHit3D->GetHitType())
                 throw StatusCodeException(STATUS_CODE_FAILURE);
 
             const CartesianVector &position3D(pCaloHit3D->GetPositionVector());
 
             const CartesianVector *const pProjectionU(
                 new CartesianVector(LArGeometryHelper::ProjectPosition(this->GetPandora(), position3D, TPC_VIEW_U)));
             const CartesianVector *const pProjectionV(
                 new CartesianVector(LArGeometryHelper::ProjectPosition(this->GetPandora(), position3D, TPC_VIEW_V)));
             const CartesianVector *const pProjectionW(
                 new CartesianVector(LArGeometryHelper::ProjectPosition(this->GetPandora(), position3D, TPC_VIEW_W)));
 
             pointsU.push_back(pProjectionU);
             pointsV.push_back(pProjectionV);
             pointsW.push_back(pProjectionW);
 
             pointToSliceIndexMap.insert(PointToSliceIndexMap::value_type(pProjectionU, sliceIndex));
             pointToSliceIndexMap.insert(PointToSliceIndexMap::value_type(pProjectionV, sliceIndex));
             pointToSliceIndexMap.insert(PointToSliceIndexMap::value_type(pProjectionW, sliceIndex));
         }
     }
 }

void lar_content::EventSlicingTool::GetRemainingClusters	(	const pandora::Algorithm *const	pAlgorithm,
		const SlicingAlgorithm::HitTypeToNameMap &	clusterListNames,
		const pandora::ClusterSet &	assignedClusters,
		pandora::ClusterList &	remainingClusters
	)		const

private

Get the list of 2D clusters with hits yets to be assigned to slices.

Parameters

pAlgorithm	the address of the calling algorithm
clusterListNames	the hit type to cluster list name map
assignedClusters	the list of 2D clusters with hits assigned to slices
remainingClusters	to receive the list of 2D clusters with hits yet to be assigned to slices

void lar_content::EventSlicingTool::GetRemainingClusters	(	const pandora::Algorithm *const	pAlgorithm,
		const std::string &	clusterListName,
		const pandora::ClusterSet &	assignedClusters,
		pandora::ClusterList &	remainingClusters
	)		const

private

Get the list of 2D clusters (from a named 2D cluster list) with hits yets to be assigned to slices.

Parameters

pAlgorithm	the address of the calling algorithm
clusterListName	the cluster list name
assignedClusters	the list of 2D clusters with hits assigned to slices
remainingClusters	to receive the list of 2D clusters with hits yet to be assigned to slices

void lar_content::EventSlicingTool::GetThreeDClusters	(	const pandora::Algorithm *const	pAlgorithm,
		const std::string &	pfoListName,
		pandora::ClusterList &	clusters3D,
		ClusterToPfoMap &	clusterToPfoMap
	)		const

private

Get the 3D clusters from a specified list of pfos, storing the 3D clusters in the provided list and populating a map from 3D cluster to parent pfo.

Parameters

pAlgorithm	the address of the calling algorithm
pfoListName	the pfo list name
clusters3D	to receive the list of 3D clusters
clusterToPfoMap	to receive the mapping from 3D clusters to parent pfos

Definition at line 133 of file EventSlicingTool.cc.

 {
     const PfoList *pPfoList(nullptr);
     PANDORA_THROW_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_INITIALIZED, !=, PandoraContentApi::GetList(*pAlgorithm, pfoListName, pPfoList));
 
     if (!pPfoList || pPfoList->empty())
     {
         if (PandoraContentApi::GetSettings(*pAlgorithm)->ShouldDisplayAlgorithmInfo())
             std::cout << "EventSlicingTool: unable to find pfo list " << pfoListName << std::endl;
 
         return;
     }
 
     for (const ParticleFlowObject *const pPfo : *pPfoList)
     {
         ClusterList pfoClusters3D;
         LArPfoHelper::GetThreeDClusterList(pPfo, pfoClusters3D);
 
         for (const Cluster *const pCluster3D : pfoClusters3D)
         {
             if (pCluster3D->GetNCaloHits() < m_minHitsPer3DCluster)
                 continue;
 
             if (!clusterToPfoMap.insert(ClusterToPfoMap::value_type(pCluster3D, pPfo)).second)
                 throw StatusCodeException(STATUS_CODE_ALREADY_PRESENT);
 
             if (clusters3D.end() != std::find(clusters3D.begin(), clusters3D.end(), pCluster3D))
                 throw StatusCodeException(STATUS_CODE_ALREADY_PRESENT);
 
             clusters3D.push_back(pCluster3D);
         }
     }
 }

bool lar_content::EventSlicingTool::IsEmission	(	const LArPointingCluster &	cluster1,
		const LArPointingCluster &	cluster2
	)		const

private

Check whether a pair of pointing clusters are consistent with an emission.

Parameters

cluster1	the first pointing cluster
cluster2	the second pointing cluster

Returns: whether the pointing clusters are declared to be in the same slice

Definition at line 401 of file EventSlicingTool.cc.

 {
     return (LArPointingClusterHelper::IsEmission(cluster1.GetInnerVertex().GetPosition(), cluster2.GetInnerVertex(),
                 m_minVertexLongitudinalDistance, m_maxVertexLongitudinalDistance, m_maxVertexTransverseDistance, m_vertexAngularAllowance) ||
             LArPointingClusterHelper::IsEmission(cluster1.GetOuterVertex().GetPosition(), cluster2.GetInnerVertex(),
                 m_minVertexLongitudinalDistance, m_maxVertexLongitudinalDistance, m_maxVertexTransverseDistance, m_vertexAngularAllowance) ||
             LArPointingClusterHelper::IsEmission(cluster1.GetInnerVertex().GetPosition(), cluster2.GetOuterVertex(),
                 m_minVertexLongitudinalDistance, m_maxVertexLongitudinalDistance, m_maxVertexTransverseDistance, m_vertexAngularAllowance) ||
             LArPointingClusterHelper::IsEmission(cluster1.GetOuterVertex().GetPosition(), cluster2.GetOuterVertex(),
                 m_minVertexLongitudinalDistance, m_maxVertexLongitudinalDistance, m_maxVertexTransverseDistance, m_vertexAngularAllowance) ||
             LArPointingClusterHelper::IsEmission(cluster2.GetInnerVertex().GetPosition(), cluster1.GetInnerVertex(),
                 m_minVertexLongitudinalDistance, m_maxVertexLongitudinalDistance, m_maxVertexTransverseDistance, m_vertexAngularAllowance) ||
             LArPointingClusterHelper::IsEmission(cluster2.GetOuterVertex().GetPosition(), cluster1.GetInnerVertex(),
                 m_minVertexLongitudinalDistance, m_maxVertexLongitudinalDistance, m_maxVertexTransverseDistance, m_vertexAngularAllowance) ||
             LArPointingClusterHelper::IsEmission(cluster2.GetInnerVertex().GetPosition(), cluster1.GetOuterVertex(),
                 m_minVertexLongitudinalDistance, m_maxVertexLongitudinalDistance, m_maxVertexTransverseDistance, m_vertexAngularAllowance) ||
             LArPointingClusterHelper::IsEmission(cluster2.GetOuterVertex().GetPosition(), cluster1.GetOuterVertex(),
                 m_minVertexLongitudinalDistance, m_maxVertexLongitudinalDistance, m_maxVertexTransverseDistance, m_vertexAngularAllowance));
 }

bool lar_content::EventSlicingTool::IsNode	(	const LArPointingCluster &	cluster1,
		const LArPointingCluster &	cluster2
	)		const

private

Check whether a pair of pointing clusters are nodally associated.

Parameters

cluster1	the first pointing cluster
cluster2	the second pointing cluster

Returns: whether the pointing clusters are declared to be in the same slice

Definition at line 379 of file EventSlicingTool.cc.

 {
     return (LArPointingClusterHelper::IsNode(cluster1.GetInnerVertex().GetPosition(), cluster2.GetInnerVertex(),
                 m_minVertexLongitudinalDistance, m_maxVertexTransverseDistance) ||
             LArPointingClusterHelper::IsNode(cluster1.GetOuterVertex().GetPosition(), cluster2.GetInnerVertex(),
                 m_minVertexLongitudinalDistance, m_maxVertexTransverseDistance) ||
             LArPointingClusterHelper::IsNode(cluster1.GetInnerVertex().GetPosition(), cluster2.GetOuterVertex(),
                 m_minVertexLongitudinalDistance, m_maxVertexTransverseDistance) ||
             LArPointingClusterHelper::IsNode(cluster1.GetOuterVertex().GetPosition(), cluster2.GetOuterVertex(),
                 m_minVertexLongitudinalDistance, m_maxVertexTransverseDistance) ||
             LArPointingClusterHelper::IsNode(cluster2.GetInnerVertex().GetPosition(), cluster1.GetInnerVertex(),
                 m_minVertexLongitudinalDistance, m_maxVertexTransverseDistance) ||
             LArPointingClusterHelper::IsNode(cluster2.GetOuterVertex().GetPosition(), cluster1.GetInnerVertex(),
                 m_minVertexLongitudinalDistance, m_maxVertexTransverseDistance) ||
             LArPointingClusterHelper::IsNode(cluster2.GetInnerVertex().GetPosition(), cluster1.GetOuterVertex(),
                 m_minVertexLongitudinalDistance, m_maxVertexTransverseDistance) ||
             LArPointingClusterHelper::IsNode(cluster2.GetOuterVertex().GetPosition(), cluster1.GetOuterVertex(),
                 m_minVertexLongitudinalDistance, m_maxVertexTransverseDistance));
 }

const EventSlicingTool::PointKDNode2D * lar_content::EventSlicingTool::MatchClusterToSlice	(	const pandora::Cluster *const	pCluster2D,
		PointKDTree2D &	kdTree
	)		const

private

Use the provided kd tree to efficiently identify the most appropriate slice for the provided 2D cluster.

Parameters

pCluster2D	the address of the 2D cluster
kdTree	the kd tree

Returns: the nearest-neighbour point identified by the kd tree

Definition at line 667 of file EventSlicingTool.cc.

 {
     PointList clusterPointList;
     const PointKDNode2D *pBestResultPoint(nullptr);
 
     try
     {
         clusterPointList.push_back(new CartesianVector(pCluster2D->GetCentroid(pCluster2D->GetInnerPseudoLayer())));
         clusterPointList.push_back(new CartesianVector(pCluster2D->GetCentroid(pCluster2D->GetOuterPseudoLayer())));
         clusterPointList.push_back(new CartesianVector(
             (pCluster2D->GetCentroid(pCluster2D->GetInnerPseudoLayer()) + pCluster2D->GetCentroid(pCluster2D->GetOuterPseudoLayer())) * 0.5f));
 
         float bestDistance(std::numeric_limits<float>::max());
 
         for (const CartesianVector *const pClusterPoint : clusterPointList)
         {
             const PointKDNode2D *pResultPoint(nullptr);
             float resultDistance(std::numeric_limits<float>::max());
             const PointKDNode2D targetPoint(pClusterPoint, pClusterPoint->GetX(), pClusterPoint->GetZ());
             kdTree.findNearestNeighbour(targetPoint, pResultPoint, resultDistance);
 
             if (pResultPoint && (resultDistance < bestDistance))
             {
                 pBestResultPoint = pResultPoint;
                 bestDistance = resultDistance;
             }
         }
     }
     catch (...)
     {
         std::cout << "EventSlicingTool::MatchClusterToSlice - exception " << std::endl;
         for (const CartesianVector *const pPoint : clusterPointList)
             delete pPoint;
         throw;
     }
 
     for (const CartesianVector *const pPoint : clusterPointList)
         delete pPoint;
 
     return pBestResultPoint;
 }

bool lar_content::EventSlicingTool::PassPointing	(	const pandora::Cluster *const	pClusterInSlice,
		const pandora::Cluster *const	pCandidateCluster,
		const ThreeDSlidingFitResultMap &	trackFitResults
	)		const

private

Compare the provided clusters to assess whether they are associated via pointing (checks association "both ways")

Parameters

pClusterInSlice	address of a cluster already in the slice
pCandidateCluster	address of the candidate cluster
trackFitResults	the map of sliding fit results for track candidate clusters

Returns: whether an addition to the cluster slice should be made

Definition at line 257 of file EventSlicingTool.cc.

 {
     ThreeDSlidingFitResultMap::const_iterator inSliceIter = trackFitResults.find(pClusterInSlice);
     ThreeDSlidingFitResultMap::const_iterator candidateIter = trackFitResults.find(pCandidateCluster);
 
     if ((trackFitResults.end() == inSliceIter) || (trackFitResults.end() == candidateIter))
         return false;
 
     const LArPointingCluster inSlicePointingCluster(inSliceIter->second);
     const LArPointingCluster candidatePointingCluster(candidateIter->second);
 
     if (this->CheckClosestApproach(inSlicePointingCluster, candidatePointingCluster) ||
         this->IsEmission(inSlicePointingCluster, candidatePointingCluster) || this->IsNode(inSlicePointingCluster, candidatePointingCluster))
     {
         return true;
     }
 
     return false;
 }

bool lar_content::EventSlicingTool::PassProximity	(	const pandora::Cluster *const	pClusterInSlice,
		const pandora::Cluster *const	pCandidateCluster
	)		const

private

Compare the provided clusters to assess whether they are associated via pointing.

Parameters

pClusterInSlice	address of a cluster already in the slice
pCandidateCluster	address of the candidate cluster

Returns: whether an addition to the cluster slice should be made

Definition at line 280 of file EventSlicingTool.cc.

 {
     for (const auto &orderedList1 : pClusterInSlice->GetOrderedCaloHitList())
     {
         for (const CaloHit *const pCaloHit1 : *(orderedList1.second))
         {
             const CartesianVector &positionVector1(pCaloHit1->GetPositionVector());
 
             for (const auto &orderedList2 : pCandidateCluster->GetOrderedCaloHitList())
             {
                 for (const CaloHit *const pCaloHit2 : *(orderedList2.second))
                 {
                     if ((positionVector1 - pCaloHit2->GetPositionVector()).GetMagnitudeSquared() < m_maxHitSeparationSquared)
                         return true;
                 }
             }
         }
     }
 
     return false;
 }

bool lar_content::EventSlicingTool::PassShowerCone	(	const pandora::Cluster *const	pConeCluster,
		const pandora::Cluster *const	pNearbyCluster,
		const ThreeDSlidingConeFitResultMap &	showerConeFitResults
	)		const

private

Compare the provided clusters to assess whether they are associated via cone fits to the shower cluster (single "direction" check)

Parameters

pClusterInSlice	address of a cluster already in the slice
pCandidateCluster	address of the candidate cluster
showerConeFitResults	the map of sliding cone fit results for shower candidate clusters

Returns: whether an addition to the cluster slice should be made

Definition at line 304 of file EventSlicingTool.cc.

 {
     ThreeDSlidingConeFitResultMap::const_iterator fitIter = showerConeFitResults.find(pConeCluster);
 
     if (showerConeFitResults.end() == fitIter)
         return false;
 
     float clusterLength(0.f);
     SimpleConeList simpleConeList;
 
     try
     {
         const ThreeDSlidingConeFitResult &slidingConeFitResult3D(fitIter->second);
         const ThreeDSlidingFitResult &slidingFitResult3D(slidingConeFitResult3D.GetSlidingFitResult());
         slidingConeFitResult3D.GetSimpleConeList(m_nConeFitLayers, m_nConeFits, CONE_BOTH_DIRECTIONS, simpleConeList);
         clusterLength = (slidingFitResult3D.GetGlobalMaxLayerPosition() - slidingFitResult3D.GetGlobalMinLayerPosition()).GetMagnitude();
     }
     catch (const StatusCodeException &)
     {
         return false;
     }
 
     for (const SimpleCone &simpleCone : simpleConeList)
     {
         const float coneLength(std::min(m_coneLengthMultiplier * clusterLength, m_maxConeLength));
 
         if (simpleCone.GetBoundedHitFraction(pNearbyCluster, coneLength, m_coneTanHalfAngle1) < m_coneBoundedFraction1)
             continue;
 
         if (simpleCone.GetBoundedHitFraction(pNearbyCluster, coneLength, m_coneTanHalfAngle2) < m_coneBoundedFraction2)
             continue;
 
         return true;
     }
 
     return false;
 }

StatusCode lar_content::EventSlicingTool::ReadSettings ( const pandora::TiXmlHandle xmlHandle )

private

Definition at line 726 of file EventSlicingTool.cc.

 {
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "TrackPfoListName", m_trackPfoListName));
 
     PANDORA_RETURN_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(xmlHandle, "ShowerPfoListName", m_showerPfoListName));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MinHitsPer3DCluster", m_minHitsPer3DCluster));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "Min3DHitsToSeedNewSlice", m_min3DHitsToSeedNewSlice));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "SlidingFitHalfWindow", m_halfWindowLayers));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "UsePointingAssociation", m_usePointingAssociation));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "MinVertexLongitudinalDistance", m_minVertexLongitudinalDistance));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "MaxVertexLongitudinalDistance", m_maxVertexLongitudinalDistance));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "MaxVertexTransverseDistance", m_maxVertexTransverseDistance));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "VertexAngularAllowance", m_vertexAngularAllowance));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxClosestApproach", m_maxClosestApproach));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxInterceptDistance", m_maxInterceptDistance));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "UseProximityAssociation", m_useProximityAssociation));
 
     float maxHitSeparation = std::sqrt(m_maxHitSeparationSquared);
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxHitSeparation", maxHitSeparation));
     m_maxHitSeparationSquared = maxHitSeparation * maxHitSeparation;
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "UseShowerConeAssociation", m_useShowerConeAssociation));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "NConeFitLayers", m_nConeFitLayers));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "NConeFits", m_nConeFits));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ConeLengthMultiplier", m_coneLengthMultiplier));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "MaxConeLength", m_maxConeLength));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ConeTanHalfAngle1", m_coneTanHalfAngle1));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ConeBoundedFraction1", m_coneBoundedFraction1));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ConeTanHalfAngle2", m_coneTanHalfAngle2));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(xmlHandle, "ConeBoundedFraction2", m_coneBoundedFraction2));
 
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=,
         XmlHelper::ReadValue(xmlHandle, "Use3DProjectionsInHitPickUp", m_use3DProjectionsInHitPickUp));
 
     return STATUS_CODE_SUCCESS;
 }

void lar_content::EventSlicingTool::RunSlicing	(	const pandora::Algorithm *const	pAlgorithm,
		const SlicingAlgorithm::HitTypeToNameMap &	caloHitListNames,
		const SlicingAlgorithm::HitTypeToNameMap &	clusterListNames,
		SlicingAlgorithm::SliceList &	sliceList
	)

virtual

Run the slicing tool.

Parameters

pAlgorithm	address of the calling algorithm
caloHitListNames	the hit type to calo hit list name map
clusterListNames	the hit type to cluster list name map
sliceList	to receive the populated slice list

Implements lar_content::EventSlicingBaseTool.

Definition at line 62 of file EventSlicingTool.cc.

 {
     if (PandoraContentApi::GetSettings(*pAlgorithm)->ShouldDisplayAlgorithmInfo())
         std::cout << "----> Running Algorithm Tool: " << this->GetInstanceName() << ", " << this->GetType() << std::endl;
 
     ClusterToPfoMap clusterToPfoMap;
 
     ClusterList trackClusters3D;
     this->GetThreeDClusters(pAlgorithm, m_trackPfoListName, trackClusters3D, clusterToPfoMap);
 
     ClusterList showerClusters3D;
     this->GetThreeDClusters(pAlgorithm, m_showerPfoListName, showerClusters3D, clusterToPfoMap);
 
     ClusterSliceList clusterSliceList;
     this->GetClusterSliceList(trackClusters3D, showerClusters3D, clusterSliceList);
 
     if (clusterSliceList.size() < 2)
     {
         return this->CopyAllHitsToSingleSlice(pAlgorithm, caloHitListNames, sliceList);
     }
     else
     {
         ClusterToSliceIndexMap clusterToSliceIndexMap;
         this->CreateSlices(clusterSliceList, sliceList, clusterToSliceIndexMap);
 
         ClusterSet assignedClusters;
         this->CopyPfoHitsToSlices(clusterToSliceIndexMap, clusterToPfoMap, sliceList, assignedClusters);
 
         ClusterList remainingClusters;
         this->GetRemainingClusters(pAlgorithm, clusterListNames, assignedClusters, remainingClusters);
 
         this->AssignRemainingHitsToSlices(remainingClusters, clusterToSliceIndexMap, sliceList);
     }
 }

bool lar_content::EventSlicingTool::SortPoints	(	const pandora::CartesianVector *const	pLhs,
		const pandora::CartesianVector *const	pRhs
	)

staticprivate

Sort points (use Z, followed by X, followed by Y)

Parameters

pLhs	address of first point
pRhs	address of second point

Definition at line 711 of file EventSlicingTool.cc.

 {
     const CartesianVector deltaPosition(*pRhs - *pLhs);
 
     if (std::fabs(deltaPosition.GetZ()) > std::numeric_limits<float>::epsilon())
         return (deltaPosition.GetZ() > std::numeric_limits<float>::epsilon());
 
     if (std::fabs(deltaPosition.GetX()) > std::numeric_limits<float>::epsilon())
         return (deltaPosition.GetX() > std::numeric_limits<float>::epsilon());
 
     return (deltaPosition.GetY() > std::numeric_limits<float>::epsilon());
 }

Member Data Documentation

float lar_content::EventSlicingTool::m_coneBoundedFraction1

private

The minimum cluster bounded fraction for association 1.

Definition at line 298 of file EventSlicingTool.h.

float lar_content::EventSlicingTool::m_coneBoundedFraction2

private

The minimum cluster bounded fraction for association 2.

Definition at line 300 of file EventSlicingTool.h.

float lar_content::EventSlicingTool::m_coneLengthMultiplier

private

The cone length multiplier to use when calculating bounded cluster fractions.

Definition at line 295 of file EventSlicingTool.h.

float lar_content::EventSlicingTool::m_coneTanHalfAngle1

private

The cone tan half angle to use when calculating bounded cluster fractions 1.

Definition at line 297 of file EventSlicingTool.h.

float lar_content::EventSlicingTool::m_coneTanHalfAngle2

private

The cone tan half angle to use when calculating bounded cluster fractions 2.

Definition at line 299 of file EventSlicingTool.h.

unsigned int lar_content::EventSlicingTool::m_halfWindowLayers

private

The number of layers to use for half-window of sliding fit.

Definition at line 279 of file EventSlicingTool.h.

float lar_content::EventSlicingTool::m_maxClosestApproach

private

Pointing association: max distance of closest approach between straight line fits.

Definition at line 286 of file EventSlicingTool.h.

float lar_content::EventSlicingTool::m_maxConeLength

private

The maximum allowed cone length to use when calculating bounded cluster fractions.

Definition at line 296 of file EventSlicingTool.h.

float lar_content::EventSlicingTool::m_maxHitSeparationSquared

private

Proximity association: max distance allowed between the closest pair of hits.

Definition at line 290 of file EventSlicingTool.h.

float lar_content::EventSlicingTool::m_maxInterceptDistance

private

Pointing association: max distance from cluster vertex to point of closest approach.

Definition at line 287 of file EventSlicingTool.h.

float lar_content::EventSlicingTool::m_maxVertexLongitudinalDistance

private

Pointing association check: max longitudinal distance cut.

Definition at line 283 of file EventSlicingTool.h.

float lar_content::EventSlicingTool::m_maxVertexTransverseDistance

private

Pointing association check: max transverse distance cut.

Definition at line 284 of file EventSlicingTool.h.

unsigned int lar_content::EventSlicingTool::m_min3DHitsToSeedNewSlice

private

The minimum number of hits in a 3D cluster to seed a new slice.

Definition at line 278 of file EventSlicingTool.h.

unsigned int lar_content::EventSlicingTool::m_minHitsPer3DCluster

private

The minimum number of hits in a 3D cluster to warrant consideration in slicing.

Definition at line 277 of file EventSlicingTool.h.

float lar_content::EventSlicingTool::m_minVertexLongitudinalDistance

private

Pointing association check: min longitudinal distance cut.

Definition at line 282 of file EventSlicingTool.h.

unsigned int lar_content::EventSlicingTool::m_nConeFitLayers

private

The number of layers over which to sum fitted direction to obtain cone fit.

Definition at line 293 of file EventSlicingTool.h.

unsigned int lar_content::EventSlicingTool::m_nConeFits

private

The number of cone fits to perform, spread roughly uniformly along the shower length.

Definition at line 294 of file EventSlicingTool.h.

std::string lar_content::EventSlicingTool::m_showerPfoListName

private

The name of the input shower pfo list.

Definition at line 275 of file EventSlicingTool.h.

std::string lar_content::EventSlicingTool::m_trackPfoListName

private

The name of the input track pfo list.

Definition at line 274 of file EventSlicingTool.h.

bool lar_content::EventSlicingTool::m_use3DProjectionsInHitPickUp

private

Whether to include 3D cluster projections when assigning remaining clusters to slices.

Definition at line 302 of file EventSlicingTool.h.

bool lar_content::EventSlicingTool::m_usePointingAssociation

private

Whether to use pointing association.

Definition at line 281 of file EventSlicingTool.h.

bool lar_content::EventSlicingTool::m_useProximityAssociation

private

Whether to use proximity association.

Definition at line 289 of file EventSlicingTool.h.

bool lar_content::EventSlicingTool::m_useShowerConeAssociation

private

Whether to use shower cone association.

Definition at line 292 of file EventSlicingTool.h.

float lar_content::EventSlicingTool::m_vertexAngularAllowance

private

Pointing association check: pointing angular allowance in degrees.

Definition at line 285 of file EventSlicingTool.h.

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

larpandoracontent/larpandoracontent/LArThreeDReco/LArEventBuilding/EventSlicingTool.h
larpandoracontent/larpandoracontent/LArThreeDReco/LArEventBuilding/EventSlicingTool.cc

Public Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation